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

Closes #21041

---------

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

10 files changed, 179 insertions, 185 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"],
     );