refactor: replace `deferred()` from `std/async` with `Promise.withResolvers()` (#21234)

Closes #21041

---------

Signed-off-by: Asher Gomez <ashersaupingomez@gmail.com>

1 files changed, 401 insertions, 377 deletions

diff --git a/cli/tests/unit/serve_test.ts b/cli/tests/unit/serve_test.ts
index 20ad7316d..f99b09377 100644
--- a/cli/tests/unit/serve_test.ts
+++ b/cli/tests/unit/serve_test.ts
@@ -11,8 +11,6 @@ import {
   assertEquals,
   assertStringIncludes,
   assertThrows,
-  Deferred,
-  deferred,
   execCode,
   fail,
   tmpUnixSocketPath,
@@ -37,11 +35,11 @@ function createOnErrorCb(ac: AbortController): (err: unknown) => Response {
   };
 }
 
-function onListen<T>(
-  p: Deferred<T>,
+function onListen(
+  resolve: (value: void | PromiseLike<void>) => void,
 ): ({ hostname, port }: { hostname: string; port: number }) => void {
   return () => {
-    p.resolve();
+    resolve();
   };
 }
 
@@ -56,16 +54,16 @@ async function makeServer(
   }
 > {
   const ac = new AbortController();
-  const listeningPromise = deferred();
+  const { promise, resolve } = Promise.withResolvers<void>();
 
   const server = Deno.serve({
     handler,
     port: servePort,
     signal: ac.signal,
-    onListen: onListen(listeningPromise),
+    onListen: onListen(resolve),
   });
 
-  await listeningPromise;
+  await promise;
   return {
     finished: server.finished,
     abort() {
@@ -95,15 +93,18 @@ Deno.test(async function httpServerShutsDownPortBeforeResolving() {
 Deno.test(
   { permissions: { net: true } },
   async function httpServerShutdownAbruptGuaranteeHttp11() {
-    const promiseQueue: { input: Deferred<string>; out: Deferred<void> }[] = [];
+    const deferredQueue: {
+      input: ReturnType<typeof Promise.withResolvers<string>>;
+      out: ReturnType<typeof Promise.withResolvers<void>>;
+    }[] = [];
     const { finished, abort } = await makeServer((_req) => {
-      const { input, out } = promiseQueue.shift()!;
+      const { input, out } = deferredQueue.shift()!;
       return new Response(
         new ReadableStream({
           async start(controller) {
             controller.enqueue(new Uint8Array([46]));
-            out.resolve(undefined);
-            controller.enqueue(encoder.encode(await input));
+            out.resolve();
+            controller.enqueue(encoder.encode(await input.promise));
             controller.close();
           },
         }),
@@ -115,12 +116,21 @@ Deno.test(
     const w = conn.writable.getWriter();
     const r = conn.readable.getReader();
 
-    const deferred1 = { input: deferred<string>(), out: deferred<void>() };
-    promiseQueue.push(deferred1);
-    const deferred2 = { input: deferred<string>(), out: deferred<void>() };
-    promiseQueue.push(deferred2);
-    const deferred3 = { input: deferred<string>(), out: deferred<void>() };
-    promiseQueue.push(deferred3);
+    const deferred1 = {
+      input: Promise.withResolvers<string>(),
+      out: Promise.withResolvers<void>(),
+    };
+    deferredQueue.push(deferred1);
+    const deferred2 = {
+      input: Promise.withResolvers<string>(),
+      out: Promise.withResolvers<void>(),
+    };
+    deferredQueue.push(deferred2);
+    const deferred3 = {
+      input: Promise.withResolvers<string>(),
+      out: Promise.withResolvers<void>(),
+    };
+    deferredQueue.push(deferred3);
     deferred1.input.resolve("#");
     deferred2.input.resolve("$");
     await w.write(encoder.encode(`GET / HTTP/1.1\nConnection: keep-alive\n\n`));
@@ -133,7 +143,7 @@ Deno.test(
     }
 
     await w.write(encoder.encode(`GET / HTTP/1.1\nConnection: keep-alive\n\n`));
-    await deferred3.out;
+    await deferred3.out.promise;
 
     // This is half served, so wait for the chunk that has the first '.'
     text = "";
@@ -179,15 +189,18 @@ Deno.test(
 Deno.test(
   { permissions: { net: true } },
   async function httpServerShutdownGracefulGuaranteeHttp11() {
-    const promiseQueue: { input: Deferred<string>; out: Deferred<void> }[] = [];
+    const deferredQueue: {
+      input: ReturnType<typeof Promise.withResolvers<string>>;
+      out: ReturnType<typeof Promise.withResolvers<void>>;
+    }[] = [];
     const { finished, shutdown } = await makeServer((_req) => {
-      const { input, out } = promiseQueue.shift()!;
+      const { input, out } = deferredQueue.shift()!;
       return new Response(
         new ReadableStream({
           async start(controller) {
             controller.enqueue(new Uint8Array([46]));
-            out.resolve(undefined);
-            controller.enqueue(encoder.encode(await input));
+            out.resolve();
+            controller.enqueue(encoder.encode(await input.promise));
             controller.close();
           },
         }),
@@ -199,12 +212,21 @@ Deno.test(
     const w = conn.writable.getWriter();
     const r = conn.readable.getReader();
 
-    const deferred1 = { input: deferred<string>(), out: deferred<void>() };
-    promiseQueue.push(deferred1);
-    const deferred2 = { input: deferred<string>(), out: deferred<void>() };
-    promiseQueue.push(deferred2);
-    const deferred3 = { input: deferred<string>(), out: deferred<void>() };
-    promiseQueue.push(deferred3);
+    const deferred1 = {
+      input: Promise.withResolvers<string>(),
+      out: Promise.withResolvers<void>(),
+    };
+    deferredQueue.push(deferred1);
+    const deferred2 = {
+      input: Promise.withResolvers<string>(),
+      out: Promise.withResolvers<void>(),
+    };
+    deferredQueue.push(deferred2);
+    const deferred3 = {
+      input: Promise.withResolvers<string>(),
+      out: Promise.withResolvers<void>(),
+    };
+    deferredQueue.push(deferred3);
     deferred1.input.resolve("#");
     deferred2.input.resolve("$");
     await w.write(encoder.encode(`GET / HTTP/1.1\nConnection: keep-alive\n\n`));
@@ -217,7 +239,7 @@ Deno.test(
     }
 
     await w.write(encoder.encode(`GET / HTTP/1.1\nConnection: keep-alive\n\n`));
-    await deferred3.out;
+    await deferred3.out.promise;
 
     // This is half served, so wait for the chunk that has the first '.'
     text = "";
@@ -266,15 +288,15 @@ Deno.test(
 Deno.test(
   { permissions: { net: true, write: true, read: true } },
   async function httpServerShutdownGracefulResources() {
-    const waitForRequest = deferred();
+    const { promise, resolve } = Promise.withResolvers<void>();
     const { finished, shutdown } = await makeServer(async (_req) => {
-      waitForRequest.resolve(null);
+      resolve();
       await new Promise((r) => setTimeout(r, 10));
       return new Response((await makeTempFile(1024 * 1024)).readable);
     });
 
     const f = fetch(`http://localhost:${servePort}`);
-    await waitForRequest;
+    await promise;
     assertEquals((await (await f).text()).length, 1048576);
     await shutdown();
     await finished;
@@ -285,19 +307,19 @@ Deno.test(
 Deno.test(
   { permissions: { net: true, write: true, read: true } },
   async function httpServerShutdownGracefulResources2() {
-    const waitForAbort = deferred();
-    const waitForRequest = deferred();
+    const waitForAbort = Promise.withResolvers<void>();
+    const waitForRequest = Promise.withResolvers<void>();
     const { finished, shutdown } = await makeServer(async (_req) => {
-      waitForRequest.resolve(null);
-      await waitForAbort;
+      waitForRequest.resolve();
+      await waitForAbort.promise;
       await new Promise((r) => setTimeout(r, 10));
       return new Response((await makeTempFile(1024 * 1024)).readable);
     });
 
     const f = fetch(`http://localhost:${servePort}`);
-    await waitForRequest;
+    await waitForRequest.promise;
     const s = shutdown();
-    waitForAbort.resolve(null);
+    waitForAbort.resolve();
     assertEquals((await (await f).text()).length, 1048576);
     await s;
     await finished;
@@ -357,18 +379,18 @@ Deno.test(
 
 Deno.test(async function httpServerCanResolveHostnames() {
   const ac = new AbortController();
-  const listeningPromise = deferred();
+  const { promise, resolve } = Promise.withResolvers<void>();
 
   const server = Deno.serve({
     handler: (_req) => new Response("ok"),
     hostname: "localhost",
     port: servePort,
     signal: ac.signal,
-    onListen: onListen(listeningPromise),
+    onListen: onListen(resolve),
     onError: createOnErrorCb(ac),
   });
 
-  await listeningPromise;
+  await promise;
   const resp = await fetch(`http://localhost:${servePort}/`, {
     headers: { "connection": "close" },
   });
@@ -380,17 +402,17 @@ Deno.test(async function httpServerCanResolveHostnames() {
 
 Deno.test(async function httpServerRejectsOnAddrInUse() {
   const ac = new AbortController();
-  const listeningPromise = deferred();
+  const { promise, resolve } = Promise.withResolvers<void>();
 
   const server = Deno.serve({
     handler: (_req) => new Response("ok"),
     hostname: "localhost",
     port: servePort,
     signal: ac.signal,
-    onListen: onListen(listeningPromise),
+    onListen: onListen(resolve),
     onError: createOnErrorCb(ac),
   });
-  await listeningPromise;
+  await promise;
 
   assertThrows(
     () =>
@@ -399,7 +421,7 @@ Deno.test(async function httpServerRejectsOnAddrInUse() {
         hostname: "localhost",
         port: servePort,
         signal: ac.signal,
-        onListen: onListen(listeningPromise),
+        onListen: onListen(resolve),
         onError: createOnErrorCb(ac),
       }),
     Deno.errors.AddrInUse,
@@ -410,8 +432,8 @@ Deno.test(async function httpServerRejectsOnAddrInUse() {
 
 Deno.test({ permissions: { net: true } }, async function httpServerBasic() {
   const ac = new AbortController();
-  const promise = deferred();
-  const listeningPromise = deferred();
+  const deferred = Promise.withResolvers<void>();
+  const listeningDeferred = Promise.withResolvers<void>();
 
   const server = Deno.serve({
     handler: async (request, { remoteAddr }) => {
@@ -421,20 +443,20 @@ Deno.test({ permissions: { net: true } }, async function httpServerBasic() {
       assertEquals(new URL(request.url).href, `http://127.0.0.1:${servePort}/`);
       assertEquals(await request.text(), "");
       assertEquals(remoteAddr.hostname, "127.0.0.1");
-      promise.resolve();
+      deferred.resolve();
       return new Response("Hello World", { headers: { "foo": "bar" } });
     },
     port: servePort,
     signal: ac.signal,
-    onListen: onListen(listeningPromise),
+    onListen: onListen(listeningDeferred.resolve),
     onError: createOnErrorCb(ac),
   });
 
-  await listeningPromise;
+  await listeningDeferred.promise;
   const resp = await fetch(`http://127.0.0.1:${servePort}/`, {
     headers: { "connection": "close" },
   });
-  await promise;
+  await deferred.promise;
   const clone = resp.clone();
   const text = await resp.text();
   assertEquals(text, "Hello World");
@@ -450,8 +472,8 @@ Deno.test(
   { permissions: { net: true } },
   async function httpServerOnListener() {
     const ac = new AbortController();
-    const promise = deferred();
-    const listeningPromise = deferred();
+    const deferred = Promise.withResolvers<void>();
+    const listeningDeferred = Promise.withResolvers<void>();
     const listener = Deno.listen({ port: servePort });
     const server = serveHttpOnListener(
       listener,
@@ -466,18 +488,18 @@ Deno.test(
         );
         assertEquals(await request.text(), "");
         assertEquals(remoteAddr.hostname, "127.0.0.1");
-        promise.resolve();
+        deferred.resolve();
         return new Response("Hello World", { headers: { "foo": "bar" } });
       },
       createOnErrorCb(ac),
-      onListen(listeningPromise),
+      onListen(listeningDeferred.resolve),
     );
 
-    await listeningPromise;
+    await listeningDeferred.promise;
     const resp = await fetch(`http://127.0.0.1:${servePort}/`, {
       headers: { "connection": "close" },
     });
-    await promise;
+    await listeningDeferred.promise;
     const clone = resp.clone();
     const text = await resp.text();
     assertEquals(text, "Hello World");
@@ -494,8 +516,8 @@ Deno.test(
   { permissions: { net: true } },
   async function httpServerOnConnection() {
     const ac = new AbortController();
-    const promise = deferred();
-    const listeningPromise = deferred();
+    const deferred = Promise.withResolvers<void>();
+    const listeningDeferred = Promise.withResolvers<void>();
     const listener = Deno.listen({ port: servePort });
     const acceptPromise = listener.accept();
     const fetchPromise = fetch(`http://127.0.0.1:${servePort}/`, {
@@ -515,15 +537,15 @@ Deno.test(
         );
         assertEquals(await request.text(), "");
         assertEquals(remoteAddr.hostname, "127.0.0.1");
-        promise.resolve();
+        deferred.resolve();
         return new Response("Hello World", { headers: { "foo": "bar" } });
       },
       createOnErrorCb(ac),
-      onListen(listeningPromise),
+      onListen(listeningDeferred.resolve),
     );
 
     const resp = await fetchPromise;
-    await promise;
+    await deferred.promise;
     const clone = resp.clone();
     const text = await resp.text();
     assertEquals(text, "Hello World");
@@ -539,7 +561,7 @@ Deno.test(
 
 Deno.test({ permissions: { net: true } }, async function httpServerOnError() {
   const ac = new AbortController();
-  const listeningPromise = deferred();
+  const { promise, resolve } = Promise.withResolvers<void>();
   let requestStash: Request | null;
 
   const server = Deno.serve({
@@ -550,13 +572,13 @@ Deno.test({ permissions: { net: true } }, async function httpServerOnError() {
     },
     port: servePort,
     signal: ac.signal,
-    onListen: onListen(listeningPromise),
+    onListen: onListen(resolve),
     onError: () => {
       return new Response("failed: " + requestStash!.url, { status: 500 });
     },
   });
 
-  await listeningPromise;
+  await promise;
   const resp = await fetch(`http://127.0.0.1:${servePort}/`, {
     headers: { "connection": "close" },
   });
@@ -571,7 +593,7 @@ Deno.test(
   { permissions: { net: true } },
   async function httpServerOnErrorFails() {
     const ac = new AbortController();
-    const listeningPromise = deferred();
+    const { promise, resolve } = Promise.withResolvers<void>();
     // NOTE(bartlomieju): deno lint doesn't know that it's actually used later,
     // but TypeScript can't see that either ¯\_(ツ)_/¯
     // deno-lint-ignore no-unused-vars
@@ -585,13 +607,13 @@ Deno.test(
       },
       port: servePort,
       signal: ac.signal,
-      onListen: onListen(listeningPromise),
+      onListen: onListen(resolve),
       onError: () => {
         throw "again";
       },
     });
 
-    await listeningPromise;
+    await promise;
     const resp = await fetch(`http://127.0.0.1:${servePort}/`, {
       headers: { "connection": "close" },
     });
@@ -605,13 +627,13 @@ Deno.test(
 
 Deno.test({ permissions: { net: true } }, async function httpServerOverload1() {
   const ac = new AbortController();
-  const promise = deferred();
-  const listeningPromise = deferred();
+  const deferred = Promise.withResolvers<void>();
+  const listeningDeferred = Promise.withResolvers<void>();
 
   const server = Deno.serve({
     port: servePort,
     signal: ac.signal,
-    onListen: onListen(listeningPromise),
+    onListen: onListen(listeningDeferred.resolve),
     onError: createOnErrorCb(ac),
   }, async (request) => {
     // FIXME(bartlomieju):
@@ -619,15 +641,15 @@ Deno.test({ permissions: { net: true } }, async function httpServerOverload1() {
     console.log(request);
     assertEquals(new URL(request.url).href, `http://127.0.0.1:${servePort}/`);
     assertEquals(await request.text(), "");
-    promise.resolve();
+    deferred.resolve();
     return new Response("Hello World", { headers: { "foo": "bar" } });
   });
 
-  await listeningPromise;
+  await listeningDeferred.promise;
   const resp = await fetch(`http://127.0.0.1:${servePort}/`, {
     headers: { "connection": "close" },
   });
-  await promise;
+  await deferred.promise;
   const clone = resp.clone();
   const text = await resp.text();
   assertEquals(text, "Hello World");
@@ -640,13 +662,13 @@ Deno.test({ permissions: { net: true } }, async function httpServerOverload1() {
 
 Deno.test({ permissions: { net: true } }, async function httpServerOverload2() {
   const ac = new AbortController();
-  const promise = deferred();
-  const listeningPromise = deferred();
+  const deferred = Promise.withResolvers<void>();
+  const listeningDeferred = Promise.withResolvers<void>();
 
   const server = Deno.serve({
     port: servePort,
     signal: ac.signal,
-    onListen: onListen(listeningPromise),
+    onListen: onListen(listeningDeferred.resolve),
     onError: createOnErrorCb(ac),
   }, async (request) => {
     // FIXME(bartlomieju):
@@ -654,15 +676,15 @@ Deno.test({ permissions: { net: true } }, async function httpServerOverload2() {
     console.log(request);
     assertEquals(new URL(request.url).href, `http://127.0.0.1:${servePort}/`);
     assertEquals(await request.text(), "");
-    promise.resolve();
+    deferred.resolve();
     return new Response("Hello World", { headers: { "foo": "bar" } });
   });
 
-  await listeningPromise;
+  await listeningDeferred.promise;
   const resp = await fetch(`http://127.0.0.1:${servePort}/`, {
     headers: { "connection": "close" },
   });
-  await promise;
+  await deferred.promise;
   const clone = resp.clone();
   const text = await resp.text();
   assertEquals(text, "Hello World");
@@ -750,8 +772,8 @@ Deno.test(
 Deno.test(
   { permissions: { net: true } },
   async function httpLazyHeadersIssue15107() {
-    const promise = deferred();
-    const listeningPromise = deferred();
+    const deferred = Promise.withResolvers<void>();
+    const listeningDeferred = Promise.withResolvers<void>();
     const ac = new AbortController();
 
     let headers: Headers;
@@ -759,16 +781,16 @@ Deno.test(
       handler: async (request) => {
         await request.text();
         headers = request.headers;
-        promise.resolve();
+        deferred.resolve();
         return new Response("");
       },
       port: servePort,
       signal: ac.signal,
-      onListen: onListen(listeningPromise),
+      onListen: onListen(listeningDeferred.resolve),
       onError: createOnErrorCb(ac),
     });
 
-    await listeningPromise;
+    await listeningDeferred.promise;
     const conn = await Deno.connect({ port: servePort });
     // Send GET request with a body + content-length.
     const encoder = new TextEncoder();
@@ -776,7 +798,7 @@ Deno.test(
       `GET / HTTP/1.1\r\nHost: 127.0.0.1:2333\r\nContent-Length: 5\r\n\r\n12345`;
     const writeResult = await conn.write(encoder.encode(body));
     assertEquals(body.length, writeResult);
-    await promise;
+    await deferred.promise;
     conn.close();
     assertEquals(headers!.get("content-length"), "5");
     ac.abort();
@@ -791,23 +813,23 @@ function createUrlTest(
   expected: string,
 ) {
   Deno.test(`httpServerUrl${name}`, async () => {
-    const listeningPromise: Deferred<number> = deferred();
-    const urlPromise = deferred();
+    const listeningDeferred = Promise.withResolvers<number>();
+    const urlDeferred = Promise.withResolvers<string>();
     const ac = new AbortController();
     const server = Deno.serve({
       handler: (request: Request) => {
-        urlPromise.resolve(request.url);
+        urlDeferred.resolve(request.url);
         return new Response("");
       },
       port: 0,
       signal: ac.signal,
       onListen: ({ port }: { port: number }) => {
-        listeningPromise.resolve(port);
+        listeningDeferred.resolve(port);
       },
       onError: createOnErrorCb(ac),
     });
 
-    const port = await listeningPromise;
+    const port = await listeningDeferred.promise;
     const conn = await Deno.connect({ port });
 
     const encoder = new TextEncoder();
@@ -822,7 +844,7 @@ function createUrlTest(
         "PORT",
         `${port}`,
       );
-      assertEquals(await urlPromise, expectedResult);
+      assertEquals(await urlDeferred.promise, expectedResult);
     } finally {
       ac.abort();
       await server.finished;
@@ -890,23 +912,23 @@ createUrlTest(
 Deno.test(
   { permissions: { net: true } },
   async function httpServerGetRequestBody() {
-    const promise = deferred();
+    const deferred = Promise.withResolvers<void>();
     const ac = new AbortController();
-    const listeningPromise = deferred();
+    const listeningDeferred = Promise.withResolvers<void>();
 
     const server = Deno.serve({
       handler: (request) => {
         assertEquals(request.body, null);
-        promise.resolve();
+        deferred.resolve();
         return new Response("", { headers: {} });
       },
       port: servePort,
       signal: ac.signal,
-      onListen: onListen(listeningPromise),
+      onListen: onListen(listeningDeferred.resolve),
       onError: createOnErrorCb(ac),
     });
 
-    await listeningPromise;
+    await listeningDeferred.promise;
     const conn = await Deno.connect({ port: servePort });
     // Send GET request with a body + content-length.
     const encoder = new TextEncoder();
@@ -921,7 +943,7 @@ Deno.test(
     assert(readResult > 0);
 
     conn.close();
-    await promise;
+    await deferred.promise;
     ac.abort();
     await server.finished;
   },
@@ -930,26 +952,26 @@ Deno.test(
 Deno.test(
   { permissions: { net: true } },
   async function httpServerAbortedRequestBody() {
-    const promise = deferred();
+    const deferred = Promise.withResolvers<void>();
     const ac = new AbortController();
-    const listeningPromise = deferred();
+    const listeningDeferred = Promise.withResolvers<void>();
 
     const server = Deno.serve({
       handler: async (request) => {
         await assertRejects(async () => {
           await request.text();
         });
-        promise.resolve();
+        deferred.resolve();
         // Not actually used
         return new Response();
       },
       port: servePort,
       signal: ac.signal,
-      onListen: onListen(listeningPromise),
+      onListen: onListen(listeningDeferred.resolve),
       onError: createOnErrorCb(ac),
     });
 
-    await listeningPromise;
+    await listeningDeferred.promise;
     const conn = await Deno.connect({ port: servePort });
     // Send POST request with a body + content-length, but don't send it all
     const encoder = new TextEncoder();
@@ -958,7 +980,7 @@ Deno.test(
     const writeResult = await conn.write(encoder.encode(body));
     assertEquals(body.length, writeResult);
     conn.close();
-    await promise;
+    await deferred.promise;
     ac.abort();
     await server.finished;
   },
@@ -997,19 +1019,19 @@ function createStreamTest(count: number, delay: number, action: string) {
 
   Deno.test(`httpServerStreamCount${count}Delay${delay}${action}`, async () => {
     const ac = new AbortController();
-    const listeningPromise = deferred();
+    const { promise, resolve } = Promise.withResolvers<void>();
     const server = Deno.serve({
       handler: (_request) => {
         return new Response(makeStream(count, delay));
       },
       port: servePort,
       signal: ac.signal,
-      onListen: onListen(listeningPromise),
+      onListen: onListen(resolve),
       onError: createOnErrorCb(ac),
     });
 
     try {
-      await listeningPromise;
+      await promise;
       const resp = await fetch(`http://127.0.0.1:${servePort}/`);
       if (action == "Throw") {
         await assertRejects(async () => {
@@ -1050,7 +1072,7 @@ Deno.test(
     writer.write(new TextEncoder().encode("hello "));
     writer.write(new TextEncoder().encode("world"));
     writer.close();
-    const listeningPromise = deferred();
+    const { promise, resolve } = Promise.withResolvers<void>();
     const ac = new AbortController();
     const server = Deno.serve({
       handler: async (request) => {
@@ -1060,11 +1082,11 @@ Deno.test(
       },
       port: servePort,
       signal: ac.signal,
-      onListen: onListen(listeningPromise),
+      onListen: onListen(resolve),
       onError: createOnErrorCb(ac),
     });
 
-    await listeningPromise;
+    await promise;
     const resp = await fetch(`http://127.0.0.1:${servePort}/`, {
       body: stream.readable,
       method: "POST",
@@ -1079,15 +1101,15 @@ Deno.test(
 
 Deno.test({ permissions: { net: true } }, async function httpServerClose() {
   const ac = new AbortController();
-  const listeningPromise = deferred();
+  const { promise, resolve } = Promise.withResolvers<void>();
   const server = Deno.serve({
     handler: () => new Response("ok"),
     port: servePort,
     signal: ac.signal,
-    onListen: onListen(listeningPromise),
+    onListen: onListen(resolve),
     onError: createOnErrorCb(ac),
   });
-  await listeningPromise;
+  await promise;
   const client = await Deno.connect({ port: servePort });
   client.close();
   ac.abort();
@@ -1097,31 +1119,31 @@ Deno.test({ permissions: { net: true } }, async function httpServerClose() {
 // https://github.com/denoland/deno/issues/15427
 Deno.test({ permissions: { net: true } }, async function httpServerCloseGet() {
   const ac = new AbortController();
-  const listeningPromise = deferred();
-  const requestPromise = deferred();
-  const responsePromise = deferred();
+  const listeningDeferred = Promise.withResolvers<void>();
+  const requestDeferred = Promise.withResolvers<void>();
+  const responseDeferred = Promise.withResolvers<void>();
   const server = Deno.serve({
     handler: async () => {
-      requestPromise.resolve();
+      requestDeferred.resolve();
       await new Promise((r) => setTimeout(r, 500));
-      responsePromise.resolve();
+      responseDeferred.resolve();
       return new Response("ok");
     },
     port: servePort,
     signal: ac.signal,
-    onListen: onListen(listeningPromise),
+    onListen: onListen(listeningDeferred.resolve),
     onError: createOnErrorCb(ac),
   });
-  await listeningPromise;
+  await listeningDeferred.promise;
   const conn = await Deno.connect({ port: servePort });
   const encoder = new TextEncoder();
   const body =
     `GET / HTTP/1.1\r\nHost: example.domain\r\nConnection: close\r\n\r\n`;
   const writeResult = await conn.write(encoder.encode(body));
   assertEquals(body.length, writeResult);
-  await requestPromise;
+  await requestDeferred.promise;
   conn.close();
-  await responsePromise;
+  await responseDeferred.promise;
   ac.abort();
   await server.finished;
 });
@@ -1131,16 +1153,16 @@ Deno.test(
   { permissions: { net: true } },
   async function httpServerEmptyBlobResponse() {
     const ac = new AbortController();
-    const listeningPromise = deferred();
+    const { promise, resolve } = Promise.withResolvers<void>();
     const server = Deno.serve({
       handler: () => new Response(new Blob([])),
       port: servePort,
       signal: ac.signal,
-      onListen: onListen(listeningPromise),
+      onListen: onListen(resolve),
       onError: createOnErrorCb(ac),
     });
 
-    await listeningPromise;
+    await promise;
     const resp = await fetch(`http://127.0.0.1:${servePort}/`);
     const respBody = await resp.text();
 
@@ -1155,8 +1177,8 @@ Deno.test(
   { permissions: { net: true } },
   async function httpServerIncorrectChunkedResponse() {
     const ac = new AbortController();
-    const listeningPromise = deferred();
-    const errorPromise = deferred();
+    const listeningDeferred = Promise.withResolvers<void>();
+    const errorDeferred = Promise.withResolvers<void>();
     const server = Deno.serve({
       handler: () => {
         const body = new ReadableStream({
@@ -1171,22 +1193,22 @@ Deno.test(
       },
       port: servePort,
       signal: ac.signal,
-      onListen: onListen(listeningPromise),
+      onListen: onListen(listeningDeferred.resolve),
       onError: (err) => {
         const errResp = new Response(
           `Internal server error: ${(err as Error).message}`,
           { status: 500 },
         );
-        errorPromise.resolve();
+        errorDeferred.resolve();
         return errResp;
       },
     });
 
-    await listeningPromise;
+    await listeningDeferred.promise;
     const resp = await fetch(`http://127.0.0.1:${servePort}/`);
     // Incorrectly implemented reader ReadableStream should reject.
     assertStringIncludes(await resp.text(), "Failed to execute 'enqueue'");
-    await errorPromise;
+    await errorDeferred.promise;
     ac.abort();
     await server.finished;
   },
@@ -1196,17 +1218,17 @@ Deno.test(
   { permissions: { net: true } },
   async function httpServerCorrectLengthForUnicodeString() {
     const ac = new AbortController();
-    const listeningPromise = deferred();
+    const { promise, resolve } = Promise.withResolvers<void>();
 
     const server = Deno.serve({
       handler: () => new Response("韓國".repeat(10)),
       port: servePort,
       signal: ac.signal,
-      onListen: onListen(listeningPromise),
+      onListen: onListen(resolve),
       onError: createOnErrorCb(ac),
     });
 
-    await listeningPromise;
+    await promise;
     const conn = await Deno.connect({ port: servePort });
     const encoder = new TextEncoder();
     const decoder = new TextDecoder();
@@ -1231,8 +1253,8 @@ Deno.test(
 
 Deno.test({ permissions: { net: true } }, async function httpServerWebSocket() {
   const ac = new AbortController();
-  const listeningPromise = deferred();
-  const done = deferred();
+  const listeningDeferred = Promise.withResolvers<void>();
+  const doneDeferred = Promise.withResolvers<void>();
   const server = Deno.serve({
     handler: (request) => {
       const {
@@ -1247,17 +1269,17 @@ Deno.test({ permissions: { net: true } }, async function httpServerWebSocket() {
         socket.send(m.data);
         socket.close(1001);
       };
-      socket.onclose = () => done.resolve();
+      socket.onclose = () => doneDeferred.resolve();
       return response;
     },
     port: servePort,
     signal: ac.signal,
-    onListen: onListen(listeningPromise),
+    onListen: onListen(listeningDeferred.resolve),
     onError: createOnErrorCb(ac),
   });
 
-  await listeningPromise;
-  const def = deferred();
+  await listeningDeferred.promise;
+  const def = Promise.withResolvers<void>();
   const ws = new WebSocket(`ws://localhost:${servePort}`);
   ws.onmessage = (m) => assertEquals(m.data, "foo");
   ws.onerror = (e) => {
@@ -1267,8 +1289,8 @@ Deno.test({ permissions: { net: true } }, async function httpServerWebSocket() {
   ws.onclose = () => def.resolve();
   ws.onopen = () => ws.send("foo");
 
-  await def;
-  await done;
+  await def.promise;
+  await doneDeferred.promise;
   ac.abort();
   await server.finished;
 });
@@ -1277,7 +1299,7 @@ Deno.test(
   { permissions: { net: true } },
   async function httpServerWebSocketRaw() {
     const ac = new AbortController();
-    const listeningPromise = deferred();
+    const { promise, resolve } = Promise.withResolvers<void>();
     const server = Deno.serve({
       handler: async (request) => {
         const { conn, response } = upgradeHttpRaw(request);
@@ -1307,11 +1329,11 @@ Deno.test(
       },
       port: servePort,
       signal: ac.signal,
-      onListen: onListen(listeningPromise),
+      onListen: onListen(resolve),
       onError: createOnErrorCb(ac),
     });
 
-    await listeningPromise;
+    await promise;
 
     const conn = await Deno.connect({ port: servePort });
     await conn.write(
@@ -1356,8 +1378,8 @@ Deno.test(
   { permissions: { net: true } },
   async function httpServerWebSocketUpgradeTwice() {
     const ac = new AbortController();
-    const done = deferred();
-    const listeningPromise = deferred();
+    const done = Promise.withResolvers<void>();
+    const listeningDeferred = Promise.withResolvers<void>();
     const server = Deno.serve({
       handler: (request) => {
         const {
@@ -1384,12 +1406,12 @@ Deno.test(
       },
       port: servePort,
       signal: ac.signal,
-      onListen: onListen(listeningPromise),
+      onListen: onListen(listeningDeferred.resolve),
       onError: createOnErrorCb(ac),
     });
 
-    await listeningPromise;
-    const def = deferred();
+    await listeningDeferred.promise;
+    const def = Promise.withResolvers<void>();
     const ws = new WebSocket(`ws://localhost:${servePort}`);
     ws.onmessage = (m) => assertEquals(m.data, "foo");
     ws.onerror = (e) => {
@@ -1399,8 +1421,8 @@ Deno.test(
     ws.onclose = () => def.resolve();
     ws.onopen = () => ws.send("foo");
 
-    await def;
-    await done;
+    await def.promise;
+    await done.promise;
     ac.abort();
     await server.finished;
   },
@@ -1410,8 +1432,8 @@ Deno.test(
   { permissions: { net: true } },
   async function httpServerWebSocketCloseFast() {
     const ac = new AbortController();
-    const done = deferred();
-    const listeningPromise = deferred();
+    const done = Promise.withResolvers<void>();
+    const listeningDeferred = Promise.withResolvers<void>();
     const server = Deno.serve({
       handler: (request) => {
         const {
@@ -1424,12 +1446,12 @@ Deno.test(
       },
       port: servePort,
       signal: ac.signal,
-      onListen: onListen(listeningPromise),
+      onListen: onListen(listeningDeferred.resolve),
       onError: createOnErrorCb(ac),
     });
 
-    await listeningPromise;
-    const def = deferred();
+    await listeningDeferred.promise;
+    const def = Promise.withResolvers<void>();
     const ws = new WebSocket(`ws://localhost:${servePort}`);
     ws.onerror = (e) => {
       console.error(e);
@@ -1437,8 +1459,8 @@ Deno.test(
     };
     ws.onclose = () => def.resolve();
 
-    await def;
-    await done;
+    await def.promise;
+    await done.promise;
     ac.abort();
     await server.finished;
   },
@@ -1448,8 +1470,8 @@ Deno.test(
   { permissions: { net: true } },
   async function httpServerWebSocketCanAccessRequest() {
     const ac = new AbortController();
-    const done = deferred();
-    const listeningPromise = deferred();
+    const done = Promise.withResolvers<void>();
+    const listeningDeferred = Promise.withResolvers<void>();
     const server = Deno.serve({
       handler: (request) => {
         const {
@@ -1469,12 +1491,12 @@ Deno.test(
       },
       port: servePort,
       signal: ac.signal,
-      onListen: onListen(listeningPromise),
+      onListen: onListen(listeningDeferred.resolve),
       onError: createOnErrorCb(ac),
     });
 
-    await listeningPromise;
-    const def = deferred();
+    await listeningDeferred.promise;
+    const def = Promise.withResolvers<void>();
     const ws = new WebSocket(`ws://localhost:${servePort}`);
     ws.onmessage = (m) =>
       assertEquals(m.data, `http://localhost:${servePort}/`);
@@ -1485,8 +1507,8 @@ Deno.test(
     ws.onclose = () => def.resolve();
     ws.onopen = () => ws.send("foo");
 
-    await def;
-    await done;
+    await def.promise;
+    await done.promise;
     ac.abort();
     await server.finished;
   },
@@ -1495,24 +1517,24 @@ Deno.test(
 Deno.test(
   { permissions: { net: true } },
   async function httpVeryLargeRequest() {
-    const promise = deferred();
-    const listeningPromise = deferred();
+    const deferred = Promise.withResolvers<void>();
+    const listeningDeferred = Promise.withResolvers<void>();
     const ac = new AbortController();
 
     let headers: Headers;
     const server = Deno.serve({
       handler: (request) => {
         headers = request.headers;
-        promise.resolve();
+        deferred.resolve();
         return new Response("");
       },
       port: servePort,
       signal: ac.signal,
-      onListen: onListen(listeningPromise),
+      onListen: onListen(listeningDeferred.resolve),
       onError: createOnErrorCb(ac),
     });
 
-    await listeningPromise;
+    await listeningDeferred.promise;
     const conn = await Deno.connect({ port: servePort });
     // Send GET request with a body + content-length.
     const encoder = new TextEncoder();
@@ -1521,7 +1543,7 @@ Deno.test(
       `GET / HTTP/1.1\r\nHost: 127.0.0.1:2333\r\nContent-Length: 5\r\nSomething-Else: ${smthElse}\r\n\r\n`;
     const writeResult = await conn.write(encoder.encode(body));
     assertEquals(body.length, writeResult);
-    await promise;
+    await deferred.promise;
     conn.close();
     assertEquals(headers!.get("content-length"), "5");
     assertEquals(headers!.get("something-else"), smthElse);
@@ -1533,8 +1555,8 @@ Deno.test(
 Deno.test(
   { permissions: { net: true } },
   async function httpVeryLargeRequestAndBody() {
-    const promise = deferred();
-    const listeningPromise = deferred();
+    const deferred = Promise.withResolvers<void>();
+    const listeningDeferred = Promise.withResolvers<void>();
     const ac = new AbortController();
 
     let headers: Headers;
@@ -1543,16 +1565,16 @@ Deno.test(
       handler: async (request) => {
         headers = request.headers;
         text = await request.text();
-        promise.resolve();
+        deferred.resolve();
         return new Response("");
       },
       port: servePort,
       signal: ac.signal,
-      onListen: onListen(listeningPromise),
+      onListen: onListen(listeningDeferred.resolve),
       onError: createOnErrorCb(ac),
     });
 
-    await listeningPromise;
+    await listeningDeferred.promise;
     const conn = await Deno.connect({ port: servePort });
     // Send GET request with a body + content-length.
     const encoder = new TextEncoder();
@@ -1566,7 +1588,7 @@ Deno.test(
       body = body.slice(writeResult);
     }
 
-    await promise;
+    await deferred.promise;
     conn.close();
 
     assertEquals(headers!.get("content-length"), `${reqBody.length}`);
@@ -1580,22 +1602,22 @@ Deno.test(
 Deno.test(
   { permissions: { net: true } },
   async function httpConnectionClose() {
-    const promise = deferred();
+    const deferred = Promise.withResolvers<void>();
     const ac = new AbortController();
-    const listeningPromise = deferred();
+    const listeningDeferred = Promise.withResolvers<void>();
 
     const server = Deno.serve({
       handler: () => {
-        promise.resolve();
+        deferred.resolve();
         return new Response("");
       },
       port: servePort,
       signal: ac.signal,
-      onListen: onListen(listeningPromise),
+      onListen: onListen(listeningDeferred.resolve),
       onError: createOnErrorCb(ac),
     });
 
-    await listeningPromise;
+    await listeningDeferred.promise;
     const conn = await Deno.connect({ port: servePort });
     // Send GET request with a body + connection: close.
     const encoder = new TextEncoder();
@@ -1604,7 +1626,7 @@ Deno.test(
     const writeResult = await conn.write(encoder.encode(body));
     assertEquals(body.length, writeResult);
 
-    await promise;
+    await deferred.promise;
     conn.close();
 
     ac.abort();
@@ -1632,14 +1654,14 @@ async function testDuplex(
 Deno.test(
   { permissions: { net: true } },
   async function httpServerStreamDuplexDirect() {
-    const promise = deferred();
+    const { promise, resolve } = Promise.withResolvers<void>();
     const ac = new AbortController();
 
     const server = Deno.serve(
       { port: servePort, signal: ac.signal },
       (request: Request) => {
         assert(request.body);
-        promise.resolve();
+        resolve();
         return new Response(request.body);
       },
     );
@@ -1663,14 +1685,14 @@ Deno.test(
 Deno.test(
   { permissions: { net: true } },
   async function httpServerStreamDuplexJavascript() {
-    const promise = deferred();
+    const { promise, resolve } = Promise.withResolvers<void>();
     const ac = new AbortController();
 
     const server = Deno.serve(
       { port: servePort, signal: ac.signal },
       (request: Request) => {
         assert(request.body);
-        promise.resolve();
+        resolve();
         const reader = request.body.getReader();
         return new Response(
           new ReadableStream({
@@ -1711,16 +1733,16 @@ Deno.test(
     // it before enqueueing subsequent chunk. Issue linked above
     // presented a situation where enqueued chunks were not
     // written to the HTTP connection until the next chunk was enqueued.
-    const listeningPromise = deferred();
-    const promise = deferred();
+    const listeningDeferred = Promise.withResolvers<void>();
+    const deferred = Promise.withResolvers<void>();
     const ac = new AbortController();
 
     let counter = 0;
 
     const deferreds = [
-      deferred(),
-      deferred(),
-      deferred(),
+      Promise.withResolvers<void>(),
+      Promise.withResolvers<void>(),
+      Promise.withResolvers<void>(),
     ];
 
     async function writeRequest(conn: Deno.Conn) {
@@ -1774,7 +1796,7 @@ Deno.test(
             return controller.close();
           }
 
-          await deferreds[counter - 1];
+          await deferreds[counter - 1].promise;
 
           controller.enqueue(`${counter}\n`);
           counter++;
@@ -1784,16 +1806,16 @@ Deno.test(
 
     const server = Deno.serve({
       handler: () => {
-        promise.resolve();
+        deferred.resolve();
         return new Response(periodicStream());
       },
       port: servePort,
       signal: ac.signal,
-      onListen: onListen(listeningPromise),
+      onListen: onListen(listeningDeferred.resolve),
       onError: createOnErrorCb(ac),
     });
 
-    await listeningPromise;
+    await listeningDeferred.promise;
     // start a client
     const clientConn = await Deno.connect({ port: servePort });
 
@@ -1801,7 +1823,7 @@ Deno.test(
     assertEquals(r1, "0\n1\n2\n");
 
     ac.abort();
-    await promise;
+    await deferred.promise;
     await server.finished;
     clientConn.close();
   },
@@ -1852,22 +1874,22 @@ Deno.test(
 Deno.test(
   { permissions: { net: true } },
   async function httpRequestLatin1Headers() {
-    const listeningPromise = deferred();
-    const promise = deferred();
+    const listeningDeferred = Promise.withResolvers<void>();
+    const deferred = Promise.withResolvers<void>();
     const ac = new AbortController();
     const server = Deno.serve({
       handler: (request) => {
         assertEquals(request.headers.get("X-Header-Test"), "á");
-        promise.resolve();
+        deferred.resolve();
         return new Response("hello", { headers: { "X-Header-Test": "Æ" } });
       },
       port: servePort,
       signal: ac.signal,
-      onListen: onListen(listeningPromise),
+      onListen: onListen(listeningDeferred.resolve),
       onError: createOnErrorCb(ac),
     });
 
-    await listeningPromise;
+    await listeningDeferred.promise;
     const clientConn = await Deno.connect({ port: servePort });
     const requestText =
       `GET / HTTP/1.1\r\nHost: 127.0.0.1:${servePort}\r\nX-Header-Test: á\r\n\r\n`;
@@ -1883,7 +1905,7 @@ Deno.test(
     const buf = new Uint8Array(1024);
     await clientConn.read(buf);
 
-    await promise;
+    await deferred.promise;
     const responseText = new TextDecoder("iso-8859-1").decode(buf);
     clientConn.close();
 
@@ -1897,8 +1919,8 @@ Deno.test(
 Deno.test(
   { permissions: { net: true } },
   async function httpServerRequestWithoutPath() {
-    const promise = deferred();
-    const listeningPromise = deferred();
+    const deferred = Promise.withResolvers<void>();
+    const listeningDeferred = Promise.withResolvers<void>();
     const ac = new AbortController();
 
     const server = Deno.serve({
@@ -1906,16 +1928,16 @@ Deno.test(
         // FIXME:
         // assertEquals(new URL(request.url).href, `http://127.0.0.1:${servePort}/`);
         assertEquals(await request.text(), "");
-        promise.resolve();
+        deferred.resolve();
         return new Response("11");
       },
       port: servePort,
       signal: ac.signal,
-      onListen: onListen(listeningPromise),
+      onListen: onListen(listeningDeferred.resolve),
       onError: createOnErrorCb(ac),
     });
 
-    await listeningPromise;
+    await listeningDeferred.promise;
     const clientConn = await Deno.connect({ port: servePort });
 
     async function writeRequest(conn: Deno.Conn) {
@@ -1941,7 +1963,7 @@ Deno.test(
 
     await writeRequest(clientConn);
     clientConn.close();
-    await promise;
+    await deferred.promise;
 
     ac.abort();
     await server.finished;
@@ -1951,25 +1973,25 @@ Deno.test(
 Deno.test(
   { permissions: { net: true } },
   async function httpCookieConcatenation() {
-    const promise = deferred();
-    const listeningPromise = deferred();
+    const deferred = Promise.withResolvers<void>();
+    const listeningDeferred = Promise.withResolvers<void>();
     const ac = new AbortController();
 
     const server = Deno.serve({
       handler: async (request) => {
         assertEquals(await request.text(), "");
         assertEquals(request.headers.get("cookie"), "foo=bar; bar=foo");
-        promise.resolve();
+        deferred.resolve();
         return new Response("ok");
       },
       port: servePort,
       signal: ac.signal,
-      onListen: onListen(listeningPromise),
+      onListen: onListen(listeningDeferred.resolve),
       onError: createOnErrorCb(ac),
       reusePort: true,
     });
 
-    await listeningPromise;
+    await listeningDeferred.promise;
     const resp = await fetch(`http://127.0.0.1:${servePort}/`, {
       headers: [
         ["connection", "close"],
@@ -1977,7 +1999,7 @@ Deno.test(
         ["cookie", "bar=foo"],
       ],
     });
-    await promise;
+    await deferred.promise;
 
     const text = await resp.text();
     assertEquals(text, "ok");
@@ -1993,24 +2015,24 @@ Deno.test(
 Deno.test(
   { permissions: { net: true, run: true } },
   async function httpServerDeleteRequestHasBody() {
-    const promise = deferred();
-    const listeningPromise = deferred();
+    const deferred = Promise.withResolvers<void>();
+    const listeningDeferred = Promise.withResolvers<void>();
     const ac = new AbortController();
 
     const hostname = "localhost";
 
     const server = Deno.serve({
       handler: () => {
-        promise.resolve();
+        deferred.resolve();
         return new Response("ok");
       },
       port: servePort,
       signal: ac.signal,
-      onListen: onListen(listeningPromise),
+      onListen: onListen(listeningDeferred.resolve),
       onError: createOnErrorCb(ac),
     });
 
-    await listeningPromise;
+    await listeningDeferred.promise;
     const url = `http://${hostname}:${servePort}/`;
     const args = ["-X", "DELETE", url];
     const { success } = await new Deno.Command("curl", {
@@ -2019,7 +2041,7 @@ Deno.test(
       stderr: "null",
     }).output();
     assert(success);
-    await promise;
+    await deferred.promise;
     ac.abort();
 
     await server.finished;
@@ -2030,25 +2052,25 @@ Deno.test(
 Deno.test(
   { permissions: { net: true } },
   async function httpServerRespondNonAsciiUint8Array() {
-    const promise = deferred();
-    const listeningPromise = deferred();
+    const deferred = Promise.withResolvers<void>();
+    const listeningDeferred = Promise.withResolvers<void>();
     const ac = new AbortController();
 
     const server = Deno.serve({
       handler: (request) => {
         assertEquals(request.body, null);
-        promise.resolve();
+        deferred.resolve();
         return new Response(new Uint8Array([128]));
       },
       port: servePort,
       signal: ac.signal,
-      onListen: onListen(listeningPromise),
+      onListen: onListen(listeningDeferred.resolve),
       onError: createOnErrorCb(ac),
     });
-    await listeningPromise;
+    await listeningDeferred.resolve;
     const resp = await fetch(`http://localhost:${servePort}/`);
 
-    await promise;
+    await deferred.promise;
 
     assertEquals(resp.status, 200);
     const body = await resp.arrayBuffer();
@@ -2066,30 +2088,30 @@ Deno.test(
 Deno.test(
   { permissions: { net: true } },
   async function httpServerParseRequest() {
-    const promise = deferred();
-    const listeningPromise = deferred();
+    const deferred = Promise.withResolvers<void>();
+    const listeningDeferred = Promise.withResolvers<void>();
     const ac = new AbortController();
 
     const server = Deno.serve({
       handler: (request) => {
         assertEquals(request.method, "GET");
         assertEquals(request.headers.get("host"), "deno.land");
-        promise.resolve();
+        deferred.resolve();
         return new Response("ok");
       },
       port: servePort,
       signal: ac.signal,
-      onListen: onListen(listeningPromise),
+      onListen: onListen(listeningDeferred.resolve),
       onError: createOnErrorCb(ac),
     });
 
-    await listeningPromise;
+    await listeningDeferred.promise;
     const conn = await Deno.connect({ port: servePort });
     const encoder = new TextEncoder();
     const body = `GET /echo HTTP/1.1\r\nHost: deno.land\r\n\r\n`;
     const writeResult = await conn.write(encoder.encode(body));
     assertEquals(body.length, writeResult);
-    await promise;
+    await deferred.promise;
     conn.close();
 
     ac.abort();
@@ -2100,30 +2122,30 @@ Deno.test(
 Deno.test(
   { permissions: { net: true } },
   async function httpServerParseHeaderHtabs() {
-    const promise = deferred();
-    const listeningPromise = deferred();
+    const deferred = Promise.withResolvers<void>();
+    const listeningDeferred = Promise.withResolvers<void>();
     const ac = new AbortController();
 
     const server = Deno.serve({
       handler: (request) => {
         assertEquals(request.method, "GET");
         assertEquals(request.headers.get("server"), "hello\tworld");
-        promise.resolve();
+        deferred.resolve();
         return new Response("ok");
       },
       port: servePort,
       signal: ac.signal,
-      onListen: onListen(listeningPromise),
+      onListen: onListen(listeningDeferred.resolve),
       onError: createOnErrorCb(ac),
     });
 
-    await listeningPromise;
+    await listeningDeferred.promise;
     const conn = await Deno.connect({ port: servePort });
     const encoder = new TextEncoder();
     const body = `GET / HTTP/1.1\r\nserver: hello\tworld\r\n\r\n`;
     const writeResult = await conn.write(encoder.encode(body));
     assertEquals(body.length, writeResult);
-    await promise;
+    await deferred.promise;
     conn.close();
 
     ac.abort();
@@ -2134,24 +2156,24 @@ Deno.test(
 Deno.test(
   { permissions: { net: true } },
   async function httpServerGetShouldIgnoreBody() {
-    const promise = deferred();
-    const listeningPromise = deferred();
+    const deferred = Promise.withResolvers<void>();
+    const listeningDeferred = Promise.withResolvers<void>();
     const ac = new AbortController();
 
     const server = Deno.serve({
       handler: async (request) => {
         assertEquals(request.method, "GET");
         assertEquals(await request.text(), "");
-        promise.resolve();
+        deferred.resolve();
         return new Response("ok");
       },
       port: servePort,
       signal: ac.signal,
-      onListen: onListen(listeningPromise),
+      onListen: onListen(listeningDeferred.resolve),
       onError: createOnErrorCb(ac),
     });
 
-    await listeningPromise;
+    await listeningDeferred.promise;
     const conn = await Deno.connect({ port: servePort });
     const encoder = new TextEncoder();
     // Connection: close = don't try to parse the body as a new request
@@ -2159,7 +2181,7 @@ Deno.test(
       `GET / HTTP/1.1\r\nHost: example.domain\r\nConnection: close\r\n\r\nI shouldn't be read.\r\n`;
     const writeResult = await conn.write(encoder.encode(body));
     assertEquals(body.length, writeResult);
-    await promise;
+    await deferred.promise;
     conn.close();
 
     ac.abort();
@@ -2170,31 +2192,31 @@ Deno.test(
 Deno.test(
   { permissions: { net: true } },
   async function httpServerPostWithBody() {
-    const promise = deferred();
-    const listeningPromise = deferred();
+    const deferred = Promise.withResolvers<void>();
+    const listeningDeferred = Promise.withResolvers<void>();
     const ac = new AbortController();
 
     const server = Deno.serve({
       handler: async (request) => {
         assertEquals(request.method, "POST");
         assertEquals(await request.text(), "I'm a good request.");
-        promise.resolve();
+        deferred.resolve();
         return new Response("ok");
       },
       port: servePort,
       signal: ac.signal,
-      onListen: onListen(listeningPromise),
+      onListen: onListen(listeningDeferred.resolve),
       onError: createOnErrorCb(ac),
     });
 
-    await listeningPromise;
+    await listeningDeferred.promise;
     const conn = await Deno.connect({ port: servePort });
     const encoder = new TextEncoder();
     const body =
       `POST / HTTP/1.1\r\nHost: example.domain\r\nContent-Length: 19\r\n\r\nI'm a good request.`;
     const writeResult = await conn.write(encoder.encode(body));
     assertEquals(body.length, writeResult);
-    await promise;
+    await deferred.promise;
     conn.close();
 
     ac.abort();
@@ -2217,30 +2239,30 @@ function hasHeader(msg: string, name: string): boolean {
 
 function createServerLengthTest(name: string, testCase: TestCase) {
   Deno.test(name, async function () {
-    const promise = deferred();
+    const deferred = Promise.withResolvers<void>();
+    const listeningDeferred = Promise.withResolvers<void>();
     const ac = new AbortController();
-    const listeningPromise = deferred();
 
     const server = Deno.serve({
       handler: (request) => {
         assertEquals(request.method, "GET");
-        promise.resolve();
+        deferred.resolve();
         return new Response(testCase.body, testCase.headers ?? {});
       },
       port: servePort,
       signal: ac.signal,
-      onListen: onListen(listeningPromise),
+      onListen: onListen(listeningDeferred.resolve),
       onError: createOnErrorCb(ac),
     });
 
-    await listeningPromise;
+    await listeningDeferred.promise;
     const conn = await Deno.connect({ port: servePort });
     const encoder = new TextEncoder();
     const body =
       `GET / HTTP/1.1\r\nHost: example.domain\r\nConnection: close\r\n\r\n`;
     const writeResult = await conn.write(encoder.encode(body));
     assertEquals(body.length, writeResult);
-    await promise;
+    await deferred.promise;
 
     const decoder = new TextDecoder();
     let msg = "";
@@ -2349,8 +2371,8 @@ createServerLengthTest("autoResponseWithUnknownLengthEmpty", {
 Deno.test(
   { permissions: { net: true } },
   async function httpServerPostWithContentLengthBody() {
-    const promise = deferred();
-    const listeningPromise = deferred();
+    const deferred = Promise.withResolvers<void>();
+    const listeningDeferred = Promise.withResolvers<void>();
     const ac = new AbortController();
 
     const server = Deno.serve({
@@ -2358,16 +2380,16 @@ Deno.test(
         assertEquals(request.method, "POST");
         assertEquals(request.headers.get("content-length"), "5");
         assertEquals(await request.text(), "hello");
-        promise.resolve();
+        deferred.resolve();
         return new Response("ok");
       },
       port: servePort,
       signal: ac.signal,
-      onListen: onListen(listeningPromise),
+      onListen: onListen(listeningDeferred.resolve),
       onError: createOnErrorCb(ac),
     });
 
-    await listeningPromise;
+    await listeningDeferred.promise;
     const conn = await Deno.connect({ port: servePort });
     const encoder = new TextEncoder();
 
@@ -2375,7 +2397,7 @@ Deno.test(
       `POST / HTTP/1.1\r\nHost: example.domain\r\nContent-Length: 5\r\n\r\nhello`;
     const writeResult = await conn.write(encoder.encode(body));
     assertEquals(body.length, writeResult);
-    await promise;
+    await deferred.promise;
 
     conn.close();
 
@@ -2388,18 +2410,18 @@ Deno.test(
   { permissions: { net: true } },
   async function httpServerPostWithInvalidPrefixContentLength() {
     const ac = new AbortController();
-    const listeningPromise = deferred();
+    const { promise, resolve } = Promise.withResolvers<void>();
     const server = Deno.serve({
       handler: () => {
         throw new Error("unreachable");
       },
       port: servePort,
       signal: ac.signal,
-      onListen: onListen(listeningPromise),
+      onListen: onListen(resolve),
       onError: createOnErrorCb(ac),
     });
 
-    await listeningPromise;
+    await promise;
     const conn = await Deno.connect({ port: servePort });
     const encoder = new TextEncoder();
     const decoder = new TextDecoder();
@@ -2425,24 +2447,24 @@ Deno.test(
 Deno.test(
   { permissions: { net: true } },
   async function httpServerPostWithChunkedBody() {
-    const promise = deferred();
+    const deferred = Promise.withResolvers<void>();
+    const listeningDeferred = Promise.withResolvers<void>();
     const ac = new AbortController();
-    const listeningPromise = deferred();
 
     const server = Deno.serve({
       handler: async (request) => {
         assertEquals(request.method, "POST");
         assertEquals(await request.text(), "qwert");
-        promise.resolve();
+        deferred.resolve();
         return new Response("ok");
       },
       port: servePort,
       signal: ac.signal,
-      onListen: onListen(listeningPromise),
+      onListen: onListen(listeningDeferred.resolve),
       onError: createOnErrorCb(ac),
     });
 
-    await listeningPromise;
+    await listeningDeferred.promise;
     const conn = await Deno.connect({ port: servePort });
     const encoder = new TextEncoder();
 
@@ -2450,7 +2472,7 @@ Deno.test(
       `POST / HTTP/1.1\r\nHost: example.domain\r\nTransfer-Encoding: chunked\r\n\r\n1\r\nq\r\n2\r\nwe\r\n2\r\nrt\r\n0\r\n\r\n`;
     const writeResult = await conn.write(encoder.encode(body));
     assertEquals(body.length, writeResult);
-    await promise;
+    await deferred.promise;
 
     conn.close();
 
@@ -2462,23 +2484,23 @@ Deno.test(
 Deno.test(
   { permissions: { net: true } },
   async function httpServerPostWithIncompleteBody() {
-    const promise = deferred();
+    const deferred = Promise.withResolvers<void>();
+    const listeningDeferred = Promise.withResolvers<void>();
     const ac = new AbortController();
-    const listeningPromise = deferred();
 
     const server = Deno.serve({
       handler: async (r) => {
-        promise.resolve();
+        deferred.resolve();
         assertEquals(await r.text(), "12345");
         return new Response("ok");
       },
       port: servePort,
       signal: ac.signal,
-      onListen: onListen(listeningPromise),
+      onListen: onListen(listeningDeferred.resolve),
       onError: createOnErrorCb(ac),
     });
 
-    await listeningPromise;
+    await listeningDeferred.promise;
     const conn = await Deno.connect({ port: servePort });
     const encoder = new TextEncoder();
 
@@ -2487,7 +2509,7 @@ Deno.test(
     const writeResult = await conn.write(encoder.encode(body));
     assertEquals(body.length, writeResult);
 
-    await promise;
+    await deferred.promise;
     conn.close();
 
     ac.abort();
@@ -2498,22 +2520,22 @@ Deno.test(
 Deno.test(
   { permissions: { net: true } },
   async function httpServerHeadResponseDoesntSendBody() {
-    const promise = deferred();
+    const deferred = Promise.withResolvers<void>();
+    const listeningDeferred = Promise.withResolvers<void>();
     const ac = new AbortController();
-    const listeningPromise = deferred();
 
     const server = Deno.serve({
       handler: () => {
-        promise.resolve();
+        deferred.resolve();
         return new Response("NaN".repeat(100));
       },
       port: servePort,
       signal: ac.signal,
-      onListen: onListen(listeningPromise),
+      onListen: onListen(listeningDeferred.resolve),
       onError: createOnErrorCb(ac),
     });
 
-    await listeningPromise;
+    await listeningDeferred.promise;
     const conn = await Deno.connect({ port: servePort });
     const encoder = new TextEncoder();
     const decoder = new TextDecoder();
@@ -2523,7 +2545,7 @@ Deno.test(
     const writeResult = await conn.write(encoder.encode(body));
     assertEquals(body.length, writeResult);
 
-    await promise;
+    await deferred.promise;
 
     const buf = new Uint8Array(1024);
     const readResult = await conn.read(buf);
@@ -2636,13 +2658,13 @@ for (const testCase of compressionTestCases) {
     { permissions: { net: true, write: true, read: true } },
     {
       [name]: async function () {
-        const promise = deferred();
+        const deferred = Promise.withResolvers<void>();
+        const listeningDeferred = Promise.withResolvers<void>();
         const ac = new AbortController();
-        const listeningPromise = deferred();
         const server = Deno.serve({
           handler: async (_request) => {
             const f = await makeTempFile(testCase.length);
-            promise.resolve();
+            deferred.resolve();
             // deno-lint-ignore no-explicit-any
             const headers = testCase.out as any;
             headers["Content-Length"] = testCase.length.toString();
@@ -2652,15 +2674,15 @@ for (const testCase of compressionTestCases) {
           },
           port: servePort,
           signal: ac.signal,
-          onListen: onListen(listeningPromise),
+          onListen: onListen(listeningDeferred.resolve),
           onError: createOnErrorCb(ac),
         });
         try {
-          await listeningPromise;
+          await listeningDeferred.promise;
           const resp = await fetch(`http://127.0.0.1:${servePort}/`, {
             headers: testCase.in as HeadersInit,
           });
-          await promise;
+          await deferred.promise;
           const body = await resp.arrayBuffer();
           if (testCase.expect == null) {
             assertEquals(body.byteLength, testCase.length);
@@ -2691,9 +2713,9 @@ for (const testCase of compressionTestCases) {
 Deno.test(
   { permissions: { net: true, write: true, read: true } },
   async function httpServerPostFile() {
-    const promise = deferred();
+    const deferred = Promise.withResolvers<void>();
+    const listeningDeferred = Promise.withResolvers<void>();
     const ac = new AbortController();
-    const listeningPromise = deferred();
 
     const server = Deno.serve({
       handler: async (request) => {
@@ -2701,23 +2723,23 @@ Deno.test(
           new Uint8Array(await request.arrayBuffer()),
           makeTempData(70 * 1024),
         );
-        promise.resolve();
+        deferred.resolve();
         return new Response("ok");
       },
       port: servePort,
       signal: ac.signal,
-      onListen: onListen(listeningPromise),
+      onListen: onListen(listeningDeferred.resolve),
       onError: createOnErrorCb(ac),
     });
 
-    await listeningPromise;
+    await listeningDeferred.promise;
     const f = await makeTempFile(70 * 1024);
     const response = await fetch(`http://localhost:${servePort}/`, {
       method: "POST",
       body: f.readable,
     });
 
-    await promise;
+    await deferred.promise;
 
     assertEquals(response.status, 200);
     assertEquals(await response.text(), "ok");
@@ -2737,14 +2759,16 @@ for (const delay of ["delay", "nodelay"]) {
       name: `httpServerTcpCancellation_${url}_${delay}`,
       fn: async function () {
         const ac = new AbortController();
-        const streamCancelled = url == "stream" ? deferred() : undefined;
-        const listeningPromise = deferred();
-        const waitForAbort = deferred();
-        const waitForRequest = deferred();
+        const streamCancelled = url == "stream"
+          ? Promise.withResolvers<void>()
+          : undefined;
+        const listeningDeferred = Promise.withResolvers<void>();
+        const waitForAbort = Promise.withResolvers<void>();
+        const waitForRequest = Promise.withResolvers<void>();
         const server = Deno.serve({
           port: servePort,
           signal: ac.signal,
-          onListen: onListen(listeningPromise),
+          onListen: onListen(listeningDeferred.resolve),
           handler: async (req: Request) => {
             let respBody = null;
             if (req.url.includes("/text")) {
@@ -2764,7 +2788,7 @@ for (const delay of ["delay", "nodelay"]) {
               fail();
             }
             waitForRequest.resolve();
-            await waitForAbort;
+            await waitForAbort.promise;
 
             if (delay == "delay") {
               await new Promise((r) => setTimeout(r, 1000));
@@ -2775,7 +2799,7 @@ for (const delay of ["delay", "nodelay"]) {
           },
         });
 
-        await listeningPromise;
+        await listeningDeferred.promise;
 
         // Create a POST request and drop it once the server has received it
         const conn = await Deno.connect({ port: servePort });
@@ -2783,7 +2807,7 @@ for (const delay of ["delay", "nodelay"]) {
         await writer.write(
           new TextEncoder().encode(`POST /${url} HTTP/1.0\n\n`),
         );
-        await waitForRequest;
+        await waitForRequest.promise;
         await writer.close();
 
         waitForAbort.resolve();
@@ -2807,8 +2831,8 @@ for (const delay of ["delay", "nodelay"]) {
 Deno.test(
   { permissions: { net: true } },
   async function httpServerCancelFetch() {
-    const request2 = deferred();
-    const request2Aborted = deferred();
+    const request2 = Promise.withResolvers<void>();
+    const request2Aborted = Promise.withResolvers<string>();
     const { finished, abort } = await makeServer(async (req) => {
       if (req.url.endsWith("/1")) {
         const fetchRecursive = await fetch(`http://localhost:${servePort}/2`);
@@ -2831,9 +2855,9 @@ Deno.test(
       signal: fetchAbort.signal,
     });
     await fetchPromise;
-    await request2;
+    await request2.promise;
     fetchAbort.abort();
-    assertEquals("resource closed", await request2Aborted);
+    assertEquals("resource closed", await request2Aborted.promise);
 
     abort();
     await finished;
@@ -2844,7 +2868,7 @@ Deno.test(
   { permissions: { read: true, net: true } },
   async function httpServerWithTls() {
     const ac = new AbortController();
-    const listeningPromise = deferred();
+    const { promise, resolve } = Promise.withResolvers<void>();
     const hostname = "127.0.0.1";
 
     const server = Deno.serve({
@@ -2852,13 +2876,13 @@ Deno.test(
       hostname,
       port: servePort,
       signal: ac.signal,
-      onListen: onListen(listeningPromise),
+      onListen: onListen(resolve),
       onError: createOnErrorCb(ac),
       cert: Deno.readTextFileSync("cli/tests/testdata/tls/localhost.crt"),
       key: Deno.readTextFileSync("cli/tests/testdata/tls/localhost.key"),
     });
 
-    await listeningPromise;
+    await promise;
     const caCert = Deno.readTextFileSync("cli/tests/testdata/tls/RootCA.pem");
     const client = Deno.createHttpClient({ caCerts: [caCert] });
     const resp = await fetch(`https://localhost:${servePort}/`, {
@@ -2879,22 +2903,22 @@ Deno.test(
   { permissions: { net: true, write: true, read: true } },
   async function httpServerRequestCLTE() {
     const ac = new AbortController();
-    const listeningPromise = deferred();
-    const promise = deferred();
+    const listeningDeferred = Promise.withResolvers<void>();
+    const deferred = Promise.withResolvers<void>();
 
     const server = Deno.serve({
       handler: async (req) => {
         assertEquals(await req.text(), "");
-        promise.resolve();
+        deferred.resolve();
         return new Response("ok");
       },
       port: servePort,
       signal: ac.signal,
-      onListen: onListen(listeningPromise),
+      onListen: onListen(listeningDeferred.resolve),
       onError: createOnErrorCb(ac),
     });
 
-    await listeningPromise;
+    await listeningDeferred.promise;
     const conn = await Deno.connect({ port: servePort });
     const encoder = new TextEncoder();
 
@@ -2902,7 +2926,7 @@ Deno.test(
       `POST / HTTP/1.1\r\nHost: example.domain\r\nContent-Length: 13\r\nTransfer-Encoding: chunked\r\n\r\n0\r\n\r\nEXTRA`;
     const writeResult = await conn.write(encoder.encode(body));
     assertEquals(body.length, writeResult);
-    await promise;
+    await deferred.promise;
 
     conn.close();
 
@@ -2915,7 +2939,7 @@ Deno.test(
   { permissions: { net: true, write: true, read: true } },
   async function httpServerRequestTETE() {
     const ac = new AbortController();
-    const listeningPromise = deferred();
+    const { promise, resolve } = Promise.withResolvers<void>();
 
     const server = Deno.serve({
       handler: () => {
@@ -2923,7 +2947,7 @@ Deno.test(
       },
       port: servePort,
       signal: ac.signal,
-      onListen: onListen(listeningPromise),
+      onListen: onListen(resolve),
       onError: createOnErrorCb(ac),
     });
 
@@ -2937,7 +2961,7 @@ Deno.test(
       "Transfer-Encoding\n: chunked",
     ];
 
-    await listeningPromise;
+    await promise;
     for (const teHeader of variations) {
       const conn = await Deno.connect({ port: servePort });
       const body =
@@ -2962,18 +2986,18 @@ Deno.test(
 Deno.test(
   { permissions: { net: true } },
   async function httpServer204ResponseDoesntSendContentLength() {
-    const listeningPromise = deferred();
+    const { promise, resolve } = Promise.withResolvers<void>();
     const ac = new AbortController();
     const server = Deno.serve({
       handler: (_request) => new Response(null, { status: 204 }),
       port: servePort,
       signal: ac.signal,
-      onListen: onListen(listeningPromise),
+      onListen: onListen(resolve),
       onError: createOnErrorCb(ac),
     });
 
     try {
-      await listeningPromise;
+      await promise;
       const resp = await fetch(`http://127.0.0.1:${servePort}/`, {
         method: "GET",
         headers: { "connection": "close" },
@@ -2990,22 +3014,22 @@ Deno.test(
 Deno.test(
   { permissions: { net: true } },
   async function httpServer304ResponseDoesntSendBody() {
-    const promise = deferred();
+    const deferred = Promise.withResolvers<void>();
     const ac = new AbortController();
-    const listeningPromise = deferred();
+    const listeningDeferred = Promise.withResolvers<void>();
 
     const server = Deno.serve({
       handler: () => {
-        promise.resolve();
+        deferred.resolve();
         return new Response(null, { status: 304 });
       },
       port: servePort,
       signal: ac.signal,
-      onListen: onListen(listeningPromise),
+      onListen: onListen(listeningDeferred.resolve),
       onError: createOnErrorCb(ac),
     });
 
-    await listeningPromise;
+    await listeningDeferred.promise;
     const conn = await Deno.connect({ port: servePort });
     const encoder = new TextEncoder();
     const decoder = new TextDecoder();
@@ -3015,7 +3039,7 @@ Deno.test(
     const writeResult = await conn.write(encoder.encode(body));
     assertEquals(body.length, writeResult);
 
-    await promise;
+    await deferred.promise;
 
     const buf = new Uint8Array(1024);
     const readResult = await conn.read(buf);
@@ -3035,23 +3059,23 @@ Deno.test(
 Deno.test(
   { permissions: { net: true } },
   async function httpServerExpectContinue() {
-    const promise = deferred();
+    const deferred = Promise.withResolvers<void>();
     const ac = new AbortController();
-    const listeningPromise = deferred();
+    const listeningDeferred = Promise.withResolvers<void>();
 
     const server = Deno.serve({
       handler: async (req) => {
-        promise.resolve();
+        deferred.resolve();
         assertEquals(await req.text(), "hello");
         return new Response(null, { status: 304 });
       },
       port: servePort,
       signal: ac.signal,
-      onListen: onListen(listeningPromise),
+      onListen: onListen(listeningDeferred.resolve),
       onError: createOnErrorCb(ac),
     });
 
-    await listeningPromise;
+    await listeningDeferred.promise;
     const conn = await Deno.connect({ port: servePort });
     const encoder = new TextEncoder();
     const decoder = new TextDecoder();
@@ -3063,7 +3087,7 @@ Deno.test(
       assertEquals(body.length, writeResult);
     }
 
-    await promise;
+    await deferred.promise;
 
     {
       const msgExpected = "HTTP/1.1 100 Continue\r\n\r\n";
@@ -3096,23 +3120,23 @@ Deno.test(
 Deno.test(
   { permissions: { net: true } },
   async function httpServerExpectContinueButNoBodyLOL() {
-    const promise = deferred();
-    const listeningPromise = deferred();
+    const deferred = Promise.withResolvers<void>();
+    const listeningDeferred = Promise.withResolvers<void>();
     const ac = new AbortController();
 
     const server = Deno.serve({
       handler: async (req) => {
-        promise.resolve();
+        deferred.resolve();
         assertEquals(await req.text(), "");
         return new Response(null, { status: 304 });
       },
       port: servePort,
       signal: ac.signal,
-      onListen: onListen(listeningPromise),
+      onListen: onListen(listeningDeferred.resolve),
       onError: createOnErrorCb(ac),
     });
 
-    await listeningPromise;
+    await listeningDeferred.promise;
     const conn = await Deno.connect({ port: servePort });
     const encoder = new TextEncoder();
     const decoder = new TextDecoder();
@@ -3125,7 +3149,7 @@ Deno.test(
       assertEquals(body.length, writeResult);
     }
 
-    await promise;
+    await deferred.promise;
 
     const buf = new Uint8Array(1024);
     const readResult = await conn.read(buf);
@@ -3152,7 +3176,7 @@ for (const [name, req] of badRequests) {
   const testFn = {
     [name]: async () => {
       const ac = new AbortController();
-      const listeningPromise = deferred();
+      const { promise, resolve } = Promise.withResolvers<void>();
 
       const server = Deno.serve({
         handler: () => {
@@ -3160,11 +3184,11 @@ for (const [name, req] of badRequests) {
         },
         port: servePort,
         signal: ac.signal,
-        onListen: onListen(listeningPromise),
+        onListen: onListen(resolve),
         onError: createOnErrorCb(ac),
       });
 
-      await listeningPromise;
+      await promise;
       const conn = await Deno.connect({ port: servePort });
       const encoder = new TextEncoder();
       const decoder = new TextDecoder();
@@ -3197,7 +3221,7 @@ Deno.test(
   { permissions: { net: true } },
   async function httpServerConcurrentRequests() {
     const ac = new AbortController();
-    const listeningPromise = deferred();
+    const { resolve } = Promise.withResolvers<void>();
 
     let reqCount = -1;
     let timerId: number | undefined;
@@ -3230,7 +3254,7 @@ Deno.test(
       },
       port: servePort,
       signal: ac.signal,
-      onListen: onListen(listeningPromise),
+      onListen: onListen(resolve),
       onError: createOnErrorCb(ac),
     });
 
@@ -3271,13 +3295,13 @@ Deno.test(
         throw new Error();
       };
       const ac = new AbortController();
-      const listeningPromise = deferred();
+      const { resolve } = Promise.withResolvers<void>();
       const server = Deno.serve({
         handler: (_req) => new Response("ok"),
         hostname: "localhost",
         port: servePort,
         signal: ac.signal,
-        onListen: onListen(listeningPromise),
+        onListen: onListen(resolve),
         onError: createOnErrorCb(ac),
       });
       ac.abort();
@@ -3294,7 +3318,7 @@ Deno.test(
   { permissions: { net: true } },
   async function testIssue15549() {
     const ac = new AbortController();
-    const promise = deferred();
+    const { promise, resolve } = Promise.withResolvers<void>();
     let count = 0;
     const server = Deno.serve({
       async onListen({ port }: { port: number }) {
@@ -3304,7 +3328,7 @@ Deno.test(
         const res2 = await fetch(`http://localhost:${port}/`);
         assertEquals(await res2.text(), "hello world 2");
 
-        promise.resolve();
+        resolve();
         ac.abort();
       },
       signal: ac.signal,
@@ -3324,7 +3348,7 @@ Deno.test(
   { permissions: { net: true } },
   async function httpServerCanCloneRequest() {
     const ac = new AbortController();
-    const listeningPromise = deferred();
+    const { promise, resolve } = Promise.withResolvers<number>();
 
     const server = Deno.serve({
       handler: async (req) => {
@@ -3352,12 +3376,12 @@ Deno.test(
         return new Response("ok");
       },
       signal: ac.signal,
-      onListen: ({ port }: { port: number }) => listeningPromise.resolve(port),
+      onListen: ({ port }: { port: number }) => resolve(port),
       onError: createOnErrorCb(ac),
     });
 
     try {
-      const port = await listeningPromise;
+      const port = await promise;
       const resp = await fetch(`http://localhost:${port}/`, {
         headers: { connection: "close" },
         method: "POST",
@@ -3378,7 +3402,7 @@ Deno.test(
   { permissions: { net: true } },
   async function shouldThrowIfBodyIsUnusableDisturbed() {
     const ac = new AbortController();
-    const listeningPromise = deferred();
+    const { promise, resolve } = Promise.withResolvers<number>();
 
     const server = Deno.serve({
       handler: async (req) => {
@@ -3400,11 +3424,11 @@ Deno.test(
         return new Response("ok");
       },
       signal: ac.signal,
-      onListen: ({ port }: { port: number }) => listeningPromise.resolve(port),
+      onListen: ({ port }: { port: number }) => resolve(port),
     });
 
     try {
-      const port = await listeningPromise;
+      const port = await promise;
       await fetch(`http://localhost:${port}/`, {
         headers: { connection: "close" },
         method: "POST",
@@ -3431,7 +3455,7 @@ Deno.test({
   permissions: { net: true },
   fn: async function shouldThrowIfBodyIsUnusableLocked() {
     const ac = new AbortController();
-    const listeningPromise = deferred();
+    const { promise, resolve } = Promise.withResolvers<number>();
 
     const server = Deno.serve({
       handler: async (req) => {
@@ -3452,11 +3476,11 @@ Deno.test({
         return new Response("ok");
       },
       signal: ac.signal,
-      onListen: ({ port }: { port: number }) => listeningPromise.resolve(port),
+      onListen: ({ port }: { port: number }) => resolve(port),
     });
 
     try {
-      const port = await listeningPromise;
+      const port = await promise;
       await fetch(`http://localhost:${port}/`, {
         headers: { connection: "close" },
         method: "POST",
@@ -3483,13 +3507,13 @@ Deno.test(
   { permissions: { net: true } },
   async function testIssue16567() {
     const ac = new AbortController();
-    const promise = deferred();
+    const { promise, resolve } = Promise.withResolvers<void>();
     const server = Deno.serve({
       async onListen({ port }) {
         const res1 = await fetch(`http://localhost:${port}/`);
         assertEquals((await res1.text()).length, 40 * 50_000);
 
-        promise.resolve();
+        resolve();
         ac.abort();
       },
       signal: ac.signal,
@@ -3684,7 +3708,7 @@ Deno.test(
   { permissions: { net: true, run: true, read: true }, ignore: true },
   async function httpServerTrailers() {
     const ac = new AbortController();
-    const listeningPromise = deferred();
+    const { resolve } = Promise.withResolvers<void>();
 
     const server = Deno.serve({
       handler: () => {
@@ -3700,7 +3724,7 @@ Deno.test(
       },
       port: servePort,
       signal: ac.signal,
-      onListen: onListen(listeningPromise),
+      onListen: onListen(resolve),
       onError: createOnErrorCb(ac),
     });
 
@@ -3809,7 +3833,7 @@ Deno.test(
     permissions: { run: true, read: true, write: true },
   },
   async function httpServerUnixDomainSocket() {
-    const d = deferred();
+    const { promise, resolve } = Promise.withResolvers<{ path: string }>();
     const ac = new AbortController();
     const filePath = tmpUnixSocketPath();
     const server = Deno.serve(
@@ -3817,7 +3841,7 @@ Deno.test(
         signal: ac.signal,
         path: filePath,
         onListen(info) {
-          d.resolve(info);
+          resolve(info);
         },
         onError: createOnErrorCb(ac),
       },
@@ -3827,7 +3851,7 @@ Deno.test(
       },
     );
 
-    assertEquals(await d, { path: filePath });
+    assertEquals(await promise, { path: filePath });
     assertEquals(
       "hello world!",
       await curlRequest(["--unix-socket", filePath, "http://localhost"]),
@@ -3841,14 +3865,14 @@ Deno.test(
 Deno.test(
   { permissions: { net: true, run: true } },
   async function handleServeCallbackReturn() {
-    const d = deferred();
-    const listeningPromise = deferred();
+    const deferred = Promise.withResolvers<void>();
+    const listeningDeferred = Promise.withResolvers<void>();
     const ac = new AbortController();
 
     const server = Deno.serve(
       {
         port: servePort,
-        onListen: onListen(listeningPromise),
+        onListen: onListen(listeningDeferred.resolve),
         signal: ac.signal,
         onError: (error) => {
           assert(error instanceof TypeError);
@@ -3856,7 +3880,7 @@ Deno.test(
             error.message ===
               "Return value from serve handler must be a response or a promise resolving to a response",
           );
-          d.resolve();
+          deferred.resolve();
           return new Response("Customized Internal Error from onError");
         },
       },
@@ -3865,9 +3889,9 @@ Deno.test(
         return <Response> <unknown> undefined;
       },
     );
-    await listeningPromise;
+    await listeningDeferred.promise;
     const respText = await curlRequest([`http://localhost:${servePort}`]);
-    await d;
+    await deferred.promise;
     ac.abort();
     await server.finished;
     assert(respText === "Customized Internal Error from onError");
@@ -3878,13 +3902,13 @@ Deno.test(
 Deno.test(
   { permissions: { net: true, run: true } },
   async function handleServeErrorCallbackReturn() {
-    const listeningPromise = deferred();
+    const { promise, resolve } = Promise.withResolvers<void>();
     const ac = new AbortController();
 
     const server = Deno.serve(
       {
         port: servePort,
-        onListen: onListen(listeningPromise),
+        onListen: onListen(resolve),
         signal: ac.signal,
         onError: () => {
           // Trick the typechecker
@@ -3896,7 +3920,7 @@ Deno.test(
         return <Response> <unknown> undefined;
       },
     );
-    await listeningPromise;
+    await promise;
     const respText = await curlRequest([`http://localhost:${servePort}`]);
     ac.abort();
     await server.finished;