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

Closes #21041

---------

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

28 files changed, 917 insertions, 917 deletions

diff --git a/cli/tests/testdata/run/tls_connecttls.js b/cli/tests/testdata/run/tls_connecttls.js
index 7c03856cb..bd1d41096 100644
--- a/cli/tests/testdata/run/tls_connecttls.js
+++ b/cli/tests/testdata/run/tls_connecttls.js
@@ -1,4 +1,3 @@
-import { deferred } from "../../../../test_util/std/async/deferred.ts";
 import {
   assert,
   assertEquals,
@@ -9,7 +8,7 @@ import { TextProtoReader } from "./textproto.ts";
 const encoder = new TextEncoder();
 const decoder = new TextDecoder();
 
-const resolvable = deferred();
+const { promise, resolve } = Promise.withResolvers();
 const hostname = "localhost";
 const port = 3505;
 
@@ -32,7 +31,7 @@ listener.accept().then(
     // TODO(bartlomieju): this might be a bug
     setTimeout(() => {
       conn.close();
-      resolvable.resolve();
+      resolve();
     }, 0);
   },
 );
@@ -65,6 +64,6 @@ await r.readFull(bodyBuf);
 assertEquals(decoder.decode(bodyBuf), "Hello World\n");
 conn.close();
 listener.close();
-await resolvable;
+await promise;
 
 console.log("DONE");
diff --git a/cli/tests/testdata/run/tls_starttls.js b/cli/tests/testdata/run/tls_starttls.js
index ecf344211..4acc21461 100644
--- a/cli/tests/testdata/run/tls_starttls.js
+++ b/cli/tests/testdata/run/tls_starttls.js
@@ -1,4 +1,3 @@
-import { deferred } from "../../../../test_util/std/async/deferred.ts";
 import {
   assert,
   assertEquals,
@@ -10,7 +9,7 @@ import { TextProtoReader } from "./textproto.ts";
 const encoder = new TextEncoder();
 const decoder = new TextDecoder();
 
-const resolvable = deferred();
+const { promise, resolve } = Promise.withResolvers();
 const hostname = "localhost";
 const port = 3504;
 
@@ -33,7 +32,7 @@ listener.accept().then(
     // TODO(bartlomieju): this might be a bug
     setTimeout(() => {
       conn.close();
-      resolvable.resolve();
+      resolve();
     }, 0);
   },
 );
@@ -64,6 +63,6 @@ await r.readFull(bodyBuf);
 assertEquals(decoder.decode(bodyBuf), "Hello World\n");
 conn.close();
 listener.close();
-await resolvable;
+await promise;
 
 console.log("DONE");
diff --git a/cli/tests/testdata/run/websocket_server_idletimeout.ts b/cli/tests/testdata/run/websocket_server_idletimeout.ts
index 211b5f6ea..b99c1a61f 100644
--- a/cli/tests/testdata/run/websocket_server_idletimeout.ts
+++ b/cli/tests/testdata/run/websocket_server_idletimeout.ts
@@ -1,8 +1,7 @@
 import { assertEquals } from "../../../../test_util/std/testing/asserts.ts";
-import { deferred } from "../../../../test_util/std/async/deferred.ts";
 
-const errorDeferred = deferred();
-const closeDeferred = deferred();
+const errorDeferred = Promise.withResolvers<void>();
+const closeDeferred = Promise.withResolvers<void>();
 
 const listener = Deno.listen({ port: 4509 });
 console.log("READY");
@@ -21,6 +20,6 @@ socket.onclose = (e) => {
 };
 await respondWith(response);
 
-await errorDeferred;
-await closeDeferred;
+await errorDeferred.promise;
+await closeDeferred.promise;
 listener.close();
diff --git a/cli/tests/testdata/run/websocket_server_multi_field_connection_header_test.ts b/cli/tests/testdata/run/websocket_server_multi_field_connection_header_test.ts
index 709419a6a..d94709767 100644
--- a/cli/tests/testdata/run/websocket_server_multi_field_connection_header_test.ts
+++ b/cli/tests/testdata/run/websocket_server_multi_field_connection_header_test.ts
@@ -1,6 +1,4 @@
-import { deferred } from "../../unit/test_util.ts";
-
-const promise = deferred();
+const { promise, resolve } = Promise.withResolvers<void>();
 const listener = Deno.listen({ port: 4319 });
 console.log("READY");
 const conn = await listener.accept();
@@ -12,6 +10,6 @@ const {
 } = Deno.upgradeWebSocket(request);
 socket.onerror = () => Deno.exit(1);
 socket.onopen = () => socket.close();
-socket.onclose = () => promise.resolve();
+socket.onclose = () => resolve();
 await respondWith(response);
 await promise;
diff --git a/cli/tests/testdata/run/websocket_test.ts b/cli/tests/testdata/run/websocket_test.ts
index 74a369d55..c534db99f 100644
--- a/cli/tests/testdata/run/websocket_test.ts
+++ b/cli/tests/testdata/run/websocket_test.ts
@@ -5,7 +5,6 @@ import {
   assertThrows,
   fail,
 } from "../../../../test_util/std/testing/asserts.ts";
-import { deferred } from "../../../../test_util/std/async/deferred.ts";
 
 Deno.test("invalid scheme", () => {
   assertThrows(() => new WebSocket("foo://localhost:4242"));
@@ -21,7 +20,7 @@ Deno.test("duplicate protocols", () => {
 });
 
 Deno.test("invalid server", async () => {
-  const promise = deferred();
+  const { promise, resolve } = Promise.withResolvers<void>();
   const ws = new WebSocket("ws://localhost:2121");
   let err = false;
   ws.onerror = () => {
@@ -29,7 +28,7 @@ Deno.test("invalid server", async () => {
   };
   ws.onclose = () => {
     if (err) {
-      promise.resolve();
+      resolve();
     } else {
       fail();
     }
@@ -39,20 +38,20 @@ Deno.test("invalid server", async () => {
 });
 
 Deno.test("connect & close", async () => {
-  const promise = deferred();
+  const { promise, resolve } = Promise.withResolvers<void>();
   const ws = new WebSocket("ws://localhost:4242");
   ws.onerror = () => fail();
   ws.onopen = () => {
     ws.close();
   };
   ws.onclose = () => {
-    promise.resolve();
+    resolve();
   };
   await promise;
 });
 
 Deno.test("connect & abort", async () => {
-  const promise = deferred();
+  const { promise, resolve } = Promise.withResolvers<void>();
   const ws = new WebSocket("ws://localhost:4242");
   ws.close();
   let err = false;
@@ -61,7 +60,7 @@ Deno.test("connect & abort", async () => {
   };
   ws.onclose = () => {
     if (err) {
-      promise.resolve();
+      resolve();
     } else {
       fail();
     }
@@ -71,18 +70,18 @@ Deno.test("connect & abort", async () => {
 });
 
 Deno.test("connect & close custom valid code", async () => {
-  const promise = deferred();
+  const { promise, resolve } = Promise.withResolvers<void>();
   const ws = new WebSocket("ws://localhost:4242");
   ws.onerror = () => fail();
   ws.onopen = () => ws.close(1000);
   ws.onclose = () => {
-    promise.resolve();
+    resolve();
   };
   await promise;
 });
 
 Deno.test("connect & close custom invalid code", async () => {
-  const promise = deferred();
+  const { promise, resolve } = Promise.withResolvers<void>();
   const ws = new WebSocket("ws://localhost:4242");
   ws.onerror = () => fail();
   ws.onopen = () => {
@@ -90,24 +89,24 @@ Deno.test("connect & close custom invalid code", async () => {
     ws.close();
   };
   ws.onclose = () => {
-    promise.resolve();
+    resolve();
   };
   await promise;
 });
 
 Deno.test("connect & close custom valid reason", async () => {
-  const promise = deferred();
+  const { promise, resolve } = Promise.withResolvers<void>();
   const ws = new WebSocket("ws://localhost:4242");
   ws.onerror = () => fail();
   ws.onopen = () => ws.close(1000, "foo");
   ws.onclose = () => {
-    promise.resolve();
+    resolve();
   };
   await promise;
 });
 
 Deno.test("connect & close custom invalid reason", async () => {
-  const promise = deferred();
+  const { promise, resolve } = Promise.withResolvers<void>();
   const ws = new WebSocket("ws://localhost:4242");
   ws.onerror = () => fail();
   ws.onopen = () => {
@@ -115,13 +114,13 @@ Deno.test("connect & close custom invalid reason", async () => {
     ws.close();
   };
   ws.onclose = () => {
-    promise.resolve();
+    resolve();
   };
   await promise;
 });
 
 Deno.test("echo string", async () => {
-  const promise = deferred();
+  const { promise, resolve } = Promise.withResolvers<void>();
   const ws = new WebSocket("ws://localhost:4242");
   ws.onerror = () => fail();
   ws.onopen = () => ws.send("foo");
@@ -130,31 +129,31 @@ Deno.test("echo string", async () => {
     ws.close();
   };
   ws.onclose = () => {
-    promise.resolve();
+    resolve();
   };
   await promise;
 });
 
 Deno.test("echo string tls", async () => {
-  const promise1 = deferred();
-  const promise2 = deferred();
+  const deferred1 = Promise.withResolvers<void>();
+  const deferred2 = Promise.withResolvers<void>();
   const ws = new WebSocket("wss://localhost:4243");
   ws.onerror = () => fail();
   ws.onopen = () => ws.send("foo");
   ws.onmessage = (e) => {
     assertEquals(e.data, "foo");
     ws.close();
-    promise1.resolve();
+    deferred1.resolve();
   };
   ws.onclose = () => {
-    promise2.resolve();
+    deferred2.resolve();
   };
-  await promise1;
-  await promise2;
+  await deferred1.promise;
+  await deferred2.promise;
 });
 
 Deno.test("websocket error", async () => {
-  const promise1 = deferred();
+  const { promise, resolve } = Promise.withResolvers<void>();
   const ws = new WebSocket("wss://localhost:4242");
   ws.onopen = () => fail();
   ws.onerror = (err) => {
@@ -163,13 +162,13 @@ Deno.test("websocket error", async () => {
       err.message,
       "NetworkError: failed to connect to WebSocket: received corrupt message of type InvalidContentType",
     );
-    promise1.resolve();
+    resolve();
   };
-  await promise1;
+  await promise;
 });
 
 Deno.test("echo blob with binaryType blob", async () => {
-  const promise = deferred();
+  const { promise, resolve } = Promise.withResolvers<void>();
   const ws = new WebSocket("ws://localhost:4242");
   const blob = new Blob(["foo"]);
   ws.onerror = () => fail();
@@ -183,13 +182,13 @@ Deno.test("echo blob with binaryType blob", async () => {
     ws.close();
   };
   ws.onclose = () => {
-    promise.resolve();
+    resolve();
   };
   await promise;
 });
 
 Deno.test("echo blob with binaryType arraybuffer", async () => {
-  const promise = deferred();
+  const { promise, resolve } = Promise.withResolvers<void>();
   const ws = new WebSocket("ws://localhost:4242");
   ws.binaryType = "arraybuffer";
   const blob = new Blob(["foo"]);
@@ -202,13 +201,13 @@ Deno.test("echo blob with binaryType arraybuffer", async () => {
     ws.close();
   };
   ws.onclose = () => {
-    promise.resolve();
+    resolve();
   };
   await promise;
 });
 
 Deno.test("echo uint8array with binaryType blob", async () => {
-  const promise = deferred();
+  const { promise, resolve } = Promise.withResolvers<void>();
   const ws = new WebSocket("ws://localhost:4242");
   const uint = new Uint8Array([102, 111, 111]);
   ws.onerror = () => fail();
@@ -220,13 +219,13 @@ Deno.test("echo uint8array with binaryType blob", async () => {
     ws.close();
   };
   ws.onclose = () => {
-    promise.resolve();
+    resolve();
   };
   await promise;
 });
 
 Deno.test("echo uint8array with binaryType arraybuffer", async () => {
-  const promise = deferred();
+  const { promise, resolve } = Promise.withResolvers<void>();
   const ws = new WebSocket("ws://localhost:4242");
   ws.binaryType = "arraybuffer";
   const uint = new Uint8Array([102, 111, 111]);
@@ -237,13 +236,13 @@ Deno.test("echo uint8array with binaryType arraybuffer", async () => {
     ws.close();
   };
   ws.onclose = () => {
-    promise.resolve();
+    resolve();
   };
   await promise;
 });
 
 Deno.test("echo arraybuffer with binaryType blob", async () => {
-  const promise = deferred();
+  const { promise, resolve } = Promise.withResolvers<void>();
   const ws = new WebSocket("ws://localhost:4242");
   const buffer = new ArrayBuffer(3);
   ws.onerror = () => fail();
@@ -255,13 +254,13 @@ Deno.test("echo arraybuffer with binaryType blob", async () => {
     ws.close();
   };
   ws.onclose = () => {
-    promise.resolve();
+    resolve();
   };
   await promise;
 });
 
 Deno.test("echo arraybuffer with binaryType arraybuffer", async () => {
-  const promise = deferred();
+  const { promise, resolve } = Promise.withResolvers<void>();
   const ws = new WebSocket("ws://localhost:4242");
   ws.binaryType = "arraybuffer";
   const buffer = new ArrayBuffer(3);
@@ -272,13 +271,13 @@ Deno.test("echo arraybuffer with binaryType arraybuffer", async () => {
     ws.close();
   };
   ws.onclose = () => {
-    promise.resolve();
+    resolve();
   };
   await promise;
 });
 
 Deno.test("Event Handlers order", async () => {
-  const promise = deferred();
+  const { promise, resolve } = Promise.withResolvers<void>();
   const ws = new WebSocket("ws://localhost:4242");
   const arr: number[] = [];
   ws.onerror = () => fail();
@@ -292,18 +291,18 @@ Deno.test("Event Handlers order", async () => {
   ws.onmessage = () => arr.push(2);
   ws.onopen = () => ws.send("Echo");
   ws.onclose = () => {
-    promise.resolve();
+    resolve();
   };
   await promise;
 });
 
 Deno.test("Close without frame", async () => {
-  const promise = deferred();
+  const { promise, resolve } = Promise.withResolvers<void>();
   const ws = new WebSocket("ws://localhost:4244");
   ws.onerror = () => fail();
   ws.onclose = (e) => {
     assertEquals(e.code, 1005);
-    promise.resolve();
+    resolve();
   };
   await promise;
 });
diff --git a/cli/tests/testdata/test/steps/invalid_usage.out b/cli/tests/testdata/test/steps/invalid_usage.out
index 311be4fd7..4b82befae 100644
--- a/cli/tests/testdata/test/steps/invalid_usage.out
+++ b/cli/tests/testdata/test/steps/invalid_usage.out
@@ -68,7 +68,7 @@ error: Started test step with sanitizers while another test step was running:
 
  FAILURES 
 
-capturing => ./test/steps/invalid_usage.ts:3:6
+capturing => ./test/steps/invalid_usage.ts:1:6
 top level missing await ... step => ./test/steps/invalid_usage.ts:[WILDCARD]
 inner missing await ... step ... inner => ./test/steps/invalid_usage.ts:[WILDCARD]
 parallel steps with sanitizers ... step 2 => ./test/steps/invalid_usage.ts:[WILDCARD]
diff --git a/cli/tests/testdata/test/steps/invalid_usage.ts b/cli/tests/testdata/test/steps/invalid_usage.ts
index fcbe8b454..1acfc874c 100644
--- a/cli/tests/testdata/test/steps/invalid_usage.ts
+++ b/cli/tests/testdata/test/steps/invalid_usage.ts
@@ -1,5 +1,3 @@
-import { deferred } from "../../../../../test_util/std/async/deferred.ts";
-
 Deno.test("capturing", async (t) => {
   let capturedContext!: Deno.TestContext;
   await t.step("some step", (t) => {
@@ -32,27 +30,27 @@ Deno.test({
 
 Deno.test("parallel steps with sanitizers", async (t) => {
   // not allowed because steps with sanitizers cannot be run in parallel
-  const step1Entered = deferred();
-  const testFinished = deferred();
+  const step1Entered = Promise.withResolvers<void>();
+  const testFinished = Promise.withResolvers<void>();
   t.step("step 1", async () => {
     step1Entered.resolve();
-    await testFinished;
+    await testFinished.promise;
   });
-  await step1Entered;
+  await step1Entered.promise;
   await t.step("step 2", () => {});
 });
 
 Deno.test("parallel steps when first has sanitizer", async (t) => {
-  const step1Entered = deferred();
-  const step2Finished = deferred();
+  const step1Entered = Promise.withResolvers<void>();
+  const step2Finished = Promise.withResolvers<void>();
   const step1 = t.step({
     name: "step 1",
     fn: async () => {
       step1Entered.resolve();
-      await step2Finished;
+      await step2Finished.promise;
     },
   });
-  await step1Entered;
+  await step1Entered.promise;
   await t.step({
     name: "step 2",
     fn: () => {},
@@ -65,19 +63,19 @@ Deno.test("parallel steps when first has sanitizer", async (t) => {
 });
 
 Deno.test("parallel steps when second has sanitizer", async (t) => {
-  const step1Entered = deferred();
-  const step2Finished = deferred();
+  const step1Entered = Promise.withResolvers<void>();
+  const step2Finished = Promise.withResolvers<void>();
   const step1 = t.step({
     name: "step 1",
     fn: async () => {
       step1Entered.resolve();
-      await step2Finished;
+      await step2Finished.promise;
     },
     sanitizeOps: false,
     sanitizeResources: false,
     sanitizeExit: false,
   });
-  await step1Entered;
+  await step1Entered.promise;
   await t.step({
     name: "step 2",
     fn: async () => {
@@ -91,19 +89,19 @@ Deno.test("parallel steps when second has sanitizer", async (t) => {
 Deno.test({
   name: "parallel steps where only inner tests have sanitizers",
   fn: async (t) => {
-    const step1Entered = deferred();
-    const step2Finished = deferred();
+    const step1Entered = Promise.withResolvers<void>();
+    const step2Finished = Promise.withResolvers<void>();
     const step1 = t.step("step 1", async (t) => {
       await t.step({
         name: "step inner",
         fn: async () => {
           step1Entered.resolve();
-          await step2Finished;
+          await step2Finished.promise;
         },
         sanitizeOps: true,
       });
     });
-    await step1Entered;
+    await step1Entered.promise;
     await t.step("step 2", async (t) => {
       await t.step({
         name: "step inner",
diff --git a/cli/tests/testdata/test/steps/passing_steps.ts b/cli/tests/testdata/test/steps/passing_steps.ts
index 38de116a7..fd145954b 100644
--- a/cli/tests/testdata/test/steps/passing_steps.ts
+++ b/cli/tests/testdata/test/steps/passing_steps.ts
@@ -1,5 +1,3 @@
-import { deferred } from "../../../../../test_util/std/async/deferred.ts";
-
 Deno.test("description", async (t) => {
   const success = await t.step("step 1", async (t) => {
     await t.step("inner 1", () => {});
@@ -107,9 +105,9 @@ Deno.test("steps buffered then streaming reporting", async (t) => {
     name: "step 1",
     fn: async (t) => {
       // also ensure the buffered tests display in order regardless of the second one finishing first
-      const step2Finished = deferred();
+      const step2Finished = Promise.withResolvers<void>();
       const step1 = t.step("step 1 - 1", async () => {
-        await step2Finished;
+        await step2Finished.promise;
       });
       const step2 = t.step("step 1 - 2", async (t) => {
         await t.step("step 1 - 2 - 1", () => {});
diff --git a/cli/tests/testdata/workers/bench_round_robin.ts b/cli/tests/testdata/workers/bench_round_robin.ts
index 062eff7a7..0380d7979 100644
--- a/cli/tests/testdata/workers/bench_round_robin.ts
+++ b/cli/tests/testdata/workers/bench_round_robin.ts
@@ -5,13 +5,8 @@ const data = "HTTP/1.1 200 OK\r\nContent-Length: 12\r\n\r\nHello World\n";
 const workerCount = 4;
 const cmdsPerWorker = 400;
 
-import {
-  Deferred,
-  deferred,
-} from "../../../../test_util/std/async/deferred.ts";
-
 function handleAsyncMsgFromWorker(
-  promiseTable: Map<number, Deferred<string>>,
+  promiseTable: Map<number, ReturnType<typeof Promise.withResolvers<string>>>,
   msg: { cmdId: number; data: string },
 ) {
   const promise = promiseTable.get(msg.cmdId);
@@ -22,15 +17,17 @@ function handleAsyncMsgFromWorker(
 }
 
 async function main() {
-  const workers: Array<[Map<number, Deferred<string>>, Worker]> = [];
+  const workers: Array<
+    [Map<number, ReturnType<typeof Promise.withResolvers<string>>>, Worker]
+  > = [];
   for (let i = 1; i <= workerCount; ++i) {
     const worker = new Worker(
       import.meta.resolve("./bench_worker.ts"),
       { type: "module" },
     );
-    const promise = deferred();
+    const { promise, resolve } = Promise.withResolvers<void>();
     worker.onmessage = (e) => {
-      if (e.data.cmdId === 0) promise.resolve();
+      if (e.data.cmdId === 0) resolve();
     };
     worker.postMessage({ cmdId: 0, action: 2 });
     await promise;
@@ -45,19 +42,19 @@ async function main() {
   for (const cmdId of Array(cmdsPerWorker).keys()) {
     const promises: Array<Promise<string>> = [];
     for (const [promiseTable, worker] of workers) {
-      const promise = deferred<string>();
-      promiseTable.set(cmdId, promise);
+      const deferred = Promise.withResolvers<string>();
+      promiseTable.set(cmdId, deferred);
       worker.postMessage({ cmdId: cmdId, action: 1, data });
-      promises.push(promise);
+      promises.push(deferred.promise);
     }
     for (const promise of promises) {
       await promise;
     }
   }
   for (const [, worker] of workers) {
-    const promise = deferred();
+    const { promise, resolve } = Promise.withResolvers<void>();
     worker.onmessage = (e) => {
-      if (e.data.cmdId === 3) promise.resolve();
+      if (e.data.cmdId === 3) resolve();
     };
     worker.postMessage({ action: 3 });
     await promise;
diff --git a/cli/tests/testdata/workers/test.ts b/cli/tests/testdata/workers/test.ts
index 0ea9a7477..71f56a8c2 100644
--- a/cli/tests/testdata/workers/test.ts
+++ b/cli/tests/testdata/workers/test.ts
@@ -8,7 +8,6 @@ import {
   assertMatch,
   assertThrows,
 } from "../../../../test_util/std/testing/asserts.ts";
-import { deferred } from "../../../../test_util/std/async/deferred.ts";
 
 Deno.test({
   name: "worker terminate",
@@ -22,20 +21,20 @@ Deno.test({
       { type: "module", name: "tsWorker" },
     );
 
-    const promise1 = deferred();
+    const deferred1 = Promise.withResolvers<string>();
     jsWorker.onmessage = (e) => {
-      promise1.resolve(e.data);
+      deferred1.resolve(e.data);
     };
 
-    const promise2 = deferred();
+    const deferred2 = Promise.withResolvers<string>();
     tsWorker.onmessage = (e) => {
-      promise2.resolve(e.data);
+      deferred2.resolve(e.data);
     };
 
     jsWorker.postMessage("Hello World");
-    assertEquals(await promise1, "Hello World");
+    assertEquals(await deferred1.promise, "Hello World");
     tsWorker.postMessage("Hello World");
-    assertEquals(await promise2, "Hello World");
+    assertEquals(await deferred2.promise, "Hello World");
     tsWorker.terminate();
     jsWorker.terminate();
   },
@@ -49,9 +48,9 @@ Deno.test({
       { type: "module", name: "tsWorker" },
     );
 
-    const promise = deferred();
+    const { promise, resolve } = Promise.withResolvers<string>();
     tsWorker.onmessage = (e) => {
-      promise.resolve(e.data);
+      resolve(e.data);
     };
 
     tsWorker.postMessage("Hello World");
@@ -68,9 +67,10 @@ Deno.test({
       { type: "module", name: "nested" },
     );
 
-    const promise = deferred();
+    // deno-lint-ignore no-explicit-any
+    const { promise, resolve } = Promise.withResolvers<any>();
     nestedWorker.onmessage = (e) => {
-      promise.resolve(e.data);
+      resolve(e.data);
     };
 
     nestedWorker.postMessage("Hello World");
@@ -87,11 +87,11 @@ Deno.test({
       { type: "module" },
     );
 
-    const promise = deferred();
+    const { promise, resolve } = Promise.withResolvers<string>();
     // deno-lint-ignore no-explicit-any
     throwingWorker.onerror = (e: any) => {
       e.preventDefault();
-      promise.resolve(e.message);
+      resolve(e.message);
     };
 
     assertMatch(await promise as string, /Uncaught Error: Thrown error/);
@@ -108,9 +108,9 @@ Deno.test({
       workerOptions,
     );
 
-    const promise = deferred();
+    const { promise, resolve } = Promise.withResolvers<string>();
     w.onmessage = (e) => {
-      promise.resolve(e.data);
+      resolve(e.data);
     };
 
     w.postMessage("Hello, world!");
@@ -128,9 +128,9 @@ Deno.test({
       workerOptions,
     );
 
-    const promise = deferred();
+    const { promise, resolve } = Promise.withResolvers<string>();
     w.onmessage = (e) => {
-      promise.resolve(e.data);
+      resolve(e.data);
     };
 
     w.postMessage("Hello, world!");
@@ -147,15 +147,15 @@ Deno.test({
       { type: "module" },
     );
 
-    const promise = deferred();
+    const { promise, resolve, reject } = Promise.withResolvers<string>();
     // deno-lint-ignore no-explicit-any
     fetchingWorker.onerror = (e: any) => {
       e.preventDefault();
-      promise.reject(e.message);
+      reject(e.message);
     };
     // Defer promise.resolve() to allow worker to shut down
     fetchingWorker.onmessage = (e) => {
-      promise.resolve(e.data);
+      resolve(e.data);
     };
 
     assertEquals(await promise, "Done!");
@@ -166,7 +166,7 @@ Deno.test({
 Deno.test({
   name: "worker terminate busy loop",
   fn: async function () {
-    const promise = deferred();
+    const { promise, resolve } = Promise.withResolvers<number>();
 
     const busyWorker = new Worker(
       import.meta.resolve("./busy_worker.js"),
@@ -183,7 +183,7 @@ Deno.test({
           throw new Error("unreachable");
         };
         setTimeout(() => {
-          promise.resolve(testResult);
+          resolve(testResult);
         }, 100);
       }
     };
@@ -198,7 +198,7 @@ Deno.test({
   fn: async function () {
     // See issue for details
     // https://github.com/denoland/deno/issues/4080
-    const promise = deferred();
+    const { promise, resolve } = Promise.withResolvers<void>();
 
     const racyWorker = new Worker(
       import.meta.resolve("./racy_worker.js"),
@@ -207,7 +207,7 @@ Deno.test({
 
     racyWorker.onmessage = (_e) => {
       setTimeout(() => {
-        promise.resolve();
+        resolve();
       }, 100);
     };
 
@@ -222,8 +222,8 @@ Deno.test({
     let messageHandlersCalled = 0;
     let errorHandlersCalled = 0;
 
-    const promise1 = deferred();
-    const promise2 = deferred();
+    const deferred1 = Promise.withResolvers<void>();
+    const deferred2 = Promise.withResolvers<void>();
 
     const worker = new Worker(
       import.meta.resolve("./event_worker.js"),
@@ -238,7 +238,7 @@ Deno.test({
     });
     worker.addEventListener("message", (_e: Event) => {
       messageHandlersCalled++;
-      promise1.resolve();
+      deferred1.resolve();
     });
 
     worker.onerror = (e) => {
@@ -250,15 +250,15 @@ Deno.test({
     });
     worker.addEventListener("error", (_e: Event) => {
       errorHandlersCalled++;
-      promise2.resolve();
+      deferred2.resolve();
     });
 
     worker.postMessage("ping");
-    await promise1;
+    await deferred1.promise;
     assertEquals(messageHandlersCalled, 3);
 
     worker.postMessage("boom");
-    await promise2;
+    await deferred2.promise;
     assertEquals(errorHandlersCalled, 3);
     worker.terminate();
   },
@@ -272,9 +272,10 @@ Deno.test({
       { type: "module" },
     );
 
-    const promise = deferred();
+    // deno-lint-ignore no-explicit-any
+    const { promise, resolve } = Promise.withResolvers<any>();
     worker.onmessage = (e: MessageEvent) => {
-      promise.resolve(e.data);
+      resolve(e.data);
     };
     worker.onerror = (_e) => {
       throw new Error("unreachable");
@@ -298,10 +299,10 @@ Deno.test({
       { type: "module", deno: { permissions: "inherit" } },
     );
 
-    const promise = deferred();
+    const { promise, resolve } = Promise.withResolvers<string>();
     denoWorker.onmessage = (e) => {
       denoWorker.terminate();
-      promise.resolve(e.data);
+      resolve(e.data);
     };
 
     denoWorker.postMessage("Hello World");
@@ -317,9 +318,9 @@ Deno.test({
       { type: "module" },
     );
 
-    const promise = deferred();
+    const { promise, resolve } = Promise.withResolvers<boolean>();
     w.onmessage = (e) => {
-      promise.resolve(e.data);
+      resolve(e.data);
     };
 
     w.postMessage(null);
@@ -331,7 +332,7 @@ Deno.test({
 Deno.test({
   name: "Worker event handler order",
   fn: async function () {
-    const promise = deferred();
+    const { promise, resolve } = Promise.withResolvers<void>();
     const w = new Worker(
       import.meta.resolve("./test_worker.ts"),
       { type: "module", name: "tsWorker" },
@@ -343,7 +344,7 @@ Deno.test({
     };
     w.addEventListener("message", () => arr.push(3));
     w.addEventListener("message", () => {
-      promise.resolve();
+      resolve();
     });
     w.postMessage("Hello World");
     await promise;
@@ -355,13 +356,13 @@ Deno.test({
 Deno.test({
   name: "Worker immediate close",
   fn: async function () {
-    const promise = deferred();
+    const { promise, resolve } = Promise.withResolvers<void>();
     const w = new Worker(
       import.meta.resolve("./immediately_close_worker.js"),
       { type: "module" },
     );
     setTimeout(() => {
-      promise.resolve();
+      resolve();
     }, 1000);
     await promise;
     w.terminate();
@@ -371,7 +372,7 @@ Deno.test({
 Deno.test({
   name: "Worker post undefined",
   fn: async function () {
-    const promise = deferred();
+    const { promise, resolve } = Promise.withResolvers<void>();
     const worker = new Worker(
       import.meta.resolve("./post_undefined.ts"),
       { type: "module" },
@@ -380,7 +381,7 @@ Deno.test({
     const handleWorkerMessage = (e: MessageEvent) => {
       console.log("main <- worker:", e.data);
       worker.terminate();
-      promise.resolve();
+      resolve();
     };
 
     worker.addEventListener("messageerror", () => console.log("message error"));
@@ -399,9 +400,9 @@ Deno.test("Worker inherits permissions", async function () {
     { type: "module", deno: { permissions: "inherit" } },
   );
 
-  const promise = deferred();
+  const { promise, resolve } = Promise.withResolvers<boolean>();
   worker.onmessage = (e) => {
-    promise.resolve(e.data);
+    resolve(e.data);
   };
 
   worker.postMessage(null);
@@ -415,9 +416,9 @@ Deno.test("Worker limit children permissions", async function () {
     { type: "module", deno: { permissions: { read: false } } },
   );
 
-  const promise = deferred();
+  const { promise, resolve } = Promise.withResolvers<boolean>();
   worker.onmessage = (e) => {
-    promise.resolve(e.data);
+    resolve(e.data);
   };
 
   worker.postMessage(null);
@@ -443,8 +444,9 @@ Deno.test("Worker limit children permissions granularly", async function () {
       },
     },
   );
-  const promise = deferred();
-  worker.onmessage = ({ data }) => promise.resolve(data);
+  // deno-lint-ignore no-explicit-any
+  const { promise, resolve } = Promise.withResolvers<any>();
+  worker.onmessage = ({ data }) => resolve(data);
   assertEquals(await promise, {
     envGlobal: "prompt",
     envFoo: "granted",
@@ -482,8 +484,9 @@ Deno.test("Nested worker limit children permissions", async function () {
     import.meta.resolve("./parent_read_check_worker.js"),
     { type: "module", deno: { permissions: "inherit" } },
   );
-  const promise = deferred();
-  worker.onmessage = ({ data }) => promise.resolve(data);
+  // deno-lint-ignore no-explicit-any
+  const { promise, resolve } = Promise.withResolvers<any>();
+  worker.onmessage = ({ data }) => resolve(data);
   assertEquals(await promise, {
     envGlobal: "prompt",
     envFoo: "prompt",
@@ -541,9 +544,9 @@ Deno.test("Worker with disabled permissions", async function () {
     { type: "module", deno: { permissions: "none" } },
   );
 
-  const promise = deferred();
+  const { promise, resolve } = Promise.withResolvers<boolean>();
   worker.onmessage = (e) => {
-    promise.resolve(e.data);
+    resolve(e.data);
   };
 
   worker.postMessage(null);
@@ -557,9 +560,10 @@ Deno.test("Worker permissions are not inherited with empty permission object", a
     { type: "module", deno: { permissions: {} } },
   );
 
-  const promise = deferred();
+  // deno-lint-ignore no-explicit-any
+  const { promise, resolve } = Promise.withResolvers<any>();
   worker.onmessage = (e) => {
-    promise.resolve(e.data);
+    resolve(e.data);
   };
 
   worker.postMessage(null);
@@ -581,9 +585,10 @@ Deno.test("Worker permissions are not inherited with single specified permission
     { type: "module", deno: { permissions: { net: true } } },
   );
 
-  const promise = deferred();
+  // deno-lint-ignore no-explicit-any
+  const { promise, resolve } = Promise.withResolvers<any>();
   worker.onmessage = (e) => {
-    promise.resolve(e.data);
+    resolve(e.data);
   };
 
   worker.postMessage(null);
@@ -615,11 +620,11 @@ Deno.test("Worker with invalid permission arg", function () {
 Deno.test({
   name: "worker location",
   fn: async function () {
-    const promise = deferred();
+    const { promise, resolve } = Promise.withResolvers<string>();
     const workerModuleHref = import.meta.resolve("./worker_location.ts");
     const w = new Worker(workerModuleHref, { type: "module" });
     w.onmessage = (e) => {
-      promise.resolve(e.data);
+      resolve(e.data);
     };
     w.postMessage("Hello, world!");
     assertEquals(await promise, `${workerModuleHref}, true`);
@@ -635,9 +640,9 @@ Deno.test({
       "./workers/test_worker.ts",
       { type: "module", name: "tsWorker" },
     );
-    const promise = deferred();
+    const { promise, resolve } = Promise.withResolvers<string>();
     w.onmessage = (e) => {
-      promise.resolve(e.data);
+      resolve(e.data);
     };
     w.postMessage("Hello, world!");
     assertEquals(await promise, "Hello, world!");
@@ -648,7 +653,7 @@ Deno.test({
 Deno.test({
   name: "Worker with top-level-await",
   fn: async function () {
-    const result = deferred();
+    const { promise, resolve, reject } = Promise.withResolvers<void>();
     const worker = new Worker(
       import.meta.resolve("./worker_with_top_level_await.ts"),
       { type: "module" },
@@ -657,12 +662,12 @@ Deno.test({
       if (e.data == "ready") {
         worker.postMessage("trigger worker handler");
       } else if (e.data == "triggered worker handler") {
-        result.resolve();
+        resolve();
       } else {
-        result.reject(new Error("Handler didn't run during top-level delay."));
+        reject(new Error("Handler didn't run during top-level delay."));
       }
     };
-    await result;
+    await promise;
     worker.terminate();
   },
 });
@@ -670,15 +675,15 @@ Deno.test({
 Deno.test({
   name: "Worker with native HTTP",
   fn: async function () {
-    const result = deferred();
+    const { promise, resolve } = Promise.withResolvers<void>();
     const worker = new Worker(
       import.meta.resolve("./http_worker.js"),
       { type: "module", deno: { permissions: "inherit" } },
     );
     worker.onmessage = () => {
-      result.resolve();
+      resolve();
     };
-    await result;
+    await promise;
 
     assert(worker);
     const response = await fetch("http://localhost:4506");
@@ -695,14 +700,14 @@ Deno.test({
       { type: "module" },
     );
 
-    const result = deferred();
+    // deno-lint-ignore no-explicit-any
+    const { promise, resolve } = Promise.withResolvers<any>();
     worker.onmessage = (e) => {
-      result.resolve(e.data);
+      resolve(e.data);
     };
 
     worker.postMessage("START");
-    // deno-lint-ignore no-explicit-any
-    const data = await result as any;
+    const data = await promise;
     // self field should reference itself (circular ref)
     assert(data === data.self);
     // fields a and b refer to the same array
@@ -729,9 +734,9 @@ Deno.test({
       "./workers/test_worker.ts",
       { type: "module", name: "tsWorker" },
     );
-    const promise = deferred();
+    const { promise, resolve } = Promise.withResolvers<string>();
     w.onmessage = (e) => {
-      promise.resolve(e.data);
+      resolve(e.data);
     };
     w.postMessage("Hello, world!");
     assertEquals(await promise, "Hello, world!");
@@ -742,7 +747,7 @@ Deno.test({
 Deno.test({
   name: "worker SharedArrayBuffer",
   fn: async function () {
-    const promise = deferred();
+    const { promise, resolve } = Promise.withResolvers<void>();
     const workerOptions: WorkerOptions = { type: "module" };
     const w = new Worker(
       import.meta.resolve("./shared_array_buffer.ts"),
@@ -757,7 +762,7 @@ Deno.test({
     w.onmessage = () => {
       w.postMessage([sab1, sab2]);
       w.onmessage = () => {
-        promise.resolve();
+        resolve();
       };
     };
     await promise;
@@ -776,30 +781,31 @@ Deno.test({
     );
     const channel = new MessageChannel();
 
-    const promise1 = deferred();
-    const promise2 = deferred();
-    const promise3 = deferred();
-    const result = deferred();
+    // deno-lint-ignore no-explicit-any
+    const deferred1 = Promise.withResolvers<any>();
+    const deferred2 = Promise.withResolvers<boolean>();
+    const deferred3 = Promise.withResolvers<boolean>();
+    const result = Promise.withResolvers<void>();
     worker.onmessage = (e) => {
-      promise1.resolve([e.data, e.ports.length]);
+      deferred1.resolve([e.data, e.ports.length]);
       const port1 = e.ports[0];
       port1.onmessage = (e) => {
-        promise2.resolve(e.data);
+        deferred2.resolve(e.data);
         port1.close();
         worker.postMessage("3", [channel.port1]);
       };
       port1.postMessage("2");
     };
     channel.port2.onmessage = (e) => {
-      promise3.resolve(e.data);
+      deferred3.resolve(e.data);
       channel.port2.close();
       result.resolve();
     };
 
-    assertEquals(await promise1, ["1", 1]);
-    assertEquals(await promise2, true);
-    assertEquals(await promise3, true);
-    await result;
+    assertEquals(await deferred1.promise, ["1", 1]);
+    assertEquals(await deferred2.promise, true);
+    assertEquals(await deferred3.promise, true);
+    await result.promise;
     worker.terminate();
   },
 });
@@ -818,14 +824,15 @@ Deno.test({
 
     w.postMessage(null);
 
-    const memoryUsagePromise = deferred();
+    // deno-lint-ignore no-explicit-any
+    const { promise, resolve } = Promise.withResolvers<any>();
     w.onmessage = function (evt) {
-      memoryUsagePromise.resolve(evt.data);
+      resolve(evt.data);
     };
 
     assertEquals(
       Object.keys(
-        await memoryUsagePromise as unknown as Record<string, number>,
+        await promise as unknown as Record<string, number>,
       ),
       ["rss", "heapTotal", "heapUsed", "external"],
     );
diff --git a/cli/tests/unit/http_test.ts b/cli/tests/unit/http_test.ts
index ac3b3d66f..b7c6169d8 100644
--- a/cli/tests/unit/http_test.ts
+++ b/cli/tests/unit/http_test.ts
@@ -8,7 +8,6 @@ import {
   assertRejects,
   assertStrictEquals,
   assertThrows,
-  deferred,
   delay,
   fail,
 } from "./test_util.ts";
@@ -592,9 +591,9 @@ Deno.test(
     let counter = 0;
 
     const deferreds = [
-      deferred(),
-      deferred(),
-      deferred(),
+      Promise.withResolvers<void>(),
+      Promise.withResolvers<void>(),
+      Promise.withResolvers<void>(),
     ];
 
     async function writeRequest(conn: Deno.Conn) {
@@ -639,7 +638,7 @@ Deno.test(
             return controller.close();
           }
 
-          await deferreds[counter - 1];
+          await deferreds[counter - 1].promise;
 
           controller.enqueue(`${counter}\n`);
           counter++;
@@ -795,13 +794,13 @@ Deno.test({ permissions: { net: true } }, async function httpServerWebSocket() {
     await close;
   })();
 
-  const def = deferred();
+  const def = Promise.withResolvers<void>();
   const ws = new WebSocket(`ws://localhost:${listenPort}`);
   ws.onmessage = (m) => assertEquals(m.data, "foo");
   ws.onerror = () => fail();
   ws.onclose = () => def.resolve();
   ws.onopen = () => ws.send("foo");
-  await def;
+  await def.promise;
   await promise;
 });
 
@@ -2287,7 +2286,7 @@ Deno.test("upgradeHttp unix", {
   ignore: Deno.build.os === "windows",
 }, async () => {
   const filePath = tmpUnixSocketPath();
-  const promise = deferred();
+  const { promise, resolve } = Promise.withResolvers<void>();
 
   async function client() {
     const unixConn = await Deno.connect({ path: filePath, transport: "unix" });
@@ -2303,7 +2302,7 @@ Deno.test("upgradeHttp unix", {
         ),
       );
       unixConn.close();
-      promise.resolve();
+      resolve();
     }, 500);
     await promise;
   }
diff --git a/cli/tests/unit/kv_test.ts b/cli/tests/unit/kv_test.ts
index 0a9f5dc8a..73c85dd5c 100644
--- a/cli/tests/unit/kv_test.ts
+++ b/cli/tests/unit/kv_test.ts
@@ -6,8 +6,6 @@ import {
   assertNotEquals,
   assertRejects,
   assertThrows,
-  Deferred,
-  deferred,
 } from "./test_util.ts";
 import { assertType, IsExact } from "../../../test_util/std/testing/types.ts";
 
@@ -1404,11 +1402,11 @@ async function _typeCheckingTests() {
 }
 
 queueTest("basic listenQueue and enqueue", async (db) => {
-  const promise = deferred();
+  const { promise, resolve } = Promise.withResolvers<void>();
   let dequeuedMessage: unknown = null;
   const listener = db.listenQueue((msg) => {
     dequeuedMessage = msg;
-    promise.resolve();
+    resolve();
   });
   try {
     const res = await db.enqueue("test");
@@ -1426,17 +1424,19 @@ for (const { name, value } of VALUE_CASES) {
   queueTest(`listenQueue and enqueue ${name}`, async (db) => {
     const numEnqueues = 10;
     let count = 0;
-    const promises: Deferred<unknown>[] = [];
+    const deferreds: ReturnType<typeof Promise.withResolvers<unknown>>[] = [];
     const listeners: Promise<void>[] = [];
     listeners.push(db.listenQueue((msg: unknown) => {
-      promises[count++].resolve(msg);
+      deferreds[count++].resolve(msg);
     }));
     try {
       for (let i = 0; i < numEnqueues; i++) {
-        promises.push(deferred());
+        deferreds.push(Promise.withResolvers<unknown>());
         await db.enqueue(value);
       }
-      const dequeuedMessages = await Promise.all(promises);
+      const dequeuedMessages = await Promise.all(
+        deferreds.map(({ promise }) => promise),
+      );
       for (let i = 0; i < numEnqueues; i++) {
         assertEquals(dequeuedMessages[i], value);
       }
@@ -1450,17 +1450,17 @@ for (const { name, value } of VALUE_CASES) {
 }
 
 queueTest("queue mixed types", async (db) => {
-  let promise: Deferred<void>;
+  let deferred: ReturnType<typeof Promise.withResolvers<void>>;
   let dequeuedMessage: unknown = null;
   const listener = db.listenQueue((msg: unknown) => {
     dequeuedMessage = msg;
-    promise.resolve();
+    deferred.resolve();
   });
   try {
     for (const item of VALUE_CASES) {
-      promise = deferred();
+      deferred = Promise.withResolvers<void>();
       await db.enqueue(item.value);
-      await promise;
+      await deferred.promise;
       assertEquals(dequeuedMessage, item.value);
     }
   } finally {
@@ -1471,12 +1471,12 @@ queueTest("queue mixed types", async (db) => {
 
 queueTest("queue delay", async (db) => {
   let dequeueTime: number | undefined;
-  const promise = deferred();
+  const { promise, resolve } = Promise.withResolvers<void>();
   let dequeuedMessage: unknown = null;
   const listener = db.listenQueue((msg) => {
     dequeueTime = Date.now();
     dequeuedMessage = msg;
-    promise.resolve();
+    resolve();
   });
   try {
     const enqueueTime = Date.now();
@@ -1493,12 +1493,12 @@ queueTest("queue delay", async (db) => {
 
 queueTest("queue delay with atomic", async (db) => {
   let dequeueTime: number | undefined;
-  const promise = deferred();
+  const { promise, resolve } = Promise.withResolvers<void>();
   let dequeuedMessage: unknown = null;
   const listener = db.listenQueue((msg) => {
     dequeueTime = Date.now();
     dequeuedMessage = msg;
-    promise.resolve();
+    resolve();
   });
   try {
     const enqueueTime = Date.now();
@@ -1520,14 +1520,14 @@ queueTest("queue delay with atomic", async (db) => {
 queueTest("queue delay and now", async (db) => {
   let count = 0;
   let dequeueTime: number | undefined;
-  const promise = deferred();
+  const { promise, resolve } = Promise.withResolvers<void>();
   let dequeuedMessage: unknown = null;
   const listener = db.listenQueue((msg) => {
     count += 1;
     if (count == 2) {
       dequeueTime = Date.now();
       dequeuedMessage = msg;
-      promise.resolve();
+      resolve();
     }
   });
   try {
@@ -1564,12 +1564,12 @@ dbTest("queue large delay", async (db) => {
 });
 
 queueTest("listenQueue with async callback", async (db) => {
-  const promise = deferred();
+  const { promise, resolve } = Promise.withResolvers<void>();
   let dequeuedMessage: unknown = null;
   const listener = db.listenQueue(async (msg) => {
     dequeuedMessage = msg;
     await sleep(100);
-    promise.resolve();
+    resolve();
   });
   try {
     await db.enqueue("test");
@@ -1603,20 +1603,20 @@ queueTest("queue retries", async (db) => {
 queueTest("multiple listenQueues", async (db) => {
   const numListens = 10;
   let count = 0;
-  const promises: Deferred<void>[] = [];
+  const deferreds: ReturnType<typeof Promise.withResolvers<void>>[] = [];
   const dequeuedMessages: unknown[] = [];
   const listeners: Promise<void>[] = [];
   for (let i = 0; i < numListens; i++) {
     listeners.push(db.listenQueue((msg) => {
       dequeuedMessages.push(msg);
-      promises[count++].resolve();
+      deferreds[count++].resolve();
     }));
   }
   try {
     for (let i = 0; i < numListens; i++) {
-      promises.push(deferred());
+      deferreds.push(Promise.withResolvers<void>());
       await db.enqueue("msg_" + i);
-      await promises[i];
+      await deferreds[i].promise;
       const msg = dequeuedMessages[i];
       assertEquals("msg_" + i, msg);
     }
@@ -1629,11 +1629,11 @@ queueTest("multiple listenQueues", async (db) => {
 });
 
 queueTest("enqueue with atomic", async (db) => {
-  const promise = deferred();
+  const { promise, resolve } = Promise.withResolvers<void>();
   let dequeuedMessage: unknown = null;
   const listener = db.listenQueue((msg) => {
     dequeuedMessage = msg;
-    promise.resolve();
+    resolve();
   });
 
   try {
@@ -1661,7 +1661,7 @@ queueTest("enqueue with atomic", async (db) => {
 });
 
 queueTest("enqueue with atomic nonce", async (db) => {
-  const promise = deferred();
+  const { promise, resolve } = Promise.withResolvers<void>();
   let dequeuedMessage: unknown = null;
 
   const nonce = crypto.randomUUID();
@@ -1672,7 +1672,7 @@ queueTest("enqueue with atomic nonce", async (db) => {
     const nonceValue = await db.get(["nonces", nonce]);
     if (nonceValue.versionstamp === null) {
       dequeuedMessage = message.msg;
-      promise.resolve();
+      resolve();
       return;
     }
 
@@ -1720,13 +1720,13 @@ Deno.test({
       let db: Deno.Kv = await Deno.openKv(filename);
 
       let count = 0;
-      let promise = deferred();
+      let deferred = Promise.withResolvers<void>();
 
       // Register long-running handler.
       let listener = db.listenQueue(async (_msg) => {
         count += 1;
         if (count == 3) {
-          promise.resolve();
+          deferred.resolve();
         }
         await new Promise(() => {});
       });
@@ -1735,7 +1735,7 @@ Deno.test({
       await db.enqueue("msg0");
       await db.enqueue("msg1");
       await db.enqueue("msg2");
-      await promise;
+      await deferred.promise;
 
       // Close the database and wait for the listener to finish.
       db.close();
@@ -1751,18 +1751,18 @@ Deno.test({
       db = await Deno.openKv(filename);
 
       count = 0;
-      promise = deferred();
+      deferred = Promise.withResolvers<void>();
 
       // Register a handler that will complete quickly.
       listener = db.listenQueue((_msg) => {
         count += 1;
         if (count == 3) {
-          promise.resolve();
+          deferred.resolve();
         }
       });
 
       // Wait for the handlers to finish.
-      await promise;
+      await deferred.promise;
       assertEquals(3, count);
       db.close();
       await listener;
@@ -1789,7 +1789,7 @@ Deno.test({
       let db: Deno.Kv = await Deno.openKv(filename);
 
       let count = 0;
-      let promise = deferred();
+      let deferred = Promise.withResolvers<void>();
 
       // Register long-running handler.
       let listener = db.listenQueue((_msg) => {});
@@ -1807,18 +1807,18 @@ Deno.test({
       db = await Deno.openKv(filename);
 
       count = 0;
-      promise = deferred();
+      deferred = Promise.withResolvers<void>();
 
       // Register a handler that will complete quickly.
       listener = db.listenQueue((_msg) => {
         count += 1;
         if (count == 3) {
-          promise.resolve();
+          deferred.resolve();
         }
       });
 
       // Wait for the handlers to finish.
-      await promise;
+      await deferred.promise;
       assertEquals(3, count);
       db.close();
       await listener;
@@ -1839,11 +1839,11 @@ Deno.test({
     try {
       const db0 = await Deno.openKv(filename);
       const db1 = await Deno.openKv(filename);
-      const promise = deferred();
+      const { promise, resolve } = Promise.withResolvers<void>();
       let dequeuedMessage: unknown = null;
       const listener = db0.listenQueue((msg) => {
         dequeuedMessage = msg;
-        promise.resolve();
+        resolve();
       });
       try {
         const res = await db1.enqueue("test");
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;
diff --git a/cli/tests/unit/test_util.ts b/cli/tests/unit/test_util.ts
index ccc8f51a1..c7dc9e80b 100644
--- a/cli/tests/unit/test_util.ts
+++ b/cli/tests/unit/test_util.ts
@@ -20,8 +20,6 @@ export {
   unimplemented,
   unreachable,
 } from "../../../test_util/std/testing/asserts.ts";
-export { deferred } from "../../../test_util/std/async/deferred.ts";
-export type { Deferred } from "../../../test_util/std/async/deferred.ts";
 export { delay } from "../../../test_util/std/async/delay.ts";
 export { readLines } from "../../../test_util/std/io/read_lines.ts";
 export { parse as parseArgs } from "../../../test_util/std/flags/mod.ts";
diff --git a/cli/tests/unit/tls_test.ts b/cli/tests/unit/tls_test.ts
index 31e24d547..375ef6688 100644
--- a/cli/tests/unit/tls_test.ts
+++ b/cli/tests/unit/tls_test.ts
@@ -6,8 +6,6 @@ import {
   assertRejects,
   assertStrictEquals,
   assertThrows,
-  Deferred,
-  deferred,
 } from "./test_util.ts";
 import { BufReader, BufWriter } from "../../../test_util/std/io/mod.ts";
 import { readAll } from "../../../test_util/std/streams/read_all.ts";
@@ -178,7 +176,7 @@ Deno.test(
 Deno.test(
   { permissions: { read: true, net: true } },
   async function dialAndListenTLS() {
-    const resolvable = deferred();
+    const { promise, resolve } = Promise.withResolvers<void>();
     const hostname = "localhost";
     const port = 3500;
 
@@ -201,7 +199,7 @@ Deno.test(
         // TODO(bartlomieju): this might be a bug
         setTimeout(() => {
           conn.close();
-          resolvable.resolve();
+          resolve();
         }, 0);
       },
     );
@@ -231,13 +229,13 @@ Deno.test(
     assertEquals(decoder.decode(bodyBuf), "Hello World\n");
     conn.close();
     listener.close();
-    await resolvable;
+    await promise;
   },
 );
 Deno.test(
   { permissions: { read: false, net: true } },
   async function listenTlsWithCertAndKey() {
-    const resolvable = deferred();
+    const { promise, resolve } = Promise.withResolvers<void>();
     const hostname = "localhost";
     const port = 3500;
 
@@ -254,7 +252,7 @@ Deno.test(
         await conn.write(response);
         setTimeout(() => {
           conn.close();
-          resolvable.resolve();
+          resolve();
         }, 0);
       },
     );
@@ -284,7 +282,7 @@ Deno.test(
     assertEquals(decoder.decode(bodyBuf), "Hello World\n");
     conn.close();
     listener.close();
-    await resolvable;
+    await promise;
   },
 );
 
@@ -770,20 +768,20 @@ async function tlsWithTcpFailureTestImpl(
       tcpConn2: tcpClientConn,
     };
 
-  const tcpForwardingInterruptPromise1 = deferred<void>();
+  const tcpForwardingInterruptDeferred1 = Promise.withResolvers<void>();
   const tcpForwardingPromise1 = forwardBytes(
     tcpConn2,
     tcpConn1,
     cipherByteCount,
-    tcpForwardingInterruptPromise1,
+    tcpForwardingInterruptDeferred1,
   );
 
-  const tcpForwardingInterruptPromise2 = deferred<void>();
+  const tcpForwardingInterruptDeferred2 = Promise.withResolvers<void>();
   const tcpForwardingPromise2 = forwardBytes(
     tcpConn1,
     tcpConn2,
     Infinity,
-    tcpForwardingInterruptPromise2,
+    tcpForwardingInterruptDeferred2,
   );
 
   switch (phase) {
@@ -836,7 +834,7 @@ async function tlsWithTcpFailureTestImpl(
       }
       await tlsTrafficPromise1;
 
-      tcpForwardingInterruptPromise2.resolve();
+      tcpForwardingInterruptDeferred2.resolve();
       await tcpForwardingPromise2;
       await tcpConn2.closeWrite();
       await tlsTrafficPromise2;
@@ -852,8 +850,8 @@ async function tlsWithTcpFailureTestImpl(
         receiveBytes(tlsConn2, 0x99, 99999),
       ]);
 
-      tcpForwardingInterruptPromise1.resolve();
-      await tcpForwardingPromise1;
+      tcpForwardingInterruptDeferred1.resolve();
+      await tcpForwardingInterruptDeferred1.promise;
 
       switch (failureMode) {
         case "corruption":
@@ -862,7 +860,7 @@ async function tlsWithTcpFailureTestImpl(
             () => receiveEof(tlsConn1),
             Deno.errors.InvalidData,
           );
-          tcpForwardingInterruptPromise2.resolve();
+          tcpForwardingInterruptDeferred2.resolve();
           break;
         case "shutdown":
           await Promise.all([
@@ -934,12 +932,15 @@ async function tlsWithTcpFailureTestImpl(
     source: Deno.Conn,
     sink: Deno.Conn,
     count: number,
-    interruptPromise: Deferred<void>,
+    interruptPromise: ReturnType<typeof Promise.withResolvers<void>>,
   ) {
     let buf = new Uint8Array(1 << 12 /* 4 kB */);
     while (count > 0) {
       buf = buf.subarray(0, Math.min(buf.length, count));
-      const nread = await Promise.race([source.read(buf), interruptPromise]);
+      const nread = await Promise.race([
+        source.read(buf),
+        interruptPromise.promise,
+      ]);
       if (nread == null) break; // Either EOF or interrupted.
       const nwritten = await sink.write(buf.subarray(0, nread));
       assertStrictEquals(nread, nwritten);
@@ -1405,7 +1406,7 @@ Deno.test(
 Deno.test(
   { permissions: { net: true } },
   async function listenTlsWithReuseAddr() {
-    const resolvable1 = deferred();
+    const deferred1 = Promise.withResolvers<void>();
     const hostname = "localhost";
     const port = 3500;
 
@@ -1413,25 +1414,25 @@ Deno.test(
 
     listener1.accept().then((conn) => {
       conn.close();
-      resolvable1.resolve();
+      deferred1.resolve();
     });
 
     const conn1 = await Deno.connectTls({ hostname, port, caCerts });
     conn1.close();
-    await resolvable1;
+    await deferred1.promise;
     listener1.close();
 
-    const resolvable2 = deferred();
+    const deferred2 = Promise.withResolvers<void>();
     const listener2 = Deno.listenTls({ hostname, port, cert, key });
 
     listener2.accept().then((conn) => {
       conn.close();
-      resolvable2.resolve();
+      deferred2.resolve();
     });
 
     const conn2 = await Deno.connectTls({ hostname, port, caCerts });
     conn2.close();
-    await resolvable2;
+    await deferred2.promise;
     listener2.close();
   },
 );
diff --git a/cli/tests/unit/websocket_test.ts b/cli/tests/unit/websocket_test.ts
index 0cdc86570..7bc53495a 100644
--- a/cli/tests/unit/websocket_test.ts
+++ b/cli/tests/unit/websocket_test.ts
@@ -1,11 +1,5 @@
 // Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
-import {
-  assert,
-  assertEquals,
-  assertThrows,
-  deferred,
-  fail,
-} from "./test_util.ts";
+import { assert, assertEquals, assertThrows, fail } from "./test_util.ts";
 
 const servePort = 4248;
 const serveUrl = `ws://localhost:${servePort}/`;
@@ -18,23 +12,23 @@ Deno.test({ permissions: "none" }, function websocketPermissionless() {
 });
 
 Deno.test(async function websocketConstructorTakeURLObjectAsParameter() {
-  const promise = deferred();
+  const { promise, resolve, reject } = Promise.withResolvers<void>();
   const ws = new WebSocket(new URL("ws://localhost:4242/"));
   assertEquals(ws.url, "ws://localhost:4242/");
-  ws.onerror = (e) => promise.reject(e);
+  ws.onerror = (e) => reject(e);
   ws.onopen = () => ws.close();
   ws.onclose = () => {
-    promise.resolve();
+    resolve();
   };
   await promise;
 });
 
 Deno.test(async function websocketH2SendSmallPacket() {
-  const promise = deferred();
+  const { promise, resolve, reject } = Promise.withResolvers<void>();
   const ws = new WebSocket(new URL("wss://localhost:4249/"));
   assertEquals(ws.url, "wss://localhost:4249/");
   let messageCount = 0;
-  ws.onerror = (e) => promise.reject(e);
+  ws.onerror = (e) => reject(e);
   ws.onopen = () => {
     ws.send("a".repeat(16));
     ws.send("a".repeat(16));
@@ -46,17 +40,17 @@ Deno.test(async function websocketH2SendSmallPacket() {
     }
   };
   ws.onclose = () => {
-    promise.resolve();
+    resolve();
   };
   await promise;
 });
 
 Deno.test(async function websocketH2SendLargePacket() {
-  const promise = deferred();
+  const { promise, resolve, reject } = Promise.withResolvers<void>();
   const ws = new WebSocket(new URL("wss://localhost:4249/"));
   assertEquals(ws.url, "wss://localhost:4249/");
   let messageCount = 0;
-  ws.onerror = (e) => promise.reject(e);
+  ws.onerror = (e) => reject(e);
   ws.onopen = () => {
     ws.send("a".repeat(65000));
     ws.send("a".repeat(65000));
@@ -68,16 +62,16 @@ Deno.test(async function websocketH2SendLargePacket() {
     }
   };
   ws.onclose = () => {
-    promise.resolve();
+    resolve();
   };
   await promise;
 });
 
 Deno.test(async function websocketSendLargePacket() {
-  const promise = deferred();
+  const { promise, resolve, reject } = Promise.withResolvers<void>();
   const ws = new WebSocket(new URL("wss://localhost:4243/"));
   assertEquals(ws.url, "wss://localhost:4243/");
-  ws.onerror = (e) => promise.reject(e);
+  ws.onerror = (e) => reject(e);
   ws.onopen = () => {
     ws.send("a".repeat(65000));
   };
@@ -85,17 +79,17 @@ Deno.test(async function websocketSendLargePacket() {
     ws.close();
   };
   ws.onclose = () => {
-    promise.resolve();
+    resolve();
   };
   await promise;
 });
 
 Deno.test(async function websocketSendLargeBinaryPacket() {
-  const promise = deferred();
+  const { promise, resolve, reject } = Promise.withResolvers<void>();
   const ws = new WebSocket(new URL("wss://localhost:4243/"));
   ws.binaryType = "arraybuffer";
   assertEquals(ws.url, "wss://localhost:4243/");
-  ws.onerror = (e) => promise.reject(e);
+  ws.onerror = (e) => reject(e);
   ws.onopen = () => {
     ws.send(new Uint8Array(65000));
   };
@@ -104,17 +98,17 @@ Deno.test(async function websocketSendLargeBinaryPacket() {
     ws.close();
   };
   ws.onclose = () => {
-    promise.resolve();
+    resolve();
   };
   await promise;
 });
 
 Deno.test(async function websocketSendLargeBlobPacket() {
-  const promise = deferred();
+  const { promise, resolve, reject } = Promise.withResolvers<void>();
   const ws = new WebSocket(new URL("wss://localhost:4243/"));
   ws.binaryType = "arraybuffer";
   assertEquals(ws.url, "wss://localhost:4243/");
-  ws.onerror = (e) => promise.reject(e);
+  ws.onerror = (e) => reject(e);
   ws.onopen = () => {
     ws.send(new Blob(["a".repeat(65000)]));
   };
@@ -123,7 +117,7 @@ Deno.test(async function websocketSendLargeBlobPacket() {
     ws.close();
   };
   ws.onclose = () => {
-    promise.resolve();
+    resolve();
   };
   await promise;
 });
@@ -131,15 +125,15 @@ Deno.test(async function websocketSendLargeBlobPacket() {
 // https://github.com/denoland/deno/pull/17762
 // https://github.com/denoland/deno/issues/17761
 Deno.test(async function websocketPingPong() {
-  const promise = deferred();
+  const { promise, resolve, reject } = Promise.withResolvers<void>();
   const ws = new WebSocket("ws://localhost:4245/");
   assertEquals(ws.url, "ws://localhost:4245/");
-  ws.onerror = (e) => promise.reject(e);
+  ws.onerror = (e) => reject(e);
   ws.onmessage = (e) => {
     ws.send(e.data);
   };
   ws.onclose = () => {
-    promise.resolve();
+    resolve();
   };
   await promise;
   ws.close();
@@ -147,7 +141,7 @@ Deno.test(async function websocketPingPong() {
 
 // TODO(mmastrac): This requires us to ignore bad certs
 // Deno.test(async function websocketSecureConnect() {
-//   const promise = deferred();
+//   const { promise, resolve } = Promise.withResolvers<void>();
 //   const ws = new WebSocket("wss://localhost:4243/");
 //   assertEquals(ws.url, "wss://localhost:4243/");
 //   ws.onerror = (error) => {
@@ -156,7 +150,7 @@ Deno.test(async function websocketPingPong() {
 //   };
 //   ws.onopen = () => ws.close();
 //   ws.onclose = () => {
-//     promise.resolve();
+//     resolve();
 //   };
 //   await promise;
 // });
@@ -166,7 +160,7 @@ Deno.test(
   { sanitizeOps: false, sanitizeResources: false },
   async function websocketWriteLock() {
     const ac = new AbortController();
-    const listeningPromise = deferred();
+    const listeningDeferred = Promise.withResolvers<void>();
 
     const server = Deno.serve({
       handler: (req) => {
@@ -181,13 +175,13 @@ Deno.test(
         return response;
       },
       signal: ac.signal,
-      onListen: () => listeningPromise.resolve(),
+      onListen: () => listeningDeferred.resolve(),
       hostname: "localhost",
       port: servePort,
     });
 
-    await listeningPromise;
-    const promise = deferred();
+    await listeningDeferred.promise;
+    const deferred = Promise.withResolvers<void>();
     const ws = new WebSocket(serveUrl);
     assertEquals(ws.url, serveUrl);
     ws.onerror = () => fail();
@@ -196,13 +190,13 @@ Deno.test(
       setTimeout(() => {
         ws.send(e.data);
       }, 1000);
-      promise.resolve();
+      deferred.resolve();
     };
     ws.onclose = () => {
-      promise.resolve();
+      deferred.resolve();
     };
 
-    await Promise.all([promise, server.finished]);
+    await Promise.all([deferred.promise, server.finished]);
     ws.close();
   },
 );
@@ -212,10 +206,10 @@ Deno.test({
   sanitizeOps: false,
   sanitizeResources: false,
 }, async function websocketDoubleClose() {
-  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: (req) => {
@@ -233,12 +227,12 @@ Deno.test({
       return response;
     },
     signal: ac.signal,
-    onListen: () => listeningPromise.resolve(),
+    onListen: () => listeningDeferred.resolve(),
     hostname: "localhost",
     port: servePort,
   });
 
-  await listeningPromise;
+  await listeningDeferred.promise;
 
   const ws = new WebSocket(serveUrl);
   assertEquals(ws.url, serveUrl);
@@ -247,9 +241,9 @@ Deno.test({
     if (m.data == "Hello") ws.send("bye");
   };
   ws.onclose = () => {
-    promise.resolve();
+    deferred.resolve();
   };
-  await Promise.all([promise, server.finished]);
+  await Promise.all([deferred.promise, server.finished]);
 });
 
 // https://github.com/denoland/deno/issues/19483
@@ -257,10 +251,10 @@ Deno.test({
   sanitizeOps: false,
   sanitizeResources: false,
 }, async function websocketCloseFlushes() {
-  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: (req) => {
@@ -275,12 +269,12 @@ Deno.test({
       return response;
     },
     signal: ac.signal,
-    onListen: () => listeningPromise.resolve(),
+    onListen: () => listeningDeferred.resolve(),
     hostname: "localhost",
     port: servePort,
   });
 
-  await listeningPromise;
+  await listeningDeferred.promise;
 
   const ws = new WebSocket(serveUrl);
   assertEquals(ws.url, serveUrl);
@@ -295,9 +289,9 @@ Deno.test({
     }
   };
   ws.onclose = () => {
-    promise.resolve();
+    deferred.resolve();
   };
-  await Promise.all([promise, server.finished]);
+  await Promise.all([deferred.promise, server.finished]);
 
   assert(seenBye);
 });
diff --git a/cli/tests/unit_node/_fs/_fs_read_test.ts b/cli/tests/unit_node/_fs/_fs_read_test.ts
index 34b029d9f..3ca303037 100644
--- a/cli/tests/unit_node/_fs/_fs_read_test.ts
+++ b/cli/tests/unit_node/_fs/_fs_read_test.ts
@@ -10,7 +10,6 @@ import { open, openSync } from "node:fs";
 import { Buffer } from "node:buffer";
 import * as path from "../../../../test_util/std/path/mod.ts";
 import { closeSync } from "node:fs";
-import { deferred } from "../../../../test_util/std/async/deferred.ts";
 
 async function readTest(
   testData: string,
@@ -132,7 +131,7 @@ Deno.test({
 Deno.test({
   name: "[std/node/fs] Read fs.read(fd, options, cb) signature",
   async fn() {
-    const promise = deferred();
+    const { promise, reject, resolve } = Promise.withResolvers<void>();
     const file = Deno.makeTempFileSync();
     Deno.writeTextFileSync(file, "hi there");
     const fd = openSync(file, "r+");
@@ -154,10 +153,10 @@ Deno.test({
             Buffer.from([104, 105, 32, 116, 104, 101, 114, 101, 0, 0, 0]),
           );
         } catch (e) {
-          promise.reject(e);
+          reject(e);
           return;
         }
-        promise.resolve();
+        resolve();
       },
     );
     closeSync(fd);
@@ -168,7 +167,7 @@ Deno.test({
 Deno.test({
   name: "[std/node/fs] Read fs.read(fd, cb) signature",
   async fn() {
-    const promise = deferred();
+    const { promise, resolve, reject } = Promise.withResolvers<void>();
     const file = Deno.makeTempFileSync();
     Deno.writeTextFileSync(file, "hi deno");
     const fd = openSync(file, "r+");
@@ -178,10 +177,10 @@ Deno.test({
         assertStrictEquals(bytesRead, 7);
         assertStrictEquals(data?.byteLength, 16384);
       } catch (e) {
-        promise.reject(e);
+        reject(e);
         return;
       }
-      promise.resolve();
+      resolve();
     });
     closeSync(fd);
     await promise;
@@ -277,27 +276,27 @@ Deno.test({
     await Deno.writeTextFile(file, "abc");
 
     await t.step("without position option", async () => {
-      const promise = deferred<void>();
+      const { promise, resolve } = Promise.withResolvers<void>();
       let called = false;
       const fd = openSync(file, "r");
       read(fd, () => {
         called = true;
         closeSync(fd);
-        promise.resolve();
+        resolve();
       });
       assertFalse(called);
       await promise;
     });
 
     await t.step("with position option", async () => {
-      const promise = deferred<void>();
+      const { promise, resolve } = Promise.withResolvers<void>();
       let called = false;
       const buffer = Buffer.alloc(2);
       const fd = openSync(file, "r");
       read(fd, { position: 1, buffer, offset: 0, length: 2 }, () => {
         called = true;
         closeSync(fd);
-        promise.resolve();
+        resolve();
       });
       assertFalse(called);
       await promise;
diff --git a/cli/tests/unit_node/async_hooks_test.ts b/cli/tests/unit_node/async_hooks_test.ts
index 871ad85f9..035e970d4 100644
--- a/cli/tests/unit_node/async_hooks_test.ts
+++ b/cli/tests/unit_node/async_hooks_test.ts
@@ -4,7 +4,6 @@ import {
   assert,
   assertEquals,
 } from "../../../test_util/std/testing/asserts.ts";
-import { deferred } from "../../../test_util/std/async/deferred.ts";
 
 Deno.test(async function foo() {
   const asyncLocalStorage = new AsyncLocalStorage();
@@ -68,16 +67,16 @@ Deno.test(async function bar() {
 
 Deno.test(async function nested() {
   const als = new AsyncLocalStorage();
-  const promise = deferred();
-  const promise1 = deferred();
+  const deferred = Promise.withResolvers();
+  const deferred1 = Promise.withResolvers();
 
   als.run(null, () => {
     als.run({ x: 1 }, () => {
-      promise.resolve(als.getStore());
+      deferred.resolve(als.getStore());
     });
-    promise1.resolve(als.getStore());
+    deferred1.resolve(als.getStore());
   });
 
-  assertEquals(await promise, { x: 1 });
-  assertEquals(await promise1, null);
+  assertEquals(await deferred.promise, { x: 1 });
+  assertEquals(await deferred1.promise, null);
 });
diff --git a/cli/tests/unit_node/child_process_test.ts b/cli/tests/unit_node/child_process_test.ts
index 47e87096e..d226319e6 100644
--- a/cli/tests/unit_node/child_process_test.ts
+++ b/cli/tests/unit_node/child_process_test.ts
@@ -10,45 +10,46 @@ import {
   assertStrictEquals,
   assertStringIncludes,
 } from "../../../test_util/std/testing/asserts.ts";
-import { Deferred, deferred } from "../../../test_util/std/async/deferred.ts";
 import * as path from "../../../test_util/std/path/mod.ts";
 
 const { spawn, spawnSync, execFile, execFileSync, ChildProcess } = CP;
 
-function withTimeout<T>(timeoutInMS = 10_000): Deferred<T> {
-  const promise = deferred<T>();
+function withTimeout<T>(
+  timeoutInMS = 10_000,
+): ReturnType<typeof Promise.withResolvers<T>> {
+  const deferred = Promise.withResolvers<T>();
   const timer = setTimeout(() => {
-    promise.reject("Timeout");
+    deferred.reject("Timeout");
   }, timeoutInMS);
-  promise.then(() => {
+  deferred.promise.then(() => {
     clearTimeout(timer);
   });
-  return promise;
+  return deferred;
 }
 
 // TODO(uki00a): Once Node.js's `parallel/test-child-process-spawn-error.js` works, this test case should be removed.
 Deno.test("[node/child_process spawn] The 'error' event is emitted when no binary is found", async () => {
-  const promise = withTimeout();
+  const deferred = withTimeout<void>();
   const childProcess = spawn("no-such-cmd");
   childProcess.on("error", (_err: Error) => {
     // TODO(@bartlomieju) Assert an error message.
-    promise.resolve();
+    deferred.resolve();
   });
-  await promise;
+  await deferred.promise;
 });
 
 Deno.test("[node/child_process spawn] The 'exit' event is emitted with an exit code after the child process ends", async () => {
-  const promise = withTimeout();
+  const deferred = withTimeout<void>();
   const childProcess = spawn(Deno.execPath(), ["--help"], {
     env: { NO_COLOR: "true" },
   });
   try {
     let exitCode = null;
     childProcess.on("exit", (code: number) => {
-      promise.resolve();
+      deferred.resolve();
       exitCode = code;
     });
-    await promise;
+    await deferred.promise;
     assertStrictEquals(exitCode, 0);
     assertStrictEquals(childProcess.exitCode, exitCode);
   } finally {
@@ -59,16 +60,16 @@ Deno.test("[node/child_process spawn] The 'exit' event is emitted with an exit c
 });
 
 Deno.test("[node/child_process disconnect] the method exists", async () => {
-  const promise = withTimeout();
+  const deferred = withTimeout<void>();
   const childProcess = spawn(Deno.execPath(), ["--help"], {
     env: { NO_COLOR: "true" },
   });
   try {
     childProcess.disconnect();
     childProcess.on("exit", () => {
-      promise.resolve();
+      deferred.resolve();
     });
-    await promise;
+    await deferred.promise;
   } finally {
     childProcess.kill();
     childProcess.stdout?.destroy();
@@ -79,7 +80,7 @@ Deno.test("[node/child_process disconnect] the method exists", async () => {
 Deno.test({
   name: "[node/child_process spawn] Verify that stdin and stdout work",
   fn: async () => {
-    const promise = withTimeout();
+    const deferred = withTimeout<void>();
     const childProcess = spawn(Deno.execPath(), ["fmt", "-"], {
       env: { NO_COLOR: "true" },
       stdio: ["pipe", "pipe"],
@@ -94,9 +95,9 @@ Deno.test({
       childProcess.stdin.write("  console.log('hello')", "utf-8");
       childProcess.stdin.end();
       childProcess.on("close", () => {
-        promise.resolve();
+        deferred.resolve();
       });
-      await promise;
+      await deferred.promise;
       assertStrictEquals(data, `console.log("hello");\n`);
     } finally {
       childProcess.kill();
@@ -107,7 +108,7 @@ Deno.test({
 Deno.test({
   name: "[node/child_process spawn] stdin and stdout with binary data",
   fn: async () => {
-    const promise = withTimeout();
+    const deferred = withTimeout<void>();
     const p = path.join(
       path.dirname(path.fromFileUrl(import.meta.url)),
       "./testdata/binary_stdio.js",
@@ -127,9 +128,9 @@ Deno.test({
       childProcess.stdin.write(buffer);
       childProcess.stdin.end();
       childProcess.on("close", () => {
-        promise.resolve();
+        deferred.resolve();
       });
-      await promise;
+      await deferred.promise;
       assertEquals(new Uint8Array(data!), buffer);
     } finally {
       childProcess.kill();
@@ -140,7 +141,7 @@ Deno.test({
 async function spawnAndGetEnvValue(
   inputValue: string | number | boolean,
 ): Promise<string> {
-  const promise = withTimeout<string>();
+  const deferred = withTimeout<string>();
   const env = spawn(
     `"${Deno.execPath()}" eval -p "Deno.env.toObject().BAZ"`,
     {
@@ -152,14 +153,14 @@ async function spawnAndGetEnvValue(
     let envOutput = "";
 
     assert(env.stdout);
-    env.on("error", (err: Error) => promise.reject(err));
+    env.on("error", (err: Error) => deferred.reject(err));
     env.stdout.on("data", (data) => {
       envOutput += data;
     });
     env.on("close", () => {
-      promise.resolve(envOutput.trim());
+      deferred.resolve(envOutput.trim());
     });
-    return await promise;
+    return await deferred.promise;
   } finally {
     env.kill();
   }
@@ -191,7 +192,7 @@ Deno.test({
 
 // TODO(uki00a): Remove this case once Node's `parallel/test-child-process-spawn-event.js` works.
 Deno.test("[child_process spawn] 'spawn' event", async () => {
-  const timeout = withTimeout();
+  const timeout = withTimeout<void>();
   const subprocess = spawn(Deno.execPath(), ["eval", "console.log('ok')"]);
 
   let didSpawn = false;
@@ -205,13 +206,13 @@ Deno.test("[child_process spawn] 'spawn' event", async () => {
 
   const promises = [] as Promise<void>[];
   function mustBeCalledAfterSpawn() {
-    const promise = deferred<void>();
-    promises.push(promise);
+    const deferred = Promise.withResolvers<void>();
+    promises.push(deferred.promise);
     return () => {
       if (didSpawn) {
-        promise.resolve();
+        deferred.resolve();
       } else {
-        promise.reject(
+        deferred.reject(
           new Error("function should be called after the 'spawn' event"),
         );
       }
@@ -229,7 +230,7 @@ Deno.test("[child_process spawn] 'spawn' event", async () => {
   subprocess.on("close", mustBeCalledAfterSpawn());
 
   try {
-    await Promise.race([Promise.all(promises), timeout]);
+    await Promise.race([Promise.all(promises), timeout.promise]);
     timeout.resolve();
   } finally {
     subprocess.kill();
@@ -238,12 +239,12 @@ Deno.test("[child_process spawn] 'spawn' event", async () => {
 
 // TODO(uki00a): Remove this case once Node's `parallel/test-child-process-spawn-shell.js` works.
 Deno.test("[child_process spawn] Verify that a shell is executed", async () => {
-  const promise = withTimeout();
+  const deferred = withTimeout<void>();
   const doesNotExist = spawn("does-not-exist", { shell: true });
   try {
     assertNotStrictEquals(doesNotExist.spawnfile, "does-not-exist");
     doesNotExist.on("error", () => {
-      promise.reject("The 'error' event must not be emitted.");
+      deferred.reject("The 'error' event must not be emitted.");
     });
     doesNotExist.on("exit", (code: number, signal: null) => {
       assertStrictEquals(signal, null);
@@ -254,9 +255,9 @@ Deno.test("[child_process spawn] Verify that a shell is executed", async () => {
         assertStrictEquals(code, 127); // Exit code of /bin/sh });
       }
 
-      promise.resolve();
+      deferred.resolve();
     });
-    await promise;
+    await deferred.promise;
   } finally {
     doesNotExist.kill();
     doesNotExist.stdout?.destroy();
@@ -269,7 +270,7 @@ Deno.test({
   ignore: Deno.build.os === "windows",
   name: "[node/child_process spawn] Verify that passing arguments works",
   async fn() {
-    const promise = withTimeout();
+    const deferred = withTimeout<void>();
     const echo = spawn("echo", ["foo"], {
       shell: true,
     });
@@ -286,9 +287,9 @@ Deno.test({
       });
       echo.on("close", () => {
         assertStrictEquals(echoOutput.trim(), "foo");
-        promise.resolve();
+        deferred.resolve();
       });
-      await promise;
+      await deferred.promise;
     } finally {
       echo.kill();
     }
@@ -300,7 +301,7 @@ Deno.test({
   ignore: Deno.build.os === "windows",
   name: "[node/child_process spawn] Verity that shell features can be used",
   async fn() {
-    const promise = withTimeout();
+    const deferred = withTimeout<void>();
     const cmd = "echo bar | cat";
     const command = spawn(cmd, {
       shell: true,
@@ -315,10 +316,10 @@ Deno.test({
 
       command.on("close", () => {
         assertStrictEquals(commandOutput.trim(), "bar");
-        promise.resolve();
+        deferred.resolve();
       });
 
-      await promise;
+      await deferred.promise;
     } finally {
       command.kill();
     }
@@ -331,7 +332,7 @@ Deno.test({
   name:
     "[node/child_process spawn] Verity that environment is properly inherited",
   async fn() {
-    const promise = withTimeout();
+    const deferred = withTimeout<void>();
     const env = spawn(
       `"${Deno.execPath()}" eval -p "Deno.env.toObject().BAZ"`,
       {
@@ -343,15 +344,15 @@ Deno.test({
       let envOutput = "";
 
       assert(env.stdout);
-      env.on("error", (err: Error) => promise.reject(err));
+      env.on("error", (err: Error) => deferred.reject(err));
       env.stdout.on("data", (data) => {
         envOutput += data;
       });
       env.on("close", () => {
         assertStrictEquals(envOutput.trim(), "buzz");
-        promise.resolve();
+        deferred.resolve();
       });
-      await promise;
+      await deferred.promise;
     } finally {
       env.kill();
     }
@@ -496,16 +497,16 @@ Deno.test({
       "./testdata/infinite_loop.js",
     );
     const childProcess = spawn(Deno.execPath(), ["run", script]);
-    const p = withTimeout();
-    const pStdout = withTimeout();
-    const pStderr = withTimeout();
+    const p = withTimeout<void>();
+    const pStdout = withTimeout<void>();
+    const pStderr = withTimeout<void>();
     childProcess.on("exit", () => p.resolve());
     childProcess.stdout.on("close", () => pStdout.resolve());
     childProcess.stderr.on("close", () => pStderr.resolve());
     childProcess.kill("SIGKILL");
-    await p;
-    await pStdout;
-    await pStderr;
+    await p.promise;
+    await pStdout.promise;
+    await pStderr.promise;
     assert(childProcess.killed);
     assertEquals(childProcess.signalCode, "SIGKILL");
     assertExists(childProcess.exitCode);
@@ -527,9 +528,9 @@ Deno.test({
       "--unstable",
       script,
     ]);
-    const p = deferred();
-    childProcess.on("exit", () => p.resolve());
-    await p;
+    const deferred = Promise.withResolvers<void>();
+    childProcess.on("exit", () => deferred.resolve());
+    await deferred.promise;
   },
 });
 
@@ -547,14 +548,14 @@ Deno.test({
       "foo",
       "index.js",
     );
-    const p = deferred();
+    const p = Promise.withResolvers<void>();
     const cp = CP.fork(script, [], { cwd: testdataDir, stdio: "pipe" });
     let output = "";
     cp.on("close", () => p.resolve());
     cp.stdout?.on("data", (data) => {
       output += data;
     });
-    await p;
+    await p.promise;
     assertEquals(output, "foo\ntrue\ntrue\ntrue\n");
   },
 });
@@ -567,7 +568,7 @@ Deno.test(
   "[node/child_process spawn] supports windowsVerbatimArguments option",
   { ignore: Deno.build.os !== "windows" },
   async () => {
-    const cmdFinished = deferred();
+    const cmdFinished = Promise.withResolvers<void>();
     let output = "";
     const cp = spawn("cmd", ["/d", "/s", "/c", '"deno ^"--version^""'], {
       stdio: "pipe",
@@ -577,7 +578,7 @@ Deno.test(
     cp.stdout?.on("data", (data) => {
       output += data;
     });
-    await cmdFinished;
+    await cmdFinished.promise;
     assertStringIncludes(output, "deno");
     assertStringIncludes(output, "v8");
     assertStringIncludes(output, "typescript");
@@ -587,7 +588,7 @@ Deno.test(
 Deno.test(
   "[node/child_process spawn] supports stdio array option",
   async () => {
-    const cmdFinished = deferred();
+    const cmdFinished = Promise.withResolvers<void>();
     let output = "";
     const script = path.join(
       path.dirname(path.fromFileUrl(import.meta.url)),
@@ -599,7 +600,7 @@ Deno.test(
       output += data;
     });
     cp.on("close", () => cmdFinished.resolve());
-    await cmdFinished;
+    await cmdFinished.promise;
 
     assertStringIncludes(output, "foo");
     assertStringIncludes(output, "close");
@@ -609,7 +610,7 @@ Deno.test(
 Deno.test(
   "[node/child_process spawn] supports stdio [0, 1, 2] option",
   async () => {
-    const cmdFinished = deferred();
+    const cmdFinished = Promise.withResolvers<void>();
     let output = "";
     const script = path.join(
       path.dirname(path.fromFileUrl(import.meta.url)),
@@ -621,7 +622,7 @@ Deno.test(
       output += data;
     });
     cp.on("close", () => cmdFinished.resolve());
-    await cmdFinished;
+    await cmdFinished.promise;
 
     assertStringIncludes(output, "foo");
     assertStringIncludes(output, "close");
@@ -638,16 +639,16 @@ Deno.test({
 
     // Spawn an infinite cat
     const cp = spawn("cat", ["-"]);
-    const p = withTimeout();
-    const pStdout = withTimeout();
-    const pStderr = withTimeout();
+    const p = withTimeout<void>();
+    const pStdout = withTimeout<void>();
+    const pStderr = withTimeout<void>();
     cp.on("exit", () => p.resolve());
     cp.stdout.on("close", () => pStdout.resolve());
     cp.stderr.on("close", () => pStderr.resolve());
     cp.kill("SIGIOT");
-    await p;
-    await pStdout;
-    await pStderr;
+    await p.promise;
+    await pStdout.promise;
+    await pStderr.promise;
     assert(cp.killed);
     assertEquals(cp.signalCode, "SIGIOT");
   },
@@ -655,7 +656,7 @@ Deno.test({
 
 // Regression test for https://github.com/denoland/deno/issues/20373
 Deno.test(async function undefinedValueInEnvVar() {
-  const promise = withTimeout<string>();
+  const deferred = withTimeout<string>();
   const env = spawn(
     `"${Deno.execPath()}" eval -p "Deno.env.toObject().BAZ"`,
     {
@@ -673,18 +674,18 @@ Deno.test(async function undefinedValueInEnvVar() {
     let envOutput = "";
 
     assert(env.stdout);
-    env.on("error", (err: Error) => promise.reject(err));
+    env.on("error", (err: Error) => deferred.reject(err));
     env.stdout.on("data", (data) => {
       envOutput += data;
     });
     env.on("close", () => {
-      promise.resolve(envOutput.trim());
+      deferred.resolve(envOutput.trim());
     });
-    await promise;
+    await deferred.promise;
   } finally {
     env.kill();
   }
-  const value = await promise;
+  const value = await deferred.promise;
   assertEquals(value, "BAZ");
 });
 
diff --git a/cli/tests/unit_node/events_test.ts b/cli/tests/unit_node/events_test.ts
index e341a17cb..6c447f05d 100644
--- a/cli/tests/unit_node/events_test.ts
+++ b/cli/tests/unit_node/events_test.ts
@@ -1,12 +1,11 @@
 // Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
 
-import { deferred } from "../../../test_util/std/async/deferred.ts";
 import { EventEmitter } from "node:events";
 
 EventEmitter.captureRejections = true;
 
 Deno.test("regression #20441", async () => {
-  const promise = deferred();
+  const { promise, resolve } = Promise.withResolvers<void>();
 
   const ee = new EventEmitter();
 
@@ -20,7 +19,7 @@ Deno.test("regression #20441", async () => {
   });
 
   ee.on("error", function (_) {
-    promise.resolve();
+    resolve();
   });
 
   ee.emit("foo");
diff --git a/cli/tests/unit_node/http2_test.ts b/cli/tests/unit_node/http2_test.ts
index d0e0de43f..87ad6c748 100644
--- a/cli/tests/unit_node/http2_test.ts
+++ b/cli/tests/unit_node/http2_test.ts
@@ -2,7 +2,6 @@
 
 import * as http2 from "node:http2";
 import * as net from "node:net";
-import { deferred } from "../../../test_util/std/async/deferred.ts";
 import { assertEquals } from "../../../test_util/std/testing/asserts.ts";
 
 for (const url of ["http://127.0.0.1:4246", "https://127.0.0.1:4247"]) {
@@ -41,17 +40,17 @@ for (const url of ["http://127.0.0.1:4246", "https://127.0.0.1:4247"]) {
     });
     req.end();
 
-    const endPromise = deferred();
+    const { promise, resolve } = Promise.withResolvers<void>();
     setTimeout(() => {
       try {
         client.close();
       } catch (_) {
         // pass
       }
-      endPromise.resolve();
+      resolve();
     }, 2000);
 
-    await endPromise;
+    await promise;
     assertEquals(receivedHeaders, { ":status": 200 });
     assertEquals(receivedData, "hello world\n");
 
@@ -67,14 +66,14 @@ Deno.test(`[node/http2 client createConnection]`, {
   ignore: Deno.build.os === "windows",
 }, async () => {
   const url = "http://127.0.0.1:4246";
-  const createConnPromise = deferred();
+  const createConnDeferred = Promise.withResolvers<void>();
   // Create a server to respond to the HTTP2 requests
   const client = http2.connect(url, {
     createConnection() {
       const socket = net.connect({ host: "127.0.0.1", port: 4246 });
 
       socket.on("connect", () => {
-        createConnPromise.resolve();
+        createConnDeferred.resolve();
       });
 
       return socket;
@@ -94,7 +93,7 @@ Deno.test(`[node/http2 client createConnection]`, {
   });
   req.end();
 
-  const endPromise = deferred();
+  const endPromise = Promise.withResolvers<void>();
   setTimeout(() => {
     try {
       client.close();
@@ -104,8 +103,8 @@ Deno.test(`[node/http2 client createConnection]`, {
     endPromise.resolve();
   }, 2000);
 
-  await createConnPromise;
-  await endPromise;
+  await createConnDeferred.promise;
+  await endPromise.promise;
   assertEquals(receivedData, "hello world\n");
 });
 
@@ -127,11 +126,9 @@ Deno.test("[node/http2 server]", { sanitizeOps: false }, async () => {
   const stream = await new Promise<http2.ServerHttp2Stream>((resolve) =>
     session.on("stream", resolve)
   );
-  const _headers = await new Promise((resolve) =>
-    stream.on("headers", resolve)
-  );
-  const _data = await new Promise((resolve) => stream.on("data", resolve));
-  const _end = await new Promise((resolve) => stream.on("end", resolve));
+  await new Promise((resolve) => stream.on("headers", resolve));
+  await new Promise((resolve) => stream.on("data", resolve));
+  await new Promise((resolve) => stream.on("end", resolve));
   stream.respond();
   stream.end();
   const resp = await responsePromise;
diff --git a/cli/tests/unit_node/http_test.ts b/cli/tests/unit_node/http_test.ts
index 84d25e42c..ef78432cb 100644
--- a/cli/tests/unit_node/http_test.ts
+++ b/cli/tests/unit_node/http_test.ts
@@ -9,7 +9,6 @@ import {
   fail,
 } from "../../../test_util/std/testing/asserts.ts";
 import { assertSpyCalls, spy } from "../../../test_util/std/testing/mock.ts";
-import { deferred } from "../../../test_util/std/async/deferred.ts";
 
 import { gzip } from "node:zlib";
 import { Buffer } from "node:buffer";
@@ -28,42 +27,42 @@ Deno.test("[node/http listen]", async () => {
   }
 
   {
-    const promise = deferred<void>();
+    const { promise, resolve } = Promise.withResolvers<void>();
     const server = http.createServer();
 
     server.listen(() => {
       server.close();
     });
     server.on("close", () => {
-      promise.resolve();
+      resolve();
     });
 
     await promise;
   }
 
   {
-    const promise = deferred<void>();
+    const { promise, resolve } = Promise.withResolvers<void>();
     const server = http.createServer();
 
     server.listen().on("listening", () => {
       server.close();
     });
     server.on("close", () => {
-      promise.resolve();
+      resolve();
     });
 
     await promise;
   }
 
   for (const port of [0, -0, 0.0, "0", null, undefined]) {
-    const promise = deferred<void>();
+    const { promise, resolve } = Promise.withResolvers<void>();
     const server = http.createServer();
 
     server.listen(port, () => {
       server.close();
     });
     server.on("close", () => {
-      promise.resolve();
+      resolve();
     });
 
     await promise;
@@ -72,43 +71,43 @@ Deno.test("[node/http listen]", async () => {
 
 Deno.test("[node/http close]", async () => {
   {
-    const promise1 = deferred<void>();
-    const promise2 = deferred<void>();
+    const deferred1 = Promise.withResolvers<void>();
+    const deferred2 = Promise.withResolvers<void>();
     // Node quirk: callback gets exception object, event listener does not.
     // deno-lint-ignore no-explicit-any
     const server = http.createServer().close((err: any) => {
       assertEquals(err.code, "ERR_SERVER_NOT_RUNNING");
-      promise1.resolve();
+      deferred1.resolve();
     });
     // deno-lint-ignore no-explicit-any
     server.on("close", (err: any) => {
       assertEquals(err, undefined);
-      promise2.resolve();
+      deferred2.resolve();
     });
     server.on("listening", () => {
       throw Error("unreachable");
     });
-    await promise1;
-    await promise2;
+    await deferred1.promise;
+    await deferred2.promise;
   }
 
   {
-    const promise1 = deferred<void>();
-    const promise2 = deferred<void>();
+    const deferred1 = Promise.withResolvers<void>();
+    const deferred2 = Promise.withResolvers<void>();
     const server = http.createServer().listen().close((err) => {
       assertEquals(err, undefined);
-      promise1.resolve();
+      deferred1.resolve();
     });
     // deno-lint-ignore no-explicit-any
     server.on("close", (err: any) => {
       assertEquals(err, undefined);
-      promise2.resolve();
+      deferred2.resolve();
     });
     server.on("listening", () => {
       throw Error("unreachable");
     });
-    await promise1;
-    await promise2;
+    await deferred1.promise;
+    await deferred2.promise;
   }
 });
 
@@ -117,7 +116,7 @@ Deno.test("[node/http] chunked response", async () => {
     const body of [undefined, "", "ok"]
   ) {
     const expected = body ?? "";
-    const promise = deferred<void>();
+    const { promise, resolve } = Promise.withResolvers<void>();
 
     const server = http.createServer((_req, res) => {
       res.writeHead(200, { "transfer-encoding": "chunked" });
@@ -134,7 +133,7 @@ Deno.test("[node/http] chunked response", async () => {
       const actual = await res.text();
       assertEquals(actual, expected);
 
-      server.close(() => promise.resolve());
+      server.close(() => resolve());
     });
 
     await promise;
@@ -143,7 +142,7 @@ Deno.test("[node/http] chunked response", async () => {
 
 // Test empty chunks: https://github.com/denoland/deno/issues/17194
 Deno.test("[node/http] empty chunk in the middle of response", async () => {
-  const promise = deferred<void>();
+  const { promise, resolve } = Promise.withResolvers<void>();
 
   const server = http.createServer((_req, res) => {
     res.write("a");
@@ -159,7 +158,7 @@ Deno.test("[node/http] empty chunk in the middle of response", async () => {
     );
     const actual = await res.text();
     assertEquals(actual, "ab");
-    server.close(() => promise.resolve());
+    server.close(() => resolve());
   });
 
   await promise;
@@ -167,7 +166,7 @@ Deno.test("[node/http] empty chunk in the middle of response", async () => {
 
 Deno.test("[node/http] server can respond with 101, 204, 205, 304 status", async () => {
   for (const status of [101, 204, 205, 304]) {
-    const promise = deferred<void>();
+    const { promise, resolve } = Promise.withResolvers<void>();
     const server = http.createServer((_req, res) => {
       res.statusCode = status;
       res.end("");
@@ -179,15 +178,15 @@ Deno.test("[node/http] server can respond with 101, 204, 205, 304 status", async
       );
       await res.arrayBuffer();
       assertEquals(res.status, status);
-      server.close(() => promise.resolve());
+      server.close(() => resolve());
     });
     await promise;
   }
 });
 
 Deno.test("[node/http] request default protocol", async () => {
-  const promise = deferred<void>();
-  const promise2 = deferred<void>();
+  const deferred1 = Promise.withResolvers<void>();
+  const deferred2 = Promise.withResolvers<void>();
   const server = http.createServer((_, res) => {
     res.end("ok");
   });
@@ -210,22 +209,22 @@ Deno.test("[node/http] request default protocol", async () => {
         });
         clientRes = res;
         assertEquals(res.statusCode, 200);
-        promise2.resolve();
+        deferred2.resolve();
       },
     );
     clientReq.end();
   });
   server.on("close", () => {
-    promise.resolve();
+    deferred1.resolve();
   });
-  await promise;
-  await promise2;
+  await deferred1.promise;
+  await deferred2.promise;
   assert(clientReq.socket instanceof EventEmitter);
   assertEquals(clientRes!.complete, true);
 });
 
 Deno.test("[node/http] request with headers", async () => {
-  const promise = deferred<void>();
+  const { promise, resolve } = Promise.withResolvers<void>();
   const server = http.createServer((req, res) => {
     assertEquals(req.headers["x-foo"], "bar");
     res.end("ok");
@@ -249,7 +248,7 @@ Deno.test("[node/http] request with headers", async () => {
     req.end();
   });
   server.on("close", () => {
-    promise.resolve();
+    resolve();
   });
   await promise;
 });
@@ -258,7 +257,7 @@ Deno.test("[node/http] non-string buffer response", {
   // TODO(kt3k): Enable sanitizer. A "zlib" resource is leaked in this test case.
   sanitizeResources: false,
 }, async () => {
-  const promise = deferred<void>();
+  const { promise, resolve } = Promise.withResolvers<void>();
   const server = http.createServer((_, res) => {
     res.socket!.end();
     gzip(
@@ -281,7 +280,7 @@ Deno.test("[node/http] non-string buffer response", {
     } catch (e) {
       server.emit("error", e);
     } finally {
-      server.close(() => promise.resolve());
+      server.close(() => resolve());
     }
   });
   await promise;
@@ -461,7 +460,7 @@ Deno.test("[node/http] send request with chunked body as default", async () => {
 });
 
 Deno.test("[node/http] ServerResponse _implicitHeader", async () => {
-  const d = deferred<void>();
+  const { promise, resolve } = Promise.withResolvers<void>();
   const server = http.createServer((_req, res) => {
     const writeHeadSpy = spy(res, "writeHead");
     // deno-lint-ignore no-explicit-any
@@ -476,11 +475,11 @@ Deno.test("[node/http] ServerResponse _implicitHeader", async () => {
     const res = await fetch(`http://localhost:${port}`);
     assertEquals(await res.text(), "Hello World");
     server.close(() => {
-      d.resolve();
+      resolve();
     });
   });
 
-  await d;
+  await promise;
 });
 
 Deno.test("[node/http] server unref", async () => {
@@ -504,7 +503,7 @@ Deno.test("[node/http] server unref", async () => {
 Deno.test("[node/http] ClientRequest handle non-string headers", async () => {
   // deno-lint-ignore no-explicit-any
   let headers: any;
-  const def = deferred();
+  const { promise, resolve, reject } = Promise.withResolvers<void>();
   const req = http.request("http://localhost:4545/echo_server", {
     method: "POST",
     headers: { 1: 2 },
@@ -514,18 +513,18 @@ Deno.test("[node/http] ClientRequest handle non-string headers", async () => {
     resp.on("data", () => {});
 
     resp.on("end", () => {
-      def.resolve();
+      resolve();
     });
   });
-  req.once("error", (e) => def.reject(e));
+  req.once("error", (e) => reject(e));
   req.end();
-  await def;
+  await promise;
   assertEquals(headers!["1"], "2");
 });
 
 Deno.test("[node/http] ClientRequest uses HTTP/1.1", async () => {
   let body = "";
-  const def = deferred();
+  const { promise, resolve, reject } = Promise.withResolvers<void>();
   const req = https.request("https://localhost:5545/http_version", {
     method: "POST",
     headers: { 1: 2 },
@@ -535,39 +534,39 @@ Deno.test("[node/http] ClientRequest uses HTTP/1.1", async () => {
     });
 
     resp.on("end", () => {
-      def.resolve();
+      resolve();
     });
   });
-  req.once("error", (e) => def.reject(e));
+  req.once("error", (e) => reject(e));
   req.end();
-  await def;
+  await promise;
   assertEquals(body, "HTTP/1.1");
 });
 
 Deno.test("[node/http] ClientRequest setTimeout", async () => {
   let body = "";
-  const def = deferred();
-  const timer = setTimeout(() => def.reject("timed out"), 50000);
+  const { promise, resolve, reject } = Promise.withResolvers<void>();
+  const timer = setTimeout(() => reject("timed out"), 50000);
   const req = http.request("http://localhost:4545/http_version", (resp) => {
     resp.on("data", (chunk) => {
       body += chunk;
     });
 
     resp.on("end", () => {
-      def.resolve();
+      resolve();
     });
   });
   req.setTimeout(120000);
-  req.once("error", (e) => def.reject(e));
+  req.once("error", (e) => reject(e));
   req.end();
-  await def;
+  await promise;
   clearTimeout(timer);
   assertEquals(body, "HTTP/1.1");
 });
 
 Deno.test("[node/http] ClientRequest PATCH", async () => {
   let body = "";
-  const def = deferred();
+  const { promise, resolve, reject } = Promise.withResolvers<void>();
   const req = http.request("http://localhost:4545/echo_server", {
     method: "PATCH",
   }, (resp) => {
@@ -576,20 +575,20 @@ Deno.test("[node/http] ClientRequest PATCH", async () => {
     });
 
     resp.on("end", () => {
-      def.resolve();
+      resolve();
     });
   });
   req.write("hello ");
   req.write("world");
-  req.once("error", (e) => def.reject(e));
+  req.once("error", (e) => reject(e));
   req.end();
-  await def;
+  await promise;
   assertEquals(body, "hello world");
 });
 
 Deno.test("[node/http] ClientRequest PUT", async () => {
   let body = "";
-  const def = deferred();
+  const { promise, resolve, reject } = Promise.withResolvers<void>();
   const req = http.request("http://localhost:4545/echo_server", {
     method: "PUT",
   }, (resp) => {
@@ -598,20 +597,20 @@ Deno.test("[node/http] ClientRequest PUT", async () => {
     });
 
     resp.on("end", () => {
-      def.resolve();
+      resolve();
     });
   });
   req.write("hello ");
   req.write("world");
-  req.once("error", (e) => def.reject(e));
+  req.once("error", (e) => reject(e));
   req.end();
-  await def;
+  await promise;
   assertEquals(body, "hello world");
 });
 
 Deno.test("[node/http] ClientRequest search params", async () => {
   let body = "";
-  const def = deferred();
+  const { promise, resolve, reject } = Promise.withResolvers<void>();
   const req = http.request({
     host: "localhost:4545",
     path: "search_params?foo=bar",
@@ -621,18 +620,18 @@ Deno.test("[node/http] ClientRequest search params", async () => {
     });
 
     resp.on("end", () => {
-      def.resolve();
+      resolve();
     });
   });
-  req.once("error", (e) => def.reject(e));
+  req.once("error", (e) => reject(e));
   req.end();
-  await def;
+  await promise;
   assertEquals(body, "foo=bar");
 });
 
 Deno.test("[node/http] HTTPS server", async () => {
-  const promise = deferred<void>();
-  const promise2 = deferred<void>();
+  const deferred = Promise.withResolvers<void>();
+  const deferred2 = Promise.withResolvers<void>();
   const client = Deno.createHttpClient({
     caCerts: [Deno.readTextFileSync("cli/tests/testdata/tls/RootCA.pem")],
   });
@@ -652,14 +651,14 @@ Deno.test("[node/http] HTTPS server", async () => {
       assertEquals(res.status, 200);
       assertEquals(await res.text(), "success!");
       server.close();
-      promise2.resolve();
+      deferred2.resolve();
     });
   })
     .on("error", () => fail());
   server.on("close", () => {
-    promise.resolve();
+    deferred.resolve();
   });
-  await Promise.all([promise, promise2]);
+  await Promise.all([deferred.promise, deferred2.promise]);
   client.close();
 });
 
@@ -667,7 +666,7 @@ Deno.test(
   "[node/http] client upgrade",
   { permissions: { net: true } },
   async () => {
-    const promise = deferred();
+    const { promise, resolve } = Promise.withResolvers<void>();
     const server = http.createServer((req, res) => {
       // @ts-ignore: It exists on TLSSocket
       assert(!req.socket.encrypted);
@@ -706,7 +705,7 @@ Deno.test(
         // @ts-ignore it's a socket for real
         serverSocket!.end();
         server.close(() => {
-          promise.resolve();
+          resolve();
         });
       });
     });
@@ -725,7 +724,7 @@ Deno.test(
       received = true;
       return new Response("hello");
     });
-    const promise = deferred();
+    const { promise, resolve, reject } = Promise.withResolvers<void>();
     let body = "";
 
     const request = http.request(
@@ -736,11 +735,11 @@ Deno.test(
         });
 
         resp.on("end", () => {
-          promise.resolve();
+          resolve();
         });
       },
     );
-    request.on("error", promise.reject);
+    request.on("error", reject);
     request.end(() => {
       assert(received);
     });
@@ -754,22 +753,22 @@ Deno.test(
 );
 
 Deno.test("[node/http] server emits error if addr in use", async () => {
-  const promise = deferred<void>();
-  const promise2 = deferred<Error>();
+  const deferred1 = Promise.withResolvers<void>();
+  const deferred2 = Promise.withResolvers<Error>();
 
   const server = http.createServer();
   server.listen(9001);
 
   const server2 = http.createServer();
   server2.on("error", (e) => {
-    promise2.resolve(e);
+    deferred2.resolve(e);
   });
   server2.listen(9001);
 
-  const err = await promise2;
-  server.close(() => promise.resolve());
+  const err = await deferred2.promise;
+  server.close(() => deferred1.resolve());
   server2.close();
-  await promise;
+  await deferred1.promise;
   const expectedMsg = Deno.build.os === "windows"
     ? "Only one usage of each socket address"
     : "Address already in use";
@@ -795,15 +794,15 @@ Deno.test(
         return new Response("hello");
       },
     );
-    const promise = deferred();
+    const { promise, resolve, reject } = Promise.withResolvers<void>();
 
     const request = http.request("http://localhost:5929/");
-    request.on("error", promise.reject);
+    request.on("error", reject);
     request.on("close", () => {});
     request.end();
     setTimeout(() => {
       request.destroy(new Error());
-      promise.resolve();
+      resolve();
     }, 100);
 
     await promise;
diff --git a/cli/tests/unit_node/internal/_randomFill_test.ts b/cli/tests/unit_node/internal/_randomFill_test.ts
index 5e2e154c8..5d56ca65a 100644
--- a/cli/tests/unit_node/internal/_randomFill_test.ts
+++ b/cli/tests/unit_node/internal/_randomFill_test.ts
@@ -6,7 +6,6 @@ import {
   assertNotEquals,
   assertThrows,
 } from "../../../../test_util/std/testing/asserts.ts";
-import { deferred } from "../../../../test_util/std/async/deferred.ts";
 
 const validateNonZero = (buf: Buffer) => {
   if (!buf.some((ch) => ch > 0)) throw new Error("Error");
@@ -17,14 +16,14 @@ const validateZero = (buf: Buffer) => {
 };
 
 Deno.test("[node/crypto.randomFill]", async () => {
-  const promise = deferred();
+  const { promise, resolve } = Promise.withResolvers<boolean>();
   const buf = Buffer.alloc(10);
   const before = buf.toString("hex");
 
   randomFill(buf, 5, 5, (_err, bufTwo) => {
     const after = bufTwo?.toString("hex");
     assertEquals(before.slice(0, 10), after?.slice(0, 10));
-    promise.resolve(true);
+    resolve(true);
   });
 
   await promise;
diff --git a/cli/tests/unit_node/internal/scrypt_test.ts b/cli/tests/unit_node/internal/scrypt_test.ts
index d65cd27ff..83830f8e4 100644
--- a/cli/tests/unit_node/internal/scrypt_test.ts
+++ b/cli/tests/unit_node/internal/scrypt_test.ts
@@ -2,10 +2,9 @@
 import { scrypt, scryptSync } from "node:crypto";
 import { Buffer } from "node:buffer";
 import { assertEquals } from "../../../../test_util/std/testing/asserts.ts";
-import { deferred } from "../../../../test_util/std/async/deferred.ts";
 
 Deno.test("scrypt works correctly", async () => {
-  const promise = deferred();
+  const { promise, resolve } = Promise.withResolvers<boolean>();
 
   scrypt("password", "salt", 32, (err, key) => {
     if (err) throw err;
@@ -46,14 +45,14 @@ Deno.test("scrypt works correctly", async () => {
         115,
       ]),
     );
-    promise.resolve(true);
+    resolve(true);
   });
 
   await promise;
 });
 
 Deno.test("scrypt works with options", async () => {
-  const promise = deferred();
+  const { promise, resolve } = Promise.withResolvers<boolean>();
 
   scrypt(
     "password",
@@ -101,7 +100,7 @@ Deno.test("scrypt works with options", async () => {
           71,
         ]),
       );
-      promise.resolve(true);
+      resolve(true);
     },
   );
 
diff --git a/cli/tests/unit_node/net_test.ts b/cli/tests/unit_node/net_test.ts
index ca9d214e1..e55adafcb 100644
--- a/cli/tests/unit_node/net_test.ts
+++ b/cli/tests/unit_node/net_test.ts
@@ -5,15 +5,14 @@ import {
   assert,
   assertEquals,
 } from "../../../test_util/std/testing/asserts.ts";
-import { Deferred, deferred } from "../../../test_util/std/async/deferred.ts";
 import * as path from "../../../test_util/std/path/mod.ts";
 import * as http from "node:http";
 
 Deno.test("[node/net] close event emits after error event", async () => {
   const socket = net.createConnection(27009, "doesnotexist");
   const events: ("error" | "close")[] = [];
-  const errorEmitted = deferred();
-  const closeEmitted = deferred();
+  const errorEmitted = Promise.withResolvers<void>();
+  const closeEmitted = Promise.withResolvers<void>();
   socket.once("error", () => {
     events.push("error");
     errorEmitted.resolve();
@@ -22,14 +21,14 @@ Deno.test("[node/net] close event emits after error event", async () => {
     events.push("close");
     closeEmitted.resolve();
   });
-  await Promise.all([errorEmitted, closeEmitted]);
+  await Promise.all([errorEmitted.promise, closeEmitted.promise]);
 
   // `error` happens before `close`
   assertEquals(events, ["error", "close"]);
 });
 
 Deno.test("[node/net] the port is available immediately after close callback", async () => {
-  const p = deferred();
+  const deferred = Promise.withResolvers<void>();
 
   // This simulates what get-port@5.1.1 does.
   const getAvailablePort = (port: number) =>
@@ -48,11 +47,11 @@ Deno.test("[node/net] the port is available immediately after close callback", a
   const port = await getAvailablePort(5555);
 
   const httpServer = http.createServer();
-  httpServer.on("error", (e) => p.reject(e));
+  httpServer.on("error", (e) => deferred.reject(e));
   httpServer.listen(port, () => {
-    httpServer.close(() => p.resolve());
+    httpServer.close(() => deferred.resolve());
   });
-  await p;
+  await deferred.promise;
 });
 
 Deno.test("[node/net] net.connect().unref() works", async () => {
@@ -100,16 +99,16 @@ Deno.test({
 });
 
 Deno.test("[node/net] connection event has socket value", async () => {
-  const p = deferred();
-  const p2 = deferred();
+  const deferred = Promise.withResolvers<void>();
+  const deferred2 = Promise.withResolvers<void>();
 
   const server = net.createServer();
-  server.on("error", p.reject);
+  server.on("error", deferred.reject);
   server.on("connection", (socket) => {
     assert(socket !== undefined);
     socket.end();
     server.close(() => {
-      p.resolve();
+      deferred.resolve();
     });
   });
   server.listen(async () => {
@@ -125,10 +124,10 @@ Deno.test("[node/net] connection event has socket value", async () => {
       //
     }
 
-    p2.resolve();
+    deferred2.resolve();
   });
 
-  await Promise.all([p, p2]);
+  await Promise.all([deferred.promise, deferred2.promise]);
 });
 
 /// We need to make sure that any shared buffers are never used concurrently by two reads.
@@ -137,17 +136,19 @@ Deno.test("[node/net] multiple Sockets should get correct server data", async ()
   const socketCount = 9;
 
   class TestSocket {
-    dataReceived: Deferred<undefined> = deferred();
+    dataReceived: ReturnType<typeof Promise.withResolvers<void>> = Promise
+      .withResolvers<void>();
     events: string[] = [];
     socket: net.Socket | undefined;
   }
 
-  const finished = deferred();
-  const serverSocketsClosed: Deferred<undefined>[] = [];
+  const finished = Promise.withResolvers<void>();
+  const serverSocketsClosed: ReturnType<typeof Promise.withResolvers<void>>[] =
+    [];
   const server = net.createServer();
   server.on("connection", (socket) => {
     assert(socket !== undefined);
-    const i = serverSocketsClosed.push(deferred());
+    const i = serverSocketsClosed.push(Promise.withResolvers<void>());
     socket.on("data", (data) => {
       socket.write(new TextDecoder().decode(data));
     });
@@ -183,7 +184,7 @@ Deno.test("[node/net] multiple Sockets should get correct server data", async ()
       sockets[i].socket?.write(`${i}`.repeat(3));
     }
 
-    await Promise.all(sockets.map((socket) => socket.dataReceived));
+    await Promise.all(sockets.map((socket) => socket.dataReceived.promise));
 
     for (let i = 0; i < socketCount; i++) {
       sockets[i].socket?.end();
@@ -194,8 +195,8 @@ Deno.test("[node/net] multiple Sockets should get correct server data", async ()
     });
   });
 
-  await finished;
-  await Promise.all(serverSocketsClosed);
+  await finished.promise;
+  await Promise.all(serverSocketsClosed.map(({ promise }) => promise));
 
   for (let i = 0; i < socketCount; i++) {
     assertEquals(sockets[i].events, [`${i}`.repeat(3), `${i}`.repeat(3)]);
diff --git a/cli/tests/unit_node/process_test.ts b/cli/tests/unit_node/process_test.ts
index a572f11b2..ffb95413a 100644
--- a/cli/tests/unit_node/process_test.ts
+++ b/cli/tests/unit_node/process_test.ts
@@ -13,7 +13,6 @@ import {
   assertThrows,
 } from "../../../test_util/std/testing/asserts.ts";
 import { stripColor } from "../../../test_util/std/fmt/colors.ts";
-import { deferred } from "../../../test_util/std/async/deferred.ts";
 import * as path from "../../../test_util/std/path/mod.ts";
 import { delay } from "../../../test_util/std/async/delay.ts";
 
@@ -368,7 +367,7 @@ Deno.test({
   // stdin resource is present before the test starts.
   sanitizeResources: false,
   async fn() {
-    const promise = deferred();
+    const { promise, resolve } = Promise.withResolvers<void>();
     const expected = ["foo", "bar", null, "end"];
     const data: (string | null)[] = [];
 
@@ -385,7 +384,7 @@ Deno.test({
       process.stdin.push("bar");
       process.nextTick(() => {
         process.stdin.push(null);
-        promise.resolve();
+        resolve();
       });
     });
 
diff --git a/cli/tests/unit_node/tls_test.ts b/cli/tests/unit_node/tls_test.ts
index 7a270c60b..0a3a91144 100644
--- a/cli/tests/unit_node/tls_test.ts
+++ b/cli/tests/unit_node/tls_test.ts
@@ -5,7 +5,6 @@ import {
   assertInstanceOf,
 } from "../../../test_util/std/testing/asserts.ts";
 import { delay } from "../../../test_util/std/async/delay.ts";
-import { deferred } from "../../../test_util/std/async/deferred.ts";
 import { fromFileUrl, join } from "../../../test_util/std/path/mod.ts";
 import { serveTls } from "../../../test_util/std/http/server.ts";
 import * as tls from "node:tls";
@@ -89,7 +88,7 @@ Deno.test("tls.connect mid-read tcp->tls upgrade", async () => {
 });
 
 Deno.test("tls.createServer creates a TLS server", async () => {
-  const p = deferred();
+  const deferred = Promise.withResolvers<void>();
   const server = tls.createServer(
     // deno-lint-ignore no-explicit-any
     { host: "0.0.0.0", key, cert } as any,
@@ -131,9 +130,9 @@ Deno.test("tls.createServer creates a TLS server", async () => {
 
     conn.close();
     server.close();
-    p.resolve();
+    deferred.resolve();
   });
-  await p;
+  await deferred.promise;
 });
 
 Deno.test("TLSSocket can construct without options", () => {
diff --git a/cli/tests/unit_node/zlib_test.ts b/cli/tests/unit_node/zlib_test.ts
index b878b7cc3..c025849da 100644
--- a/cli/tests/unit_node/zlib_test.ts
+++ b/cli/tests/unit_node/zlib_test.ts
@@ -4,7 +4,6 @@ import {
   assert,
   assertEquals,
 } from "../../../test_util/std/testing/asserts.ts";
-import { deferred } from "../../../test_util/std/async/deferred.ts";
 import { fromFileUrl, relative } from "../../../test_util/std/path/mod.ts";
 import {
   brotliCompressSync,
@@ -24,7 +23,7 @@ Deno.test("brotli compression sync", () => {
 });
 
 Deno.test("brotli compression", async () => {
-  const promise = deferred();
+  const { promise, resolve } = Promise.withResolvers<void>();
   const compress = createBrotliCompress();
   const filePath = relative(
     Deno.cwd(),
@@ -43,7 +42,7 @@ Deno.test("brotli compression", async () => {
     const stream2 = input2.pipe(decompress).pipe(output2);
 
     stream2.on("finish", () => {
-      promise.resolve();
+      resolve();
     });
   });
 
@@ -73,12 +72,12 @@ Deno.test(
   "zlib create deflate with dictionary",
   { sanitizeResources: false },
   async () => {
-    const promise = deferred();
+    const { promise, resolve } = Promise.withResolvers<void>();
     const handle = createDeflate({
       dictionary: Buffer.alloc(0),
     });
 
-    handle.on("close", () => promise.resolve());
+    handle.on("close", () => resolve());
     handle.end();
     handle.destroy();