refactor: Use ES modules for internal runtime code (#17648)

This PR refactors all internal js files (except core) to be written as
ES modules.
`__bootstrap`has been mostly replaced with static imports in form in
`internal:[path to file from repo root]`.
To specify if files are ESM, an `esm` method has been added to
`Extension`, similar to the `js` method.
A new ModuleLoader called `InternalModuleLoader` has been added to
enable the loading of internal specifiers, which is used in all
situations except when a snapshot is only loaded, and not a new one is
created from it.

---------

Co-authored-by: Bartek Iwańczuk <biwanczuk@gmail.com>

1 files changed, 1253 insertions, 1256 deletions

diff --git a/cli/js/40_testing.js b/cli/js/40_testing.js
index 0693fba1a..374dc10ee 100644
--- a/cli/js/40_testing.js
+++ b/cli/js/40_testing.js
@@ -1,899 +1,930 @@
 // Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
-"use strict";
-
-((window) => {
-  const core = window.Deno.core;
-  const ops = core.ops;
-  const { setExitHandler } = window.__bootstrap.os;
-  const { Console } = window.__bootstrap.console;
-  const { serializePermissions } = window.__bootstrap.permissions;
-  const { assert } = window.__bootstrap.infra;
-  const {
-    ArrayFrom,
-    ArrayPrototypeFilter,
-    ArrayPrototypeJoin,
-    ArrayPrototypeMap,
-    ArrayPrototypePush,
-    ArrayPrototypeShift,
-    ArrayPrototypeSort,
-    BigInt,
-    DateNow,
-    Error,
-    FunctionPrototype,
-    Map,
-    MapPrototypeGet,
-    MapPrototypeHas,
-    MapPrototypeSet,
-    MathCeil,
-    ObjectKeys,
-    ObjectPrototypeHasOwnProperty,
-    ObjectPrototypeIsPrototypeOf,
-    Promise,
-    SafeArrayIterator,
-    Set,
-    SymbolToStringTag,
-    TypeError,
-  } = window.__bootstrap.primordials;
-
-  const opSanitizerDelayResolveQueue = [];
-
-  // Even if every resource is closed by the end of a test, there can be a delay
-  // until the pending ops have all finished. This function returns a promise
-  // that resolves when it's (probably) fine to run the op sanitizer.
-  //
-  // This is implemented by adding a macrotask callback that runs after the
-  // timer macrotasks, so we can guarantee that a currently running interval
-  // will have an associated op. An additional `setTimeout` of 0 is needed
-  // before that, though, in order to give time for worker message ops to finish
-  // (since timeouts of 0 don't queue tasks in the timer queue immediately).
-  function opSanitizerDelay() {
-    return new Promise((resolve) => {
-      setTimeout(() => {
-        ArrayPrototypePush(opSanitizerDelayResolveQueue, resolve);
-      }, 0);
-    });
-  }
-
-  function handleOpSanitizerDelayMacrotask() {
-    ArrayPrototypeShift(opSanitizerDelayResolveQueue)?.();
-    return opSanitizerDelayResolveQueue.length === 0;
-  }
-
-  // An async operation to $0 was started in this test, but never completed. This is often caused by not $1.
-  // An async operation to $0 was started in this test, but never completed. Async operations should not complete in a test if they were not started in that test.
-  // deno-fmt-ignore
-  const OP_DETAILS = {
-    "op_blob_read_part": ["read from a Blob or File", "awaiting the result of a Blob or File read"],
-    "op_broadcast_recv": ["receive a message from a BroadcastChannel", "closing the BroadcastChannel"],
-    "op_broadcast_send": ["send a message to a BroadcastChannel", "closing the BroadcastChannel"],
-    "op_chmod_async": ["change the permissions of a file", "awaiting the result of a `Deno.chmod` call"],
-    "op_chown_async": ["change the owner of a file", "awaiting the result of a `Deno.chown` call"],
-    "op_copy_file_async": ["copy a file", "awaiting the result of a `Deno.copyFile` call"],
-    "op_crypto_decrypt": ["decrypt data", "awaiting the result of a `crypto.subtle.decrypt` call"],
-    "op_crypto_derive_bits": ["derive bits from a key", "awaiting the result of a `crypto.subtle.deriveBits` call"],
-    "op_crypto_encrypt": ["encrypt data", "awaiting the result of a `crypto.subtle.encrypt` call"],
-    "op_crypto_generate_key": ["generate a key", "awaiting the result of a `crypto.subtle.generateKey` call"],
-    "op_crypto_sign_key": ["sign data", "awaiting the result of a `crypto.subtle.sign` call"],
-    "op_crypto_subtle_digest": ["digest data", "awaiting the result of a `crypto.subtle.digest` call"],
-    "op_crypto_verify_key": ["verify data", "awaiting the result of a `crypto.subtle.verify` call"],
-    "op_net_recv_udp": ["receive a datagram message via UDP", "awaiting the result of `Deno.DatagramConn#receive` call, or not breaking out of a for await loop looping over a `Deno.DatagramConn`"],
-    "op_net_recv_unixpacket": ["receive a datagram message via Unixpacket", "awaiting the result of `Deno.DatagramConn#receive` call, or not breaking out of a for await loop looping over a `Deno.DatagramConn`"],
-    "op_net_send_udp": ["send a datagram message via UDP", "awaiting the result of `Deno.DatagramConn#send` call"],
-    "op_net_send_unixpacket": ["send a datagram message via Unixpacket", "awaiting the result of `Deno.DatagramConn#send` call"],
-    "op_dns_resolve": ["resolve a DNS name", "awaiting the result of a `Deno.resolveDns` call"],
-    "op_fdatasync_async": ["flush pending data operations for a file to disk", "awaiting the result of a `Deno.fdatasync` call"],
-    "op_fetch_send": ["send a HTTP request", "awaiting the result of a `fetch` call"],
-    "op_ffi_call_nonblocking": ["do a non blocking ffi call", "awaiting the returned promise"] ,
-    "op_ffi_call_ptr_nonblocking": ["do a non blocking ffi call",  "awaiting the returned promise"],
-    "op_flock_async": ["lock a file", "awaiting the result of a `Deno.flock` call"],
-    "op_fs_events_poll": ["get the next file system event", "breaking out of a for await loop looping over `Deno.FsEvents`"],
-    "op_fstat_async": ["get file metadata", "awaiting the result of a `Deno.File#fstat` call"],
-    "op_fsync_async": ["flush pending data operations for a file to disk", "awaiting the result of a `Deno.fsync` call"],
-    "op_ftruncate_async": ["truncate a file", "awaiting the result of a `Deno.ftruncate` call"],
-    "op_funlock_async": ["unlock a file", "awaiting the result of a `Deno.funlock` call"],
-    "op_futime_async": ["change file timestamps", "awaiting the result of a `Deno.futime` call"],
-    "op_http_accept": ["accept a HTTP request", "closing a `Deno.HttpConn`"],
-    "op_http_shutdown": ["shutdown a HTTP connection", "awaiting `Deno.HttpEvent#respondWith`"],
-    "op_http_upgrade_websocket": ["upgrade a HTTP connection to a WebSocket", "awaiting `Deno.HttpEvent#respondWith`"],
-    "op_http_write_headers": ["write HTTP response headers", "awaiting `Deno.HttpEvent#respondWith`"],
-    "op_http_write": ["write HTTP response body", "awaiting `Deno.HttpEvent#respondWith`"],
-    "op_link_async": ["create a hard link", "awaiting the result of a `Deno.link` call"],
-    "op_make_temp_dir_async": ["create a temporary directory", "awaiting the result of a `Deno.makeTempDir` call"],
-    "op_make_temp_file_async": ["create a temporary file", "awaiting the result of a `Deno.makeTempFile` call"],
-    "op_message_port_recv_message": ["receive a message from a MessagePort", "awaiting the result of not closing a `MessagePort`"],
-    "op_mkdir_async": ["create a directory", "awaiting the result of a `Deno.mkdir` call"],
-    "op_net_accept_tcp": ["accept a TCP stream", "closing a `Deno.Listener`"],
-    "op_net_accept_unix": ["accept a Unix stream", "closing a `Deno.Listener`"],
-    "op_net_connect_tcp": ["connect to a TCP server", "awaiting a `Deno.connect` call"],
-    "op_net_connect_unix": ["connect to a Unix server", "awaiting a `Deno.connect` call"],
-    "op_open_async": ["open a file", "awaiting the result of a `Deno.open` call"],
-    "op_read_dir_async": ["read a directory", "collecting all items in the async iterable returned from a `Deno.readDir` call"],
-    "op_read_link_async": ["read a symlink", "awaiting the result of a `Deno.readLink` call"],
-    "op_realpath_async": ["resolve a path", "awaiting the result of a `Deno.realpath` call"],
-    "op_remove_async": ["remove a file or directory", "awaiting the result of a `Deno.remove` call"],
-    "op_rename_async": ["rename a file or directory", "awaiting the result of a `Deno.rename` call"],
-    "op_run_status": ["get the status of a subprocess", "awaiting the result of a `Deno.Process#status` call"],
-    "op_seek_async": ["seek in a file", "awaiting the result of a `Deno.File#seek` call"],
-    "op_signal_poll": ["get the next signal", "un-registering a OS signal handler"],
-    "op_sleep": ["sleep for a duration", "cancelling a `setTimeout` or `setInterval` call"],
-    "op_stat_async": ["get file metadata", "awaiting the result of a `Deno.stat` call"],
-    "op_symlink_async": ["create a symlink", "awaiting the result of a `Deno.symlink` call"],
-    "op_net_accept_tls": ["accept a TLS stream", "closing a `Deno.TlsListener`"],
-    "op_net_connect_tls": ["connect to a TLS server", "awaiting a `Deno.connectTls` call"],
-    "op_tls_handshake": ["perform a TLS handshake", "awaiting a `Deno.TlsConn#handshake` call"],
-    "op_tls_start": ["start a TLS connection", "awaiting a `Deno.startTls` call"],
-    "op_truncate_async": ["truncate a file", "awaiting the result of a `Deno.truncate` call"],
-    "op_utime_async": ["change file timestamps", "awaiting the result of a `Deno.utime` call"],
-    "op_webgpu_buffer_get_map_async": ["map a WebGPU buffer", "awaiting the result of a `GPUBuffer#mapAsync` call"],
-    "op_webgpu_request_adapter": ["request a WebGPU adapter", "awaiting the result of a `navigator.gpu.requestAdapter` call"],
-    "op_webgpu_request_device": ["request a WebGPU device", "awaiting the result of a `GPUAdapter#requestDevice` call"],
-    "op_worker_recv_message":  ["receive a message from a web worker", "terminating a `Worker`"],
-    "op_ws_close": ["close a WebSocket", "awaiting until the `close` event is emitted on a `WebSocket`, or the `WebSocketStream#closed` promise resolves"],
-    "op_ws_create": ["create a WebSocket", "awaiting until the `open` event is emitted on a `WebSocket`, or the result of a `WebSocketStream#connection` promise"],
-    "op_ws_next_event": ["receive the next message on a WebSocket", "closing a `WebSocket` or `WebSocketStream`"],
-    "op_ws_send": ["send a message on a WebSocket", "closing a `WebSocket` or `WebSocketStream`"],
-  };
 
-  // Wrap test function in additional assertion that makes sure
-  // the test case does not leak async "ops" - ie. number of async
-  // completed ops after the test is the same as number of dispatched
-  // ops. Note that "unref" ops are ignored since in nature that are
-  // optional.
-  function assertOps(fn) {
-    /** @param desc {TestDescription | TestStepDescription} */
-    return async function asyncOpSanitizer(desc) {
-      const pre = core.metrics();
-      const preTraces = new Map(core.opCallTraces);
-      try {
-        await fn(desc);
-      } finally {
-        // Defer until next event loop turn - that way timeouts and intervals
-        // cleared can actually be removed from resource table, otherwise
-        // false positives may occur (https://github.com/denoland/deno/issues/4591)
-        await opSanitizerDelay();
-        await opSanitizerDelay();
-      }
+const core = globalThis.Deno.core;
+const ops = core.ops;
+const internals = globalThis.__bootstrap.internals;
+import { setExitHandler } from "internal:runtime/js/30_os.js";
+import { Console } from "internal:ext/console/02_console.js";
+import { serializePermissions } from "internal:runtime/js/10_permissions.js";
+import { assert } from "internal:ext/web/00_infra.js";
+const primordials = globalThis.__bootstrap.primordials;
+const {
+  ArrayFrom,
+  ArrayPrototypeFilter,
+  ArrayPrototypeJoin,
+  ArrayPrototypeMap,
+  ArrayPrototypePush,
+  ArrayPrototypeShift,
+  ArrayPrototypeSort,
+  BigInt,
+  DateNow,
+  Error,
+  FunctionPrototype,
+  Map,
+  MapPrototypeGet,
+  MapPrototypeHas,
+  MapPrototypeSet,
+  MathCeil,
+  ObjectKeys,
+  ObjectPrototypeHasOwnProperty,
+  ObjectPrototypeIsPrototypeOf,
+  Promise,
+  SafeArrayIterator,
+  Set,
+  SymbolToStringTag,
+  TypeError,
+} = primordials;
+
+const opSanitizerDelayResolveQueue = [];
+
+// Even if every resource is closed by the end of a test, there can be a delay
+// until the pending ops have all finished. This function returns a promise
+// that resolves when it's (probably) fine to run the op sanitizer.
+//
+// This is implemented by adding a macrotask callback that runs after the
+// timer macrotasks, so we can guarantee that a currently running interval
+// will have an associated op. An additional `setTimeout` of 0 is needed
+// before that, though, in order to give time for worker message ops to finish
+// (since timeouts of 0 don't queue tasks in the timer queue immediately).
+function opSanitizerDelay() {
+  return new Promise((resolve) => {
+    setTimeout(() => {
+      ArrayPrototypePush(opSanitizerDelayResolveQueue, resolve);
+    }, 0);
+  });
+}
+
+function handleOpSanitizerDelayMacrotask() {
+  ArrayPrototypeShift(opSanitizerDelayResolveQueue)?.();
+  return opSanitizerDelayResolveQueue.length === 0;
+}
+
+// An async operation to $0 was started in this test, but never completed. This is often caused by not $1.
+// An async operation to $0 was started in this test, but never completed. Async operations should not complete in a test if they were not started in that test.
+// deno-fmt-ignore
+const OP_DETAILS = {
+  "op_blob_read_part": ["read from a Blob or File", "awaiting the result of a Blob or File read"],
+  "op_broadcast_recv": ["receive a message from a BroadcastChannel", "closing the BroadcastChannel"],
+  "op_broadcast_send": ["send a message to a BroadcastChannel", "closing the BroadcastChannel"],
+  "op_chmod_async": ["change the permissions of a file", "awaiting the result of a `Deno.chmod` call"],
+  "op_chown_async": ["change the owner of a file", "awaiting the result of a `Deno.chown` call"],
+  "op_copy_file_async": ["copy a file", "awaiting the result of a `Deno.copyFile` call"],
+  "op_crypto_decrypt": ["decrypt data", "awaiting the result of a `crypto.subtle.decrypt` call"],
+  "op_crypto_derive_bits": ["derive bits from a key", "awaiting the result of a `crypto.subtle.deriveBits` call"],
+  "op_crypto_encrypt": ["encrypt data", "awaiting the result of a `crypto.subtle.encrypt` call"],
+  "op_crypto_generate_key": ["generate a key", "awaiting the result of a `crypto.subtle.generateKey` call"],
+  "op_crypto_sign_key": ["sign data", "awaiting the result of a `crypto.subtle.sign` call"],
+  "op_crypto_subtle_digest": ["digest data", "awaiting the result of a `crypto.subtle.digest` call"],
+  "op_crypto_verify_key": ["verify data", "awaiting the result of a `crypto.subtle.verify` call"],
+  "op_net_recv_udp": ["receive a datagram message via UDP", "awaiting the result of `Deno.DatagramConn#receive` call, or not breaking out of a for await loop looping over a `Deno.DatagramConn`"],
+  "op_net_recv_unixpacket": ["receive a datagram message via Unixpacket", "awaiting the result of `Deno.DatagramConn#receive` call, or not breaking out of a for await loop looping over a `Deno.DatagramConn`"],
+  "op_net_send_udp": ["send a datagram message via UDP", "awaiting the result of `Deno.DatagramConn#send` call"],
+  "op_net_send_unixpacket": ["send a datagram message via Unixpacket", "awaiting the result of `Deno.DatagramConn#send` call"],
+  "op_dns_resolve": ["resolve a DNS name", "awaiting the result of a `Deno.resolveDns` call"],
+  "op_fdatasync_async": ["flush pending data operations for a file to disk", "awaiting the result of a `Deno.fdatasync` call"],
+  "op_fetch_send": ["send a HTTP request", "awaiting the result of a `fetch` call"],
+  "op_ffi_call_nonblocking": ["do a non blocking ffi call", "awaiting the returned promise"] ,
+  "op_ffi_call_ptr_nonblocking": ["do a non blocking ffi call",  "awaiting the returned promise"],
+  "op_flock_async": ["lock a file", "awaiting the result of a `Deno.flock` call"],
+  "op_fs_events_poll": ["get the next file system event", "breaking out of a for await loop looping over `Deno.FsEvents`"],
+  "op_fstat_async": ["get file metadata", "awaiting the result of a `Deno.File#fstat` call"],
+  "op_fsync_async": ["flush pending data operations for a file to disk", "awaiting the result of a `Deno.fsync` call"],
+  "op_ftruncate_async": ["truncate a file", "awaiting the result of a `Deno.ftruncate` call"],
+  "op_funlock_async": ["unlock a file", "awaiting the result of a `Deno.funlock` call"],
+  "op_futime_async": ["change file timestamps", "awaiting the result of a `Deno.futime` call"],
+  "op_http_accept": ["accept a HTTP request", "closing a `Deno.HttpConn`"],
+  "op_http_shutdown": ["shutdown a HTTP connection", "awaiting `Deno.HttpEvent#respondWith`"],
+  "op_http_upgrade_websocket": ["upgrade a HTTP connection to a WebSocket", "awaiting `Deno.HttpEvent#respondWith`"],
+  "op_http_write_headers": ["write HTTP response headers", "awaiting `Deno.HttpEvent#respondWith`"],
+  "op_http_write": ["write HTTP response body", "awaiting `Deno.HttpEvent#respondWith`"],
+  "op_link_async": ["create a hard link", "awaiting the result of a `Deno.link` call"],
+  "op_make_temp_dir_async": ["create a temporary directory", "awaiting the result of a `Deno.makeTempDir` call"],
+  "op_make_temp_file_async": ["create a temporary file", "awaiting the result of a `Deno.makeTempFile` call"],
+  "op_message_port_recv_message": ["receive a message from a MessagePort", "awaiting the result of not closing a `MessagePort`"],
+  "op_mkdir_async": ["create a directory", "awaiting the result of a `Deno.mkdir` call"],
+  "op_net_accept_tcp": ["accept a TCP stream", "closing a `Deno.Listener`"],
+  "op_net_accept_unix": ["accept a Unix stream", "closing a `Deno.Listener`"],
+  "op_net_connect_tcp": ["connect to a TCP server", "awaiting a `Deno.connect` call"],
+  "op_net_connect_unix": ["connect to a Unix server", "awaiting a `Deno.connect` call"],
+  "op_open_async": ["open a file", "awaiting the result of a `Deno.open` call"],
+  "op_read_dir_async": ["read a directory", "collecting all items in the async iterable returned from a `Deno.readDir` call"],
+  "op_read_link_async": ["read a symlink", "awaiting the result of a `Deno.readLink` call"],
+  "op_realpath_async": ["resolve a path", "awaiting the result of a `Deno.realpath` call"],
+  "op_remove_async": ["remove a file or directory", "awaiting the result of a `Deno.remove` call"],
+  "op_rename_async": ["rename a file or directory", "awaiting the result of a `Deno.rename` call"],
+  "op_run_status": ["get the status of a subprocess", "awaiting the result of a `Deno.Process#status` call"],
+  "op_seek_async": ["seek in a file", "awaiting the result of a `Deno.File#seek` call"],
+  "op_signal_poll": ["get the next signal", "un-registering a OS signal handler"],
+  "op_sleep": ["sleep for a duration", "cancelling a `setTimeout` or `setInterval` call"],
+  "op_stat_async": ["get file metadata", "awaiting the result of a `Deno.stat` call"],
+  "op_symlink_async": ["create a symlink", "awaiting the result of a `Deno.symlink` call"],
+  "op_net_accept_tls": ["accept a TLS stream", "closing a `Deno.TlsListener`"],
+  "op_net_connect_tls": ["connect to a TLS server", "awaiting a `Deno.connectTls` call"],
+  "op_tls_handshake": ["perform a TLS handshake", "awaiting a `Deno.TlsConn#handshake` call"],
+  "op_tls_start": ["start a TLS connection", "awaiting a `Deno.startTls` call"],
+  "op_truncate_async": ["truncate a file", "awaiting the result of a `Deno.truncate` call"],
+  "op_utime_async": ["change file timestamps", "awaiting the result of a `Deno.utime` call"],
+  "op_webgpu_buffer_get_map_async": ["map a WebGPU buffer", "awaiting the result of a `GPUBuffer#mapAsync` call"],
+  "op_webgpu_request_adapter": ["request a WebGPU adapter", "awaiting the result of a `navigator.gpu.requestAdapter` call"],
+  "op_webgpu_request_device": ["request a WebGPU device", "awaiting the result of a `GPUAdapter#requestDevice` call"],
+  "op_worker_recv_message":  ["receive a message from a web worker", "terminating a `Worker`"],
+  "op_ws_close": ["close a WebSocket", "awaiting until the `close` event is emitted on a `WebSocket`, or the `WebSocketStream#closed` promise resolves"],
+  "op_ws_create": ["create a WebSocket", "awaiting until the `open` event is emitted on a `WebSocket`, or the result of a `WebSocketStream#connection` promise"],
+  "op_ws_next_event": ["receive the next message on a WebSocket", "closing a `WebSocket` or `WebSocketStream`"],
+  "op_ws_send": ["send a message on a WebSocket", "closing a `WebSocket` or `WebSocketStream`"],
+};
+
+// Wrap test function in additional assertion that makes sure
+// the test case does not leak async "ops" - ie. number of async
+// completed ops after the test is the same as number of dispatched
+// ops. Note that "unref" ops are ignored since in nature that are
+// optional.
+function assertOps(fn) {
+  /** @param desc {TestDescription | TestStepDescription} */
+  return async function asyncOpSanitizer(desc) {
+    const pre = core.metrics();
+    const preTraces = new Map(core.opCallTraces);
+    try {
+      await fn(desc);
+    } finally {
+      // Defer until next event loop turn - that way timeouts and intervals
+      // cleared can actually be removed from resource table, otherwise
+      // false positives may occur (https://github.com/denoland/deno/issues/4591)
+      await opSanitizerDelay();
+      await opSanitizerDelay();
+    }
 
-      if (shouldSkipSanitizers(desc)) return;
+    if (shouldSkipSanitizers(desc)) return;
 
-      const post = core.metrics();
-      const postTraces = new Map(core.opCallTraces);
+    const post = core.metrics();
+    const postTraces = new Map(core.opCallTraces);
 
-      // We're checking diff because one might spawn HTTP server in the background
-      // that will be a pending async op before test starts.
-      const dispatchedDiff = post.opsDispatchedAsync - pre.opsDispatchedAsync;
-      const completedDiff = post.opsCompletedAsync - pre.opsCompletedAsync;
+    // We're checking diff because one might spawn HTTP server in the background
+    // that will be a pending async op before test starts.
+    const dispatchedDiff = post.opsDispatchedAsync - pre.opsDispatchedAsync;
+    const completedDiff = post.opsCompletedAsync - pre.opsCompletedAsync;
 
-      if (dispatchedDiff === completedDiff) return;
+    if (dispatchedDiff === completedDiff) return;
 
-      const details = [];
-      for (const key in post.ops) {
-        if (!ObjectPrototypeHasOwnProperty(post.ops, key)) {
-          continue;
+    const details = [];
+    for (const key in post.ops) {
+      if (!ObjectPrototypeHasOwnProperty(post.ops, key)) {
+        continue;
+      }
+      const preOp = pre.ops[key] ??
+        { opsDispatchedAsync: 0, opsCompletedAsync: 0 };
+      const postOp = post.ops[key];
+      const dispatchedDiff = postOp.opsDispatchedAsync -
+        preOp.opsDispatchedAsync;
+      const completedDiff = postOp.opsCompletedAsync -
+        preOp.opsCompletedAsync;
+
+      if (dispatchedDiff > completedDiff) {
+        const [name, hint] = OP_DETAILS[key] || [key, null];
+        const count = dispatchedDiff - completedDiff;
+        let message = `${count} async operation${
+          count === 1 ? "" : "s"
+        } to ${name} ${
+          count === 1 ? "was" : "were"
+        } started in this test, but never completed.`;
+        if (hint) {
+          message += ` This is often caused by not ${hint}.`;
         }
-        const preOp = pre.ops[key] ??
-          { opsDispatchedAsync: 0, opsCompletedAsync: 0 };
-        const postOp = post.ops[key];
-        const dispatchedDiff = postOp.opsDispatchedAsync -
-          preOp.opsDispatchedAsync;
-        const completedDiff = postOp.opsCompletedAsync -
-          preOp.opsCompletedAsync;
-
-        if (dispatchedDiff > completedDiff) {
-          const [name, hint] = OP_DETAILS[key] || [key, null];
-          const count = dispatchedDiff - completedDiff;
-          let message = `${count} async operation${
-            count === 1 ? "" : "s"
-          } to ${name} ${
+        const traces = [];
+        for (const [id, { opName, stack }] of postTraces) {
+          if (opName !== key) continue;
+          if (MapPrototypeHas(preTraces, id)) continue;
+          ArrayPrototypePush(traces, stack);
+        }
+        if (traces.length === 1) {
+          message += " The operation was started here:\n";
+          message += traces[0];
+        } else if (traces.length > 1) {
+          message += " The operations were started here:\n";
+          message += ArrayPrototypeJoin(traces, "\n\n");
+        }
+        ArrayPrototypePush(details, message);
+      } else if (dispatchedDiff < completedDiff) {
+        const [name, hint] = OP_DETAILS[key] || [key, null];
+        const count = completedDiff - dispatchedDiff;
+        ArrayPrototypePush(
+          details,
+          `${count} async operation${count === 1 ? "" : "s"} to ${name} ${
             count === 1 ? "was" : "were"
-          } started in this test, but never completed.`;
-          if (hint) {
-            message += ` This is often caused by not ${hint}.`;
-          }
-          const traces = [];
-          for (const [id, { opName, stack }] of postTraces) {
-            if (opName !== key) continue;
-            if (MapPrototypeHas(preTraces, id)) continue;
-            ArrayPrototypePush(traces, stack);
-          }
-          if (traces.length === 1) {
-            message += " The operation was started here:\n";
-            message += traces[0];
-          } else if (traces.length > 1) {
-            message += " The operations were started here:\n";
-            message += ArrayPrototypeJoin(traces, "\n\n");
-          }
-          ArrayPrototypePush(details, message);
-        } else if (dispatchedDiff < completedDiff) {
-          const [name, hint] = OP_DETAILS[key] || [key, null];
-          const count = completedDiff - dispatchedDiff;
-          ArrayPrototypePush(
-            details,
-            `${count} async operation${count === 1 ? "" : "s"} to ${name} ${
-              count === 1 ? "was" : "were"
-            } started before this test, but ${
-              count === 1 ? "was" : "were"
-            } completed during the test. Async operations should not complete in a test if they were not started in that test.
+          } started before this test, but ${
+            count === 1 ? "was" : "were"
+          } completed during the test. Async operations should not complete in a test if they were not started in that test.
             ${hint ? `This is often caused by not ${hint}.` : ""}`,
-          );
-        }
+        );
       }
+    }
 
-      let msg = `Test case is leaking async ops.
+    let msg = `Test case is leaking async ops.
 
  - ${ArrayPrototypeJoin(details, "\n - ")}`;
 
-      if (!core.isOpCallTracingEnabled()) {
-        msg +=
-          `\n\nTo get more details where ops were leaked, run again with --trace-ops flag.`;
-      } else {
-        msg += "\n";
-      }
-
-      throw assert(false, msg);
-    };
-  }
-
-  function prettyResourceNames(name) {
-    switch (name) {
-      case "fsFile":
-        return ["A file", "opened", "closed"];
-      case "fetchRequest":
-        return ["A fetch request", "started", "finished"];
-      case "fetchRequestBody":
-        return ["A fetch request body", "created", "closed"];
-      case "fetchResponseBody":
-        return ["A fetch response body", "created", "consumed"];
-      case "httpClient":
-        return ["An HTTP client", "created", "closed"];
-      case "dynamicLibrary":
-        return ["A dynamic library", "loaded", "unloaded"];
-      case "httpConn":
-        return ["An inbound HTTP connection", "accepted", "closed"];
-      case "httpStream":
-        return ["An inbound HTTP request", "accepted", "closed"];
-      case "tcpStream":
-        return ["A TCP connection", "opened/accepted", "closed"];
-      case "unixStream":
-        return ["A Unix connection", "opened/accepted", "closed"];
-      case "tlsStream":
-        return ["A TLS connection", "opened/accepted", "closed"];
-      case "tlsListener":
-        return ["A TLS listener", "opened", "closed"];
-      case "unixListener":
-        return ["A Unix listener", "opened", "closed"];
-      case "unixDatagram":
-        return ["A Unix datagram", "opened", "closed"];
-      case "tcpListener":
-        return ["A TCP listener", "opened", "closed"];
-      case "udpSocket":
-        return ["A UDP socket", "opened", "closed"];
-      case "timer":
-        return ["A timer", "started", "fired/cleared"];
-      case "textDecoder":
-        return ["A text decoder", "created", "finished"];
-      case "messagePort":
-        return ["A message port", "created", "closed"];
-      case "webSocketStream":
-        return ["A WebSocket", "opened", "closed"];
-      case "fsEvents":
-        return ["A file system watcher", "created", "closed"];
-      case "childStdin":
-        return ["A child process stdin", "opened", "closed"];
-      case "childStdout":
-        return ["A child process stdout", "opened", "closed"];
-      case "childStderr":
-        return ["A child process stderr", "opened", "closed"];
-      case "child":
-        return ["A child process", "started", "closed"];
-      case "signal":
-        return ["A signal listener", "created", "fired/cleared"];
-      case "stdin":
-        return ["The stdin pipe", "opened", "closed"];
-      case "stdout":
-        return ["The stdout pipe", "opened", "closed"];
-      case "stderr":
-        return ["The stderr pipe", "opened", "closed"];
-      case "compression":
-        return ["A CompressionStream", "created", "closed"];
-      default:
-        return [`A "${name}" resource`, "created", "cleaned up"];
+    if (!core.isOpCallTracingEnabled()) {
+      msg +=
+        `\n\nTo get more details where ops were leaked, run again with --trace-ops flag.`;
+    } else {
+      msg += "\n";
     }
-  }
 
-  function resourceCloseHint(name) {
-    switch (name) {
-      case "fsFile":
-        return "Close the file handle by calling `file.close()`.";
-      case "fetchRequest":
-        return "Await the promise returned from `fetch()` or abort the fetch with an abort signal.";
-      case "fetchRequestBody":
-        return "Terminate the request body `ReadableStream` by closing or erroring it.";
-      case "fetchResponseBody":
-        return "Consume or close the response body `ReadableStream`, e.g `await resp.text()` or `await resp.body.cancel()`.";
-      case "httpClient":
-        return "Close the HTTP client by calling `httpClient.close()`.";
-      case "dynamicLibrary":
-        return "Unload the dynamic library by calling `dynamicLibrary.close()`.";
-      case "httpConn":
-        return "Close the inbound HTTP connection by calling `httpConn.close()`.";
-      case "httpStream":
-        return "Close the inbound HTTP request by responding with `e.respondWith()` or closing the HTTP connection.";
-      case "tcpStream":
-        return "Close the TCP connection by calling `tcpConn.close()`.";
-      case "unixStream":
-        return "Close the Unix socket connection by calling `unixConn.close()`.";
-      case "tlsStream":
-        return "Close the TLS connection by calling `tlsConn.close()`.";
-      case "tlsListener":
-        return "Close the TLS listener by calling `tlsListener.close()`.";
-      case "unixListener":
-        return "Close the Unix socket listener by calling `unixListener.close()`.";
-      case "unixDatagram":
-        return "Close the Unix datagram socket by calling `unixDatagram.close()`.";
-      case "tcpListener":
-        return "Close the TCP listener by calling `tcpListener.close()`.";
-      case "udpSocket":
-        return "Close the UDP socket by calling `udpSocket.close()`.";
-      case "timer":
-        return "Clear the timer by calling `clearInterval` or `clearTimeout`.";
-      case "textDecoder":
-        return "Close the text decoder by calling `textDecoder.decode('')` or `await textDecoderStream.readable.cancel()`.";
-      case "messagePort":
-        return "Close the message port by calling `messagePort.close()`.";
-      case "webSocketStream":
-        return "Close the WebSocket by calling `webSocket.close()`.";
-      case "fsEvents":
-        return "Close the file system watcher by calling `watcher.close()`.";
-      case "childStdin":
-        return "Close the child process stdin by calling `proc.stdin.close()`.";
-      case "childStdout":
-        return "Close the child process stdout by calling `proc.stdout.close()` or `await child.stdout.cancel()`.";
-      case "childStderr":
-        return "Close the child process stderr by calling `proc.stderr.close()` or `await child.stderr.cancel()`.";
-      case "child":
-        return "Close the child process by calling `proc.kill()` or `proc.close()`.";
-      case "signal":
-        return "Clear the signal listener by calling `Deno.removeSignalListener`.";
-      case "stdin":
-        return "Close the stdin pipe by calling `Deno.stdin.close()`.";
-      case "stdout":
-        return "Close the stdout pipe by calling `Deno.stdout.close()`.";
-      case "stderr":
-        return "Close the stderr pipe by calling `Deno.stderr.close()`.";
-      case "compression":
-        return "Close the compression stream by calling `await stream.writable.close()`.";
-      default:
-        return "Close the resource before the end of the test.";
-    }
+    throw assert(false, msg);
+  };
+}
+
+function prettyResourceNames(name) {
+  switch (name) {
+    case "fsFile":
+      return ["A file", "opened", "closed"];
+    case "fetchRequest":
+      return ["A fetch request", "started", "finished"];
+    case "fetchRequestBody":
+      return ["A fetch request body", "created", "closed"];
+    case "fetchResponseBody":
+      return ["A fetch response body", "created", "consumed"];
+    case "httpClient":
+      return ["An HTTP client", "created", "closed"];
+    case "dynamicLibrary":
+      return ["A dynamic library", "loaded", "unloaded"];
+    case "httpConn":
+      return ["An inbound HTTP connection", "accepted", "closed"];
+    case "httpStream":
+      return ["An inbound HTTP request", "accepted", "closed"];
+    case "tcpStream":
+      return ["A TCP connection", "opened/accepted", "closed"];
+    case "unixStream":
+      return ["A Unix connection", "opened/accepted", "closed"];
+    case "tlsStream":
+      return ["A TLS connection", "opened/accepted", "closed"];
+    case "tlsListener":
+      return ["A TLS listener", "opened", "closed"];
+    case "unixListener":
+      return ["A Unix listener", "opened", "closed"];
+    case "unixDatagram":
+      return ["A Unix datagram", "opened", "closed"];
+    case "tcpListener":
+      return ["A TCP listener", "opened", "closed"];
+    case "udpSocket":
+      return ["A UDP socket", "opened", "closed"];
+    case "timer":
+      return ["A timer", "started", "fired/cleared"];
+    case "textDecoder":
+      return ["A text decoder", "created", "finished"];
+    case "messagePort":
+      return ["A message port", "created", "closed"];
+    case "webSocketStream":
+      return ["A WebSocket", "opened", "closed"];
+    case "fsEvents":
+      return ["A file system watcher", "created", "closed"];
+    case "childStdin":
+      return ["A child process stdin", "opened", "closed"];
+    case "childStdout":
+      return ["A child process stdout", "opened", "closed"];
+    case "childStderr":
+      return ["A child process stderr", "opened", "closed"];
+    case "child":
+      return ["A child process", "started", "closed"];
+    case "signal":
+      return ["A signal listener", "created", "fired/cleared"];
+    case "stdin":
+      return ["The stdin pipe", "opened", "closed"];
+    case "stdout":
+      return ["The stdout pipe", "opened", "closed"];
+    case "stderr":
+      return ["The stderr pipe", "opened", "closed"];
+    case "compression":
+      return ["A CompressionStream", "created", "closed"];
+    default:
+      return [`A "${name}" resource`, "created", "cleaned up"];
+  }
+}
+
+function resourceCloseHint(name) {
+  switch (name) {
+    case "fsFile":
+      return "Close the file handle by calling `file.close()`.";
+    case "fetchRequest":
+      return "Await the promise returned from `fetch()` or abort the fetch with an abort signal.";
+    case "fetchRequestBody":
+      return "Terminate the request body `ReadableStream` by closing or erroring it.";
+    case "fetchResponseBody":
+      return "Consume or close the response body `ReadableStream`, e.g `await resp.text()` or `await resp.body.cancel()`.";
+    case "httpClient":
+      return "Close the HTTP client by calling `httpClient.close()`.";
+    case "dynamicLibrary":
+      return "Unload the dynamic library by calling `dynamicLibrary.close()`.";
+    case "httpConn":
+      return "Close the inbound HTTP connection by calling `httpConn.close()`.";
+    case "httpStream":
+      return "Close the inbound HTTP request by responding with `e.respondWith()` or closing the HTTP connection.";
+    case "tcpStream":
+      return "Close the TCP connection by calling `tcpConn.close()`.";
+    case "unixStream":
+      return "Close the Unix socket connection by calling `unixConn.close()`.";
+    case "tlsStream":
+      return "Close the TLS connection by calling `tlsConn.close()`.";
+    case "tlsListener":
+      return "Close the TLS listener by calling `tlsListener.close()`.";
+    case "unixListener":
+      return "Close the Unix socket listener by calling `unixListener.close()`.";
+    case "unixDatagram":
+      return "Close the Unix datagram socket by calling `unixDatagram.close()`.";
+    case "tcpListener":
+      return "Close the TCP listener by calling `tcpListener.close()`.";
+    case "udpSocket":
+      return "Close the UDP socket by calling `udpSocket.close()`.";
+    case "timer":
+      return "Clear the timer by calling `clearInterval` or `clearTimeout`.";
+    case "textDecoder":
+      return "Close the text decoder by calling `textDecoder.decode('')` or `await textDecoderStream.readable.cancel()`.";
+    case "messagePort":
+      return "Close the message port by calling `messagePort.close()`.";
+    case "webSocketStream":
+      return "Close the WebSocket by calling `webSocket.close()`.";
+    case "fsEvents":
+      return "Close the file system watcher by calling `watcher.close()`.";
+    case "childStdin":
+      return "Close the child process stdin by calling `proc.stdin.close()`.";
+    case "childStdout":
+      return "Close the child process stdout by calling `proc.stdout.close()` or `await child.stdout.cancel()`.";
+    case "childStderr":
+      return "Close the child process stderr by calling `proc.stderr.close()` or `await child.stderr.cancel()`.";
+    case "child":
+      return "Close the child process by calling `proc.kill()` or `proc.close()`.";
+    case "signal":
+      return "Clear the signal listener by calling `Deno.removeSignalListener`.";
+    case "stdin":
+      return "Close the stdin pipe by calling `Deno.stdin.close()`.";
+    case "stdout":
+      return "Close the stdout pipe by calling `Deno.stdout.close()`.";
+    case "stderr":
+      return "Close the stderr pipe by calling `Deno.stderr.close()`.";
+    case "compression":
+      return "Close the compression stream by calling `await stream.writable.close()`.";
+    default:
+      return "Close the resource before the end of the test.";
   }
+}
 
-  // Wrap test function in additional assertion that makes sure
-  // the test case does not "leak" resources - ie. resource table after
-  // the test has exactly the same contents as before the test.
-  function assertResources(fn) {
-    /** @param desc {TestDescription | TestStepDescription} */
-    return async function resourceSanitizer(desc) {
-      const pre = core.resources();
-      await fn(desc);
+// Wrap test function in additional assertion that makes sure
+// the test case does not "leak" resources - ie. resource table after
+// the test has exactly the same contents as before the test.
+function assertResources(fn) {
+  /** @param desc {TestDescription | TestStepDescription} */
+  return async function resourceSanitizer(desc) {
+    const pre = core.resources();
+    await fn(desc);
 
-      if (shouldSkipSanitizers(desc)) {
-        return;
-      }
+    if (shouldSkipSanitizers(desc)) {
+      return;
+    }
 
-      const post = core.resources();
-
-      const allResources = new Set([
-        ...new SafeArrayIterator(ObjectKeys(pre)),
-        ...new SafeArrayIterator(ObjectKeys(post)),
-      ]);
-
-      const details = [];
-      for (const resource of allResources) {
-        const preResource = pre[resource];
-        const postResource = post[resource];
-        if (preResource === postResource) continue;
-
-        if (preResource === undefined) {
-          const [name, action1, action2] = prettyResourceNames(postResource);
-          const hint = resourceCloseHint(postResource);
-          const detail =
-            `${name} (rid ${resource}) was ${action1} during the test, but not ${action2} during the test. ${hint}`;
-          ArrayPrototypePush(details, detail);
-        } else {
-          const [name, action1, action2] = prettyResourceNames(preResource);
-          const detail =
-            `${name} (rid ${resource}) was ${action1} before the test started, but was ${action2} during the test. Do not close resources in a test that were not created during that test.`;
-          ArrayPrototypePush(details, detail);
-        }
+    const post = core.resources();
+
+    const allResources = new Set([
+      ...new SafeArrayIterator(ObjectKeys(pre)),
+      ...new SafeArrayIterator(ObjectKeys(post)),
+    ]);
+
+    const details = [];
+    for (const resource of allResources) {
+      const preResource = pre[resource];
+      const postResource = post[resource];
+      if (preResource === postResource) continue;
+
+      if (preResource === undefined) {
+        const [name, action1, action2] = prettyResourceNames(postResource);
+        const hint = resourceCloseHint(postResource);
+        const detail =
+          `${name} (rid ${resource}) was ${action1} during the test, but not ${action2} during the test. ${hint}`;
+        ArrayPrototypePush(details, detail);
+      } else {
+        const [name, action1, action2] = prettyResourceNames(preResource);
+        const detail =
+          `${name} (rid ${resource}) was ${action1} before the test started, but was ${action2} during the test. Do not close resources in a test that were not created during that test.`;
+        ArrayPrototypePush(details, detail);
       }
+    }
 
-      const message = `Test case is leaking ${details.length} resource${
-        details.length === 1 ? "" : "s"
-      }:
+    const message = `Test case is leaking ${details.length} resource${
+      details.length === 1 ? "" : "s"
+    }:
 
  - ${details.join("\n - ")}
 `;
-      assert(details.length === 0, message);
-    };
-  }
+    assert(details.length === 0, message);
+  };
+}
+
+// Wrap test function in additional assertion that makes sure
+// that the test case does not accidentally exit prematurely.
+function assertExit(fn, isTest) {
+  return async function exitSanitizer(...params) {
+    setExitHandler((exitCode) => {
+      assert(
+        false,
+        `${
+          isTest ? "Test case" : "Bench"
+        } attempted to exit with exit code: ${exitCode}`,
+      );
+    });
 
-  // Wrap test function in additional assertion that makes sure
-  // that the test case does not accidentally exit prematurely.
-  function assertExit(fn, isTest) {
-    return async function exitSanitizer(...params) {
-      setExitHandler((exitCode) => {
-        assert(
-          false,
-          `${
-            isTest ? "Test case" : "Bench"
-          } attempted to exit with exit code: ${exitCode}`,
-        );
-      });
+    try {
+      await fn(...new SafeArrayIterator(params));
+    } catch (err) {
+      throw err;
+    } finally {
+      setExitHandler(null);
+    }
+  };
+}
 
-      try {
-        await fn(...new SafeArrayIterator(params));
-      } catch (err) {
-        throw err;
-      } finally {
-        setExitHandler(null);
-      }
-    };
-  }
+function assertTestStepScopes(fn) {
+  /** @param desc {TestDescription | TestStepDescription} */
+  return async function testStepSanitizer(desc) {
+    preValidation();
+    // only report waiting after pre-validation
+    if (canStreamReporting(desc) && "parent" in desc) {
+      stepReportWait(desc);
+    }
+    await fn(MapPrototypeGet(testStates, desc.id).context);
+    testStepPostValidation(desc);
+
+    function preValidation() {
+      const runningStepDescs = getRunningStepDescs();
+      const runningStepDescsWithSanitizers = ArrayPrototypeFilter(
+        runningStepDescs,
+        (d) => usesSanitizer(d),
+      );
 
-  function assertTestStepScopes(fn) {
-    /** @param desc {TestDescription | TestStepDescription} */
-    return async function testStepSanitizer(desc) {
-      preValidation();
-      // only report waiting after pre-validation
-      if (canStreamReporting(desc) && "parent" in desc) {
-        stepReportWait(desc);
-      }
-      await fn(MapPrototypeGet(testStates, desc.id).context);
-      testStepPostValidation(desc);
-
-      function preValidation() {
-        const runningStepDescs = getRunningStepDescs();
-        const runningStepDescsWithSanitizers = ArrayPrototypeFilter(
-          runningStepDescs,
-          (d) => usesSanitizer(d),
+      if (runningStepDescsWithSanitizers.length > 0) {
+        throw new Error(
+          "Cannot start test step while another test step with sanitizers is running.\n" +
+            runningStepDescsWithSanitizers
+              .map((d) => ` * ${getFullName(d)}`)
+              .join("\n"),
         );
-
-        if (runningStepDescsWithSanitizers.length > 0) {
-          throw new Error(
-            "Cannot start test step while another test step with sanitizers is running.\n" +
-              runningStepDescsWithSanitizers
-                .map((d) => ` * ${getFullName(d)}`)
-                .join("\n"),
-          );
-        }
-
-        if (usesSanitizer(desc) && runningStepDescs.length > 0) {
-          throw new Error(
-            "Cannot start test step with sanitizers while another test step is running.\n" +
-              runningStepDescs.map((d) => ` * ${getFullName(d)}`).join("\n"),
-          );
-        }
-
-        function getRunningStepDescs() {
-          const results = [];
-          let childDesc = desc;
-          while (childDesc.parent != null) {
-            const state = MapPrototypeGet(testStates, childDesc.parent.id);
-            for (const siblingDesc of state.children) {
-              if (siblingDesc.id == childDesc.id) {
-                continue;
-              }
-              const siblingState = MapPrototypeGet(testStates, siblingDesc.id);
-              if (!siblingState.finalized) {
-                ArrayPrototypePush(results, siblingDesc);
-              }
-            }
-            childDesc = childDesc.parent;
-          }
-          return results;
-        }
       }
-    };
-  }
 
-  function testStepPostValidation(desc) {
-    // check for any running steps
-    for (const childDesc of MapPrototypeGet(testStates, desc.id).children) {
-      if (MapPrototypeGet(testStates, childDesc.id).status == "pending") {
+      if (usesSanitizer(desc) && runningStepDescs.length > 0) {
         throw new Error(
-          "There were still test steps running after the current scope finished execution. Ensure all steps are awaited (ex. `await t.step(...)`).",
+          "Cannot start test step with sanitizers while another test step is running.\n" +
+            runningStepDescs.map((d) => ` * ${getFullName(d)}`).join("\n"),
         );
       }
-    }
 
-    // check if an ancestor already completed
-    let currentDesc = desc.parent;
-    while (currentDesc != null) {
-      if (MapPrototypeGet(testStates, currentDesc.id).finalized) {
-        throw new Error(
-          "Parent scope completed before test step finished execution. Ensure all steps are awaited (ex. `await t.step(...)`).",
-        );
+      function getRunningStepDescs() {
+        const results = [];
+        let childDesc = desc;
+        while (childDesc.parent != null) {
+          const state = MapPrototypeGet(testStates, childDesc.parent.id);
+          for (const siblingDesc of state.children) {
+            if (siblingDesc.id == childDesc.id) {
+              continue;
+            }
+            const siblingState = MapPrototypeGet(testStates, siblingDesc.id);
+            if (!siblingState.finalized) {
+              ArrayPrototypePush(results, siblingDesc);
+            }
+          }
+          childDesc = childDesc.parent;
+        }
+        return results;
       }
-      currentDesc = currentDesc.parent;
+    }
+  };
+}
+
+function testStepPostValidation(desc) {
+  // check for any running steps
+  for (const childDesc of MapPrototypeGet(testStates, desc.id).children) {
+    if (MapPrototypeGet(testStates, childDesc.id).status == "pending") {
+      throw new Error(
+        "There were still test steps running after the current scope finished execution. Ensure all steps are awaited (ex. `await t.step(...)`).",
+      );
     }
   }
 
-  function pledgePermissions(permissions) {
-    return ops.op_pledge_test_permissions(
-      serializePermissions(permissions),
-    );
+  // check if an ancestor already completed
+  let currentDesc = desc.parent;
+  while (currentDesc != null) {
+    if (MapPrototypeGet(testStates, currentDesc.id).finalized) {
+      throw new Error(
+        "Parent scope completed before test step finished execution. Ensure all steps are awaited (ex. `await t.step(...)`).",
+      );
+    }
+    currentDesc = currentDesc.parent;
   }
+}
 
-  function restorePermissions(token) {
-    ops.op_restore_test_permissions(token);
-  }
+function pledgePermissions(permissions) {
+  return ops.op_pledge_test_permissions(
+    serializePermissions(permissions),
+  );
+}
 
-  function withPermissions(fn, permissions) {
-    return async function applyPermissions(...params) {
-      const token = pledgePermissions(permissions);
+function restorePermissions(token) {
+  ops.op_restore_test_permissions(token);
+}
 
-      try {
-        await fn(...new SafeArrayIterator(params));
-      } finally {
-        restorePermissions(token);
-      }
-    };
-  }
+function withPermissions(fn, permissions) {
+  return async function applyPermissions(...params) {
+    const token = pledgePermissions(permissions);
 
-  /**
-   * @typedef {{
-   *   id: number,
-   *   name: string,
-   *   fn: TestFunction
-   *   origin: string,
-   *   location: TestLocation,
-   *   filteredOut: boolean,
-   *   ignore: boolean,
-   *   only: boolean.
-   *   sanitizeOps: boolean,
-   *   sanitizeResources: boolean,
-   *   sanitizeExit: boolean,
-   *   permissions: PermissionOptions,
-   * }} TestDescription
-   *
-   * @typedef {{
-   *   id: number,
-   *   name: string,
-   *   fn: TestFunction
-   *   origin: string,
-   *   location: TestLocation,
-   *   ignore: boolean,
-   *   level: number,
-   *   parent: TestDescription | TestStepDescription,
-   *   rootId: number,
-   *   rootName: String,
-   *   sanitizeOps: boolean,
-   *   sanitizeResources: boolean,
-   *   sanitizeExit: boolean,
-   * }} TestStepDescription
-   *
-   * @typedef {{
-   *   context: TestContext,
-   *   children: TestStepDescription[],
-   *   finalized: boolean,
-   * }} TestState
-   *
-   * @typedef {{
-   *   context: TestContext,
-   *   children: TestStepDescription[],
-   *   finalized: boolean,
-   *   status: "pending" | "ok" | ""failed" | ignored",
-   *   error: unknown,
-   *   elapsed: number | null,
-   *   reportedWait: boolean,
-   *   reportedResult: boolean,
-   * }} TestStepState
-   *
-   * @typedef {{
-   *   id: number,
-   *   name: string,
-   *   fn: BenchFunction
-   *   origin: string,
-   *   filteredOut: boolean,
-   *   ignore: boolean,
-   *   only: boolean.
-   *   sanitizeExit: boolean,
-   *   permissions: PermissionOptions,
-   * }} BenchDescription
-   */
-
-  /** @type {TestDescription[]} */
-  const testDescs = [];
-  /** @type {Map<number, TestState | TestStepState>} */
-  const testStates = new Map();
-  /** @type {BenchDescription[]} */
-  const benchDescs = [];
-  let isTestSubcommand = false;
-  let isBenchSubcommand = false;
-
-  // Main test function provided by Deno.
-  function test(
-    nameOrFnOrOptions,
-    optionsOrFn,
-    maybeFn,
-  ) {
-    if (!isTestSubcommand) {
-      return;
+    try {
+      await fn(...new SafeArrayIterator(params));
+    } finally {
+      restorePermissions(token);
     }
+  };
+}
+
+/**
+ * @typedef {{
+ *   id: number,
+ *   name: string,
+ *   fn: TestFunction
+ *   origin: string,
+ *   location: TestLocation,
+ *   filteredOut: boolean,
+ *   ignore: boolean,
+ *   only: boolean.
+ *   sanitizeOps: boolean,
+ *   sanitizeResources: boolean,
+ *   sanitizeExit: boolean,
+ *   permissions: PermissionOptions,
+ * }} TestDescription
+ *
+ * @typedef {{
+ *   id: number,
+ *   name: string,
+ *   fn: TestFunction
+ *   origin: string,
+ *   location: TestLocation,
+ *   ignore: boolean,
+ *   level: number,
+ *   parent: TestDescription | TestStepDescription,
+ *   rootId: number,
+ *   rootName: String,
+ *   sanitizeOps: boolean,
+ *   sanitizeResources: boolean,
+ *   sanitizeExit: boolean,
+ * }} TestStepDescription
+ *
+ * @typedef {{
+ *   context: TestContext,
+ *   children: TestStepDescription[],
+ *   finalized: boolean,
+ * }} TestState
+ *
+ * @typedef {{
+ *   context: TestContext,
+ *   children: TestStepDescription[],
+ *   finalized: boolean,
+ *   status: "pending" | "ok" | ""failed" | ignored",
+ *   error: unknown,
+ *   elapsed: number | null,
+ *   reportedWait: boolean,
+ *   reportedResult: boolean,
+ * }} TestStepState
+ *
+ * @typedef {{
+ *   id: number,
+ *   name: string,
+ *   fn: BenchFunction
+ *   origin: string,
+ *   filteredOut: boolean,
+ *   ignore: boolean,
+ *   only: boolean.
+ *   sanitizeExit: boolean,
+ *   permissions: PermissionOptions,
+ * }} BenchDescription
+ */
+
+/** @type {TestDescription[]} */
+const testDescs = [];
+/** @type {Map<number, TestState | TestStepState>} */
+const testStates = new Map();
+/** @type {BenchDescription[]} */
+const benchDescs = [];
+let isTestSubcommand = false;
+let isBenchSubcommand = false;
+
+// Main test function provided by Deno.
+function test(
+  nameOrFnOrOptions,
+  optionsOrFn,
+  maybeFn,
+) {
+  if (!isTestSubcommand) {
+    return;
+  }
 
-    let testDesc;
-    const defaults = {
-      ignore: false,
-      only: false,
-      sanitizeOps: true,
-      sanitizeResources: true,
-      sanitizeExit: true,
-      permissions: null,
-    };
+  let testDesc;
+  const defaults = {
+    ignore: false,
+    only: false,
+    sanitizeOps: true,
+    sanitizeResources: true,
+    sanitizeExit: true,
+    permissions: null,
+  };
 
-    if (typeof nameOrFnOrOptions === "string") {
-      if (!nameOrFnOrOptions) {
-        throw new TypeError("The test name can't be empty");
-      }
-      if (typeof optionsOrFn === "function") {
-        testDesc = { fn: optionsOrFn, name: nameOrFnOrOptions, ...defaults };
-      } else {
-        if (!maybeFn || typeof maybeFn !== "function") {
-          throw new TypeError("Missing test function");
-        }
-        if (optionsOrFn.fn != undefined) {
-          throw new TypeError(
-            "Unexpected 'fn' field in options, test function is already provided as the third argument.",
-          );
-        }
-        if (optionsOrFn.name != undefined) {
-          throw new TypeError(
-            "Unexpected 'name' field in options, test name is already provided as the first argument.",
-          );
-        }
-        testDesc = {
-          ...defaults,
-          ...optionsOrFn,
-          fn: maybeFn,
-          name: nameOrFnOrOptions,
-        };
-      }
-    } else if (typeof nameOrFnOrOptions === "function") {
-      if (!nameOrFnOrOptions.name) {
-        throw new TypeError("The test function must have a name");
+  if (typeof nameOrFnOrOptions === "string") {
+    if (!nameOrFnOrOptions) {
+      throw new TypeError("The test name can't be empty");
+    }
+    if (typeof optionsOrFn === "function") {
+      testDesc = { fn: optionsOrFn, name: nameOrFnOrOptions, ...defaults };
+    } else {
+      if (!maybeFn || typeof maybeFn !== "function") {
+        throw new TypeError("Missing test function");
       }
-      if (optionsOrFn != undefined) {
-        throw new TypeError("Unexpected second argument to Deno.test()");
+      if (optionsOrFn.fn != undefined) {
+        throw new TypeError(
+          "Unexpected 'fn' field in options, test function is already provided as the third argument.",
+        );
       }
-      if (maybeFn != undefined) {
-        throw new TypeError("Unexpected third argument to Deno.test()");
+      if (optionsOrFn.name != undefined) {
+        throw new TypeError(
+          "Unexpected 'name' field in options, test name is already provided as the first argument.",
+        );
       }
       testDesc = {
         ...defaults,
-        fn: nameOrFnOrOptions,
-        name: nameOrFnOrOptions.name,
+        ...optionsOrFn,
+        fn: maybeFn,
+        name: nameOrFnOrOptions,
       };
-    } else {
-      let fn;
-      let name;
-      if (typeof optionsOrFn === "function") {
-        fn = optionsOrFn;
-        if (nameOrFnOrOptions.fn != undefined) {
-          throw new TypeError(
-            "Unexpected 'fn' field in options, test function is already provided as the second argument.",
-          );
-        }
-        name = nameOrFnOrOptions.name ?? fn.name;
-      } else {
-        if (
-          !nameOrFnOrOptions.fn || typeof nameOrFnOrOptions.fn !== "function"
-        ) {
-          throw new TypeError(
-            "Expected 'fn' field in the first argument to be a test function.",
-          );
-        }
-        fn = nameOrFnOrOptions.fn;
-        name = nameOrFnOrOptions.name ?? fn.name;
+    }
+  } else if (typeof nameOrFnOrOptions === "function") {
+    if (!nameOrFnOrOptions.name) {
+      throw new TypeError("The test function must have a name");
+    }
+    if (optionsOrFn != undefined) {
+      throw new TypeError("Unexpected second argument to Deno.test()");
+    }
+    if (maybeFn != undefined) {
+      throw new TypeError("Unexpected third argument to Deno.test()");
+    }
+    testDesc = {
+      ...defaults,
+      fn: nameOrFnOrOptions,
+      name: nameOrFnOrOptions.name,
+    };
+  } else {
+    let fn;
+    let name;
+    if (typeof optionsOrFn === "function") {
+      fn = optionsOrFn;
+      if (nameOrFnOrOptions.fn != undefined) {
+        throw new TypeError(
+          "Unexpected 'fn' field in options, test function is already provided as the second argument.",
+        );
       }
-      if (!name) {
-        throw new TypeError("The test name can't be empty");
+      name = nameOrFnOrOptions.name ?? fn.name;
+    } else {
+      if (
+        !nameOrFnOrOptions.fn || typeof nameOrFnOrOptions.fn !== "function"
+      ) {
+        throw new TypeError(
+          "Expected 'fn' field in the first argument to be a test function.",
+        );
       }
-      testDesc = { ...defaults, ...nameOrFnOrOptions, fn, name };
+      fn = nameOrFnOrOptions.fn;
+      name = nameOrFnOrOptions.name ?? fn.name;
     }
-
-    // Delete this prop in case the user passed it. It's used to detect steps.
-    delete testDesc.parent;
-    testDesc.fn = wrapTestFnWithSanitizers(testDesc.fn, testDesc);
-    if (testDesc.permissions) {
-      testDesc.fn = withPermissions(
-        testDesc.fn,
-        testDesc.permissions,
-      );
+    if (!name) {
+      throw new TypeError("The test name can't be empty");
     }
-    testDesc.origin = getTestOrigin();
-    const jsError = core.destructureError(new Error());
-    testDesc.location = {
-      fileName: jsError.frames[1].fileName,
-      lineNumber: jsError.frames[1].lineNumber,
-      columnNumber: jsError.frames[1].columnNumber,
-    };
-
-    const { id, filteredOut } = ops.op_register_test(testDesc);
-    testDesc.id = id;
-    testDesc.filteredOut = filteredOut;
+    testDesc = { ...defaults, ...nameOrFnOrOptions, fn, name };
+  }
 
-    ArrayPrototypePush(testDescs, testDesc);
-    MapPrototypeSet(testStates, testDesc.id, {
-      context: createTestContext(testDesc),
-      children: [],
-      finalized: false,
-    });
+  // Delete this prop in case the user passed it. It's used to detect steps.
+  delete testDesc.parent;
+  testDesc.fn = wrapTestFnWithSanitizers(testDesc.fn, testDesc);
+  if (testDesc.permissions) {
+    testDesc.fn = withPermissions(
+      testDesc.fn,
+      testDesc.permissions,
+    );
   }
+  testDesc.origin = getTestOrigin();
+  const jsError = core.destructureError(new Error());
+  testDesc.location = {
+    fileName: jsError.frames[1].fileName,
+    lineNumber: jsError.frames[1].lineNumber,
+    columnNumber: jsError.frames[1].columnNumber,
+  };
 
-  // Main bench function provided by Deno.
-  function bench(
-    nameOrFnOrOptions,
-    optionsOrFn,
-    maybeFn,
-  ) {
-    if (!isBenchSubcommand) {
-      return;
-    }
+  const { id, filteredOut } = ops.op_register_test(testDesc);
+  testDesc.id = id;
+  testDesc.filteredOut = filteredOut;
+
+  ArrayPrototypePush(testDescs, testDesc);
+  MapPrototypeSet(testStates, testDesc.id, {
+    context: createTestContext(testDesc),
+    children: [],
+    finalized: false,
+  });
+}
+
+// Main bench function provided by Deno.
+function bench(
+  nameOrFnOrOptions,
+  optionsOrFn,
+  maybeFn,
+) {
+  if (!isBenchSubcommand) {
+    return;
+  }
 
-    let benchDesc;
-    const defaults = {
-      ignore: false,
-      baseline: false,
-      only: false,
-      sanitizeExit: true,
-      permissions: null,
-    };
+  let benchDesc;
+  const defaults = {
+    ignore: false,
+    baseline: false,
+    only: false,
+    sanitizeExit: true,
+    permissions: null,
+  };
 
-    if (typeof nameOrFnOrOptions === "string") {
-      if (!nameOrFnOrOptions) {
-        throw new TypeError("The bench name can't be empty");
-      }
-      if (typeof optionsOrFn === "function") {
-        benchDesc = { fn: optionsOrFn, name: nameOrFnOrOptions, ...defaults };
-      } else {
-        if (!maybeFn || typeof maybeFn !== "function") {
-          throw new TypeError("Missing bench function");
-        }
-        if (optionsOrFn.fn != undefined) {
-          throw new TypeError(
-            "Unexpected 'fn' field in options, bench function is already provided as the third argument.",
-          );
-        }
-        if (optionsOrFn.name != undefined) {
-          throw new TypeError(
-            "Unexpected 'name' field in options, bench name is already provided as the first argument.",
-          );
-        }
-        benchDesc = {
-          ...defaults,
-          ...optionsOrFn,
-          fn: maybeFn,
-          name: nameOrFnOrOptions,
-        };
-      }
-    } else if (typeof nameOrFnOrOptions === "function") {
-      if (!nameOrFnOrOptions.name) {
-        throw new TypeError("The bench function must have a name");
+  if (typeof nameOrFnOrOptions === "string") {
+    if (!nameOrFnOrOptions) {
+      throw new TypeError("The bench name can't be empty");
+    }
+    if (typeof optionsOrFn === "function") {
+      benchDesc = { fn: optionsOrFn, name: nameOrFnOrOptions, ...defaults };
+    } else {
+      if (!maybeFn || typeof maybeFn !== "function") {
+        throw new TypeError("Missing bench function");
       }
-      if (optionsOrFn != undefined) {
-        throw new TypeError("Unexpected second argument to Deno.bench()");
+      if (optionsOrFn.fn != undefined) {
+        throw new TypeError(
+          "Unexpected 'fn' field in options, bench function is already provided as the third argument.",
+        );
       }
-      if (maybeFn != undefined) {
-        throw new TypeError("Unexpected third argument to Deno.bench()");
+      if (optionsOrFn.name != undefined) {
+        throw new TypeError(
+          "Unexpected 'name' field in options, bench name is already provided as the first argument.",
+        );
       }
       benchDesc = {
         ...defaults,
-        fn: nameOrFnOrOptions,
-        name: nameOrFnOrOptions.name,
+        ...optionsOrFn,
+        fn: maybeFn,
+        name: nameOrFnOrOptions,
       };
-    } else {
-      let fn;
-      let name;
-      if (typeof optionsOrFn === "function") {
-        fn = optionsOrFn;
-        if (nameOrFnOrOptions.fn != undefined) {
-          throw new TypeError(
-            "Unexpected 'fn' field in options, bench function is already provided as the second argument.",
-          );
-        }
-        name = nameOrFnOrOptions.name ?? fn.name;
-      } else {
-        if (
-          !nameOrFnOrOptions.fn || typeof nameOrFnOrOptions.fn !== "function"
-        ) {
-          throw new TypeError(
-            "Expected 'fn' field in the first argument to be a bench function.",
-          );
-        }
-        fn = nameOrFnOrOptions.fn;
-        name = nameOrFnOrOptions.name ?? fn.name;
+    }
+  } else if (typeof nameOrFnOrOptions === "function") {
+    if (!nameOrFnOrOptions.name) {
+      throw new TypeError("The bench function must have a name");
+    }
+    if (optionsOrFn != undefined) {
+      throw new TypeError("Unexpected second argument to Deno.bench()");
+    }
+    if (maybeFn != undefined) {
+      throw new TypeError("Unexpected third argument to Deno.bench()");
+    }
+    benchDesc = {
+      ...defaults,
+      fn: nameOrFnOrOptions,
+      name: nameOrFnOrOptions.name,
+    };
+  } else {
+    let fn;
+    let name;
+    if (typeof optionsOrFn === "function") {
+      fn = optionsOrFn;
+      if (nameOrFnOrOptions.fn != undefined) {
+        throw new TypeError(
+          "Unexpected 'fn' field in options, bench function is already provided as the second argument.",
+        );
       }
-      if (!name) {
-        throw new TypeError("The bench name can't be empty");
+      name = nameOrFnOrOptions.name ?? fn.name;
+    } else {
+      if (
+        !nameOrFnOrOptions.fn || typeof nameOrFnOrOptions.fn !== "function"
+      ) {
+        throw new TypeError(
+          "Expected 'fn' field in the first argument to be a bench function.",
+        );
       }
-      benchDesc = { ...defaults, ...nameOrFnOrOptions, fn, name };
+      fn = nameOrFnOrOptions.fn;
+      name = nameOrFnOrOptions.name ?? fn.name;
     }
+    if (!name) {
+      throw new TypeError("The bench name can't be empty");
+    }
+    benchDesc = { ...defaults, ...nameOrFnOrOptions, fn, name };
+  }
 
-    benchDesc.origin = getBenchOrigin();
-    const AsyncFunction = (async () => {}).constructor;
-    benchDesc.async = AsyncFunction === benchDesc.fn.constructor;
+  benchDesc.origin = getBenchOrigin();
+  const AsyncFunction = (async () => {}).constructor;
+  benchDesc.async = AsyncFunction === benchDesc.fn.constructor;
 
-    const { id, filteredOut } = ops.op_register_bench(benchDesc);
-    benchDesc.id = id;
-    benchDesc.filteredOut = filteredOut;
+  const { id, filteredOut } = ops.op_register_bench(benchDesc);
+  benchDesc.id = id;
+  benchDesc.filteredOut = filteredOut;
 
-    ArrayPrototypePush(benchDescs, benchDesc);
-  }
+  ArrayPrototypePush(benchDescs, benchDesc);
+}
 
-  async function runTest(desc) {
-    if (desc.ignore) {
-      return "ignored";
-    }
+async function runTest(desc) {
+  if (desc.ignore) {
+    return "ignored";
+  }
 
-    try {
-      await desc.fn(desc);
-      const failCount = failedChildStepsCount(desc);
-      return failCount === 0 ? "ok" : {
-        "failed": core.destructureError(
-          new Error(
-            `${failCount} test step${failCount === 1 ? "" : "s"} failed.`,
-          ),
+  try {
+    await desc.fn(desc);
+    const failCount = failedChildStepsCount(desc);
+    return failCount === 0 ? "ok" : {
+      "failed": core.destructureError(
+        new Error(
+          `${failCount} test step${failCount === 1 ? "" : "s"} failed.`,
         ),
-      };
-    } catch (error) {
-      return {
-        "failed": core.destructureError(error),
-      };
-    } finally {
-      const state = MapPrototypeGet(testStates, desc.id);
-      state.finalized = true;
-      // ensure the children report their result
-      for (const childDesc of state.children) {
-        stepReportResult(childDesc);
-      }
+      ),
+    };
+  } catch (error) {
+    return {
+      "failed": core.destructureError(error),
+    };
+  } finally {
+    const state = MapPrototypeGet(testStates, desc.id);
+    state.finalized = true;
+    // ensure the children report their result
+    for (const childDesc of state.children) {
+      stepReportResult(childDesc);
     }
   }
+}
+
+function compareMeasurements(a, b) {
+  if (a > b) return 1;
+  if (a < b) return -1;
+
+  return 0;
+}
+
+function benchStats(n, highPrecision, avg, min, max, all) {
+  return {
+    n,
+    min,
+    max,
+    p75: all[MathCeil(n * (75 / 100)) - 1],
+    p99: all[MathCeil(n * (99 / 100)) - 1],
+    p995: all[MathCeil(n * (99.5 / 100)) - 1],
+    p999: all[MathCeil(n * (99.9 / 100)) - 1],
+    avg: !highPrecision ? (avg / n) : MathCeil(avg / n),
+  };
+}
+
+async function benchMeasure(timeBudget, desc) {
+  const fn = desc.fn;
+  let n = 0;
+  let avg = 0;
+  let wavg = 0;
+  const all = [];
+  let min = Infinity;
+  let max = -Infinity;
+  const lowPrecisionThresholdInNs = 1e4;
+
+  // warmup step
+  let c = 0;
+  let iterations = 20;
+  let budget = 10 * 1e6;
+
+  if (!desc.async) {
+    while (budget > 0 || iterations-- > 0) {
+      const t1 = benchNow();
+
+      fn();
+      const iterationTime = benchNow() - t1;
+
+      c++;
+      wavg += iterationTime;
+      budget -= iterationTime;
+    }
+  } else {
+    while (budget > 0 || iterations-- > 0) {
+      const t1 = benchNow();
 
-  function compareMeasurements(a, b) {
-    if (a > b) return 1;
-    if (a < b) return -1;
+      await fn();
+      const iterationTime = benchNow() - t1;
 
-    return 0;
+      c++;
+      wavg += iterationTime;
+      budget -= iterationTime;
+    }
   }
 
-  function benchStats(n, highPrecision, avg, min, max, all) {
-    return {
-      n,
-      min,
-      max,
-      p75: all[MathCeil(n * (75 / 100)) - 1],
-      p99: all[MathCeil(n * (99 / 100)) - 1],
-      p995: all[MathCeil(n * (99.5 / 100)) - 1],
-      p999: all[MathCeil(n * (99.9 / 100)) - 1],
-      avg: !highPrecision ? (avg / n) : MathCeil(avg / n),
-    };
-  }
+  wavg /= c;
 
-  async function benchMeasure(timeBudget, desc) {
-    const fn = desc.fn;
-    let n = 0;
-    let avg = 0;
-    let wavg = 0;
-    const all = [];
-    let min = Infinity;
-    let max = -Infinity;
-    const lowPrecisionThresholdInNs = 1e4;
-
-    // warmup step
-    let c = 0;
-    let iterations = 20;
-    let budget = 10 * 1e6;
+  // measure step
+  if (wavg > lowPrecisionThresholdInNs) {
+    let iterations = 10;
+    let budget = timeBudget * 1e6;
 
     if (!desc.async) {
       while (budget > 0 || iterations-- > 0) {
@@ -902,9 +933,12 @@
         fn();
         const iterationTime = benchNow() - t1;
 
-        c++;
-        wavg += iterationTime;
+        n++;
+        avg += iterationTime;
         budget -= iterationTime;
+        ArrayPrototypePush(all, iterationTime);
+        if (iterationTime < min) min = iterationTime;
+        if (iterationTime > max) max = iterationTime;
       }
     } else {
       while (budget > 0 || iterations-- > 0) {
@@ -913,520 +947,483 @@
         await fn();
         const iterationTime = benchNow() - t1;
 
-        c++;
-        wavg += iterationTime;
+        n++;
+        avg += iterationTime;
         budget -= iterationTime;
+        ArrayPrototypePush(all, iterationTime);
+        if (iterationTime < min) min = iterationTime;
+        if (iterationTime > max) max = iterationTime;
       }
     }
+  } else {
+    let iterations = 10;
+    let budget = timeBudget * 1e6;
 
-    wavg /= c;
-
-    // measure step
-    if (wavg > lowPrecisionThresholdInNs) {
-      let iterations = 10;
-      let budget = timeBudget * 1e6;
-
-      if (!desc.async) {
-        while (budget > 0 || iterations-- > 0) {
-          const t1 = benchNow();
-
-          fn();
-          const iterationTime = benchNow() - t1;
-
-          n++;
-          avg += iterationTime;
-          budget -= iterationTime;
-          ArrayPrototypePush(all, iterationTime);
-          if (iterationTime < min) min = iterationTime;
-          if (iterationTime > max) max = iterationTime;
-        }
-      } else {
-        while (budget > 0 || iterations-- > 0) {
-          const t1 = benchNow();
-
-          await fn();
-          const iterationTime = benchNow() - t1;
-
-          n++;
-          avg += iterationTime;
-          budget -= iterationTime;
-          ArrayPrototypePush(all, iterationTime);
-          if (iterationTime < min) min = iterationTime;
-          if (iterationTime > max) max = iterationTime;
-        }
+    if (!desc.async) {
+      while (budget > 0 || iterations-- > 0) {
+        const t1 = benchNow();
+        for (let c = 0; c < lowPrecisionThresholdInNs; c++) fn();
+        const iterationTime = (benchNow() - t1) / lowPrecisionThresholdInNs;
+
+        n++;
+        avg += iterationTime;
+        ArrayPrototypePush(all, iterationTime);
+        if (iterationTime < min) min = iterationTime;
+        if (iterationTime > max) max = iterationTime;
+        budget -= iterationTime * lowPrecisionThresholdInNs;
       }
     } else {
-      let iterations = 10;
-      let budget = timeBudget * 1e6;
-
-      if (!desc.async) {
-        while (budget > 0 || iterations-- > 0) {
-          const t1 = benchNow();
-          for (let c = 0; c < lowPrecisionThresholdInNs; c++) fn();
-          const iterationTime = (benchNow() - t1) / lowPrecisionThresholdInNs;
-
-          n++;
-          avg += iterationTime;
-          ArrayPrototypePush(all, iterationTime);
-          if (iterationTime < min) min = iterationTime;
-          if (iterationTime > max) max = iterationTime;
-          budget -= iterationTime * lowPrecisionThresholdInNs;
-        }
-      } else {
-        while (budget > 0 || iterations-- > 0) {
-          const t1 = benchNow();
-          for (let c = 0; c < lowPrecisionThresholdInNs; c++) await fn();
-          const iterationTime = (benchNow() - t1) / lowPrecisionThresholdInNs;
-
-          n++;
-          avg += iterationTime;
-          ArrayPrototypePush(all, iterationTime);
-          if (iterationTime < min) min = iterationTime;
-          if (iterationTime > max) max = iterationTime;
-          budget -= iterationTime * lowPrecisionThresholdInNs;
-        }
+      while (budget > 0 || iterations-- > 0) {
+        const t1 = benchNow();
+        for (let c = 0; c < lowPrecisionThresholdInNs; c++) await fn();
+        const iterationTime = (benchNow() - t1) / lowPrecisionThresholdInNs;
+
+        n++;
+        avg += iterationTime;
+        ArrayPrototypePush(all, iterationTime);
+        if (iterationTime < min) min = iterationTime;
+        if (iterationTime > max) max = iterationTime;
+        budget -= iterationTime * lowPrecisionThresholdInNs;
       }
     }
-
-    all.sort(compareMeasurements);
-    return benchStats(n, wavg > lowPrecisionThresholdInNs, avg, min, max, all);
   }
 
-  async function runBench(desc) {
-    let token = null;
+  all.sort(compareMeasurements);
+  return benchStats(n, wavg > lowPrecisionThresholdInNs, avg, min, max, all);
+}
 
-    try {
-      if (desc.permissions) {
-        token = pledgePermissions(desc.permissions);
-      }
+async function runBench(desc) {
+  let token = null;
 
-      if (desc.sanitizeExit) {
-        setExitHandler((exitCode) => {
-          assert(
-            false,
-            `Bench attempted to exit with exit code: ${exitCode}`,
-          );
-        });
-      }
-
-      const benchTimeInMs = 500;
-      const stats = await benchMeasure(benchTimeInMs, desc);
+  try {
+    if (desc.permissions) {
+      token = pledgePermissions(desc.permissions);
+    }
 
-      return { ok: stats };
-    } catch (error) {
-      return { failed: core.destructureError(error) };
-    } finally {
-      if (bench.sanitizeExit) setExitHandler(null);
-      if (token !== null) restorePermissions(token);
+    if (desc.sanitizeExit) {
+      setExitHandler((exitCode) => {
+        assert(
+          false,
+          `Bench attempted to exit with exit code: ${exitCode}`,
+        );
+      });
     }
-  }
 
-  let origin = null;
+    const benchTimeInMs = 500;
+    const stats = await benchMeasure(benchTimeInMs, desc);
 
-  function getTestOrigin() {
-    if (origin == null) {
-      origin = ops.op_get_test_origin();
-    }
-    return origin;
+    return { ok: stats };
+  } catch (error) {
+    return { failed: core.destructureError(error) };
+  } finally {
+    if (bench.sanitizeExit) setExitHandler(null);
+    if (token !== null) restorePermissions(token);
   }
+}
 
-  function getBenchOrigin() {
-    if (origin == null) {
-      origin = ops.op_get_bench_origin();
-    }
-    return origin;
-  }
+let origin = null;
 
-  function benchNow() {
-    return ops.op_bench_now();
+function getTestOrigin() {
+  if (origin == null) {
+    origin = ops.op_get_test_origin();
   }
+  return origin;
+}
 
-  function enableTest() {
-    isTestSubcommand = true;
+function getBenchOrigin() {
+  if (origin == null) {
+    origin = ops.op_get_bench_origin();
   }
+  return origin;
+}
+
+function benchNow() {
+  return ops.op_bench_now();
+}
+
+function enableTest() {
+  isTestSubcommand = true;
+}
+
+function enableBench() {
+  isBenchSubcommand = true;
+}
+
+async function runTests({
+  shuffle = null,
+} = {}) {
+  core.setMacrotaskCallback(handleOpSanitizerDelayMacrotask);
+
+  const origin = getTestOrigin();
+  const only = ArrayPrototypeFilter(testDescs, (test) => test.only);
+  const filtered = ArrayPrototypeFilter(
+    only.length > 0 ? only : testDescs,
+    (desc) => !desc.filteredOut,
+  );
+
+  ops.op_dispatch_test_event({
+    plan: {
+      origin,
+      total: filtered.length,
+      filteredOut: testDescs.length - filtered.length,
+      usedOnly: only.length > 0,
+    },
+  });
+
+  if (shuffle !== null) {
+    // http://en.wikipedia.org/wiki/Linear_congruential_generator
+    // Use BigInt for everything because the random seed is u64.
+    const nextInt = function (state) {
+      const m = 0x80000000n;
+      const a = 1103515245n;
+      const c = 12345n;
+
+      return function (max) {
+        return state = ((a * state + c) % m) % BigInt(max);
+      };
+    }(BigInt(shuffle));
 
-  function enableBench() {
-    isBenchSubcommand = true;
+    for (let i = filtered.length - 1; i > 0; i--) {
+      const j = nextInt(i);
+      [filtered[i], filtered[j]] = [filtered[j], filtered[i]];
+    }
   }
 
-  async function runTests({
-    shuffle = null,
-  } = {}) {
-    core.setMacrotaskCallback(handleOpSanitizerDelayMacrotask);
-
-    const origin = getTestOrigin();
-    const only = ArrayPrototypeFilter(testDescs, (test) => test.only);
-    const filtered = ArrayPrototypeFilter(
-      only.length > 0 ? only : testDescs,
-      (desc) => !desc.filteredOut,
-    );
-
+  for (const desc of filtered) {
+    if (ops.op_tests_should_stop()) {
+      break;
+    }
+    ops.op_dispatch_test_event({ wait: desc.id });
+    const earlier = DateNow();
+    const result = await runTest(desc);
+    const elapsed = DateNow() - earlier;
     ops.op_dispatch_test_event({
-      plan: {
-        origin,
-        total: filtered.length,
-        filteredOut: testDescs.length - filtered.length,
-        usedOnly: only.length > 0,
-      },
+      result: [desc.id, result, elapsed],
     });
-
-    if (shuffle !== null) {
-      // http://en.wikipedia.org/wiki/Linear_congruential_generator
-      // Use BigInt for everything because the random seed is u64.
-      const nextInt = function (state) {
-        const m = 0x80000000n;
-        const a = 1103515245n;
-        const c = 12345n;
-
-        return function (max) {
-          return state = ((a * state + c) % m) % BigInt(max);
-        };
-      }(BigInt(shuffle));
-
-      for (let i = filtered.length - 1; i > 0; i--) {
-        const j = nextInt(i);
-        [filtered[i], filtered[j]] = [filtered[j], filtered[i]];
-      }
-    }
-
-    for (const desc of filtered) {
-      if (ops.op_tests_should_stop()) {
-        break;
-      }
-      ops.op_dispatch_test_event({ wait: desc.id });
-      const earlier = DateNow();
-      const result = await runTest(desc);
-      const elapsed = DateNow() - earlier;
-      ops.op_dispatch_test_event({
-        result: [desc.id, result, elapsed],
-      });
-    }
   }
+}
 
-  async function runBenchmarks() {
-    core.setMacrotaskCallback(handleOpSanitizerDelayMacrotask);
+async function runBenchmarks() {
+  core.setMacrotaskCallback(handleOpSanitizerDelayMacrotask);
 
-    const origin = getBenchOrigin();
-    const originalConsole = globalThis.console;
+  const origin = getBenchOrigin();
+  const originalConsole = globalThis.console;
 
-    globalThis.console = new Console((s) => {
-      ops.op_dispatch_bench_event({ output: s });
-    });
+  globalThis.console = new Console((s) => {
+    ops.op_dispatch_bench_event({ output: s });
+  });
 
-    const only = ArrayPrototypeFilter(benchDescs, (bench) => bench.only);
-    const filtered = ArrayPrototypeFilter(
-      only.length > 0 ? only : benchDescs,
-      (desc) => !desc.filteredOut && !desc.ignore,
-    );
+  const only = ArrayPrototypeFilter(benchDescs, (bench) => bench.only);
+  const filtered = ArrayPrototypeFilter(
+    only.length > 0 ? only : benchDescs,
+    (desc) => !desc.filteredOut && !desc.ignore,
+  );
 
-    let groups = new Set();
-    // make sure ungrouped benchmarks are placed above grouped
-    groups.add(undefined);
+  let groups = new Set();
+  // make sure ungrouped benchmarks are placed above grouped
+  groups.add(undefined);
 
-    for (const desc of filtered) {
-      desc.group ||= undefined;
-      groups.add(desc.group);
-    }
+  for (const desc of filtered) {
+    desc.group ||= undefined;
+    groups.add(desc.group);
+  }
 
-    groups = ArrayFrom(groups);
-    ArrayPrototypeSort(
-      filtered,
-      (a, b) => groups.indexOf(a.group) - groups.indexOf(b.group),
-    );
+  groups = ArrayFrom(groups);
+  ArrayPrototypeSort(
+    filtered,
+    (a, b) => groups.indexOf(a.group) - groups.indexOf(b.group),
+  );
+
+  ops.op_dispatch_bench_event({
+    plan: {
+      origin,
+      total: filtered.length,
+      usedOnly: only.length > 0,
+      names: ArrayPrototypeMap(filtered, (desc) => desc.name),
+    },
+  });
 
+  for (const desc of filtered) {
+    desc.baseline = !!desc.baseline;
+    ops.op_dispatch_bench_event({ wait: desc.id });
     ops.op_dispatch_bench_event({
-      plan: {
-        origin,
-        total: filtered.length,
-        usedOnly: only.length > 0,
-        names: ArrayPrototypeMap(filtered, (desc) => desc.name),
-      },
+      result: [desc.id, await runBench(desc)],
     });
-
-    for (const desc of filtered) {
-      desc.baseline = !!desc.baseline;
-      ops.op_dispatch_bench_event({ wait: desc.id });
-      ops.op_dispatch_bench_event({
-        result: [desc.id, await runBench(desc)],
-      });
-    }
-
-    globalThis.console = originalConsole;
   }
 
-  function getFullName(desc) {
-    if ("parent" in desc) {
-      return `${desc.parent.name} > ${desc.name}`;
-    }
-    return desc.name;
-  }
+  globalThis.console = originalConsole;
+}
 
-  function usesSanitizer(desc) {
-    return desc.sanitizeResources || desc.sanitizeOps || desc.sanitizeExit;
+function getFullName(desc) {
+  if ("parent" in desc) {
+    return `${desc.parent.name} > ${desc.name}`;
   }
+  return desc.name;
+}
 
-  function canStreamReporting(desc) {
-    let currentDesc = desc;
-    while (currentDesc != null) {
-      if (!usesSanitizer(currentDesc)) {
-        return false;
-      }
-      currentDesc = currentDesc.parent;
-    }
-    for (const childDesc of MapPrototypeGet(testStates, desc.id).children) {
-      const state = MapPrototypeGet(testStates, childDesc.id);
-      if (!usesSanitizer(childDesc) && !state.finalized) {
-        return false;
-      }
-    }
-    return true;
-  }
+function usesSanitizer(desc) {
+  return desc.sanitizeResources || desc.sanitizeOps || desc.sanitizeExit;
+}
 
-  function stepReportWait(desc) {
-    const state = MapPrototypeGet(testStates, desc.id);
-    if (state.reportedWait) {
-      return;
+function canStreamReporting(desc) {
+  let currentDesc = desc;
+  while (currentDesc != null) {
+    if (!usesSanitizer(currentDesc)) {
+      return false;
     }
-    ops.op_dispatch_test_event({ stepWait: desc.id });
-    state.reportedWait = true;
+    currentDesc = currentDesc.parent;
   }
-
-  function stepReportResult(desc) {
-    const state = MapPrototypeGet(testStates, desc.id);
-    if (state.reportedResult) {
-      return;
-    }
-    stepReportWait(desc);
-    for (const childDesc of state.children) {
-      stepReportResult(childDesc);
-    }
-    let result;
-    if (state.status == "pending" || state.status == "failed") {
-      result = {
-        [state.status]: state.error && core.destructureError(state.error),
-      };
-    } else {
-      result = state.status;
+  for (const childDesc of MapPrototypeGet(testStates, desc.id).children) {
+    const state = MapPrototypeGet(testStates, childDesc.id);
+    if (!usesSanitizer(childDesc) && !state.finalized) {
+      return false;
     }
-    ops.op_dispatch_test_event({
-      stepResult: [desc.id, result, state.elapsed],
-    });
-    state.reportedResult = true;
   }
+  return true;
+}
 
-  function failedChildStepsCount(desc) {
-    return ArrayPrototypeFilter(
-      MapPrototypeGet(testStates, desc.id).children,
-      (d) => MapPrototypeGet(testStates, d.id).status === "failed",
-    ).length;
+function stepReportWait(desc) {
+  const state = MapPrototypeGet(testStates, desc.id);
+  if (state.reportedWait) {
+    return;
   }
-
-  /** If a test validation error already occurred then don't bother checking
-   * the sanitizers as that will create extra noise.
-   */
-  function shouldSkipSanitizers(desc) {
-    try {
-      testStepPostValidation(desc);
-      return false;
-    } catch {
-      return true;
-    }
+  ops.op_dispatch_test_event({ stepWait: desc.id });
+  state.reportedWait = true;
+}
+
+function stepReportResult(desc) {
+  const state = MapPrototypeGet(testStates, desc.id);
+  if (state.reportedResult) {
+    return;
+  }
+  stepReportWait(desc);
+  for (const childDesc of state.children) {
+    stepReportResult(childDesc);
+  }
+  let result;
+  if (state.status == "pending" || state.status == "failed") {
+    result = {
+      [state.status]: state.error && core.destructureError(state.error),
+    };
+  } else {
+    result = state.status;
+  }
+  ops.op_dispatch_test_event({
+    stepResult: [desc.id, result, state.elapsed],
+  });
+  state.reportedResult = true;
+}
+
+function failedChildStepsCount(desc) {
+  return ArrayPrototypeFilter(
+    MapPrototypeGet(testStates, desc.id).children,
+    (d) => MapPrototypeGet(testStates, d.id).status === "failed",
+  ).length;
+}
+
+/** If a test validation error already occurred then don't bother checking
+ * the sanitizers as that will create extra noise.
+ */
+function shouldSkipSanitizers(desc) {
+  try {
+    testStepPostValidation(desc);
+    return false;
+  } catch {
+    return true;
+  }
+}
+
+/** @param desc {TestDescription | TestStepDescription} */
+function createTestContext(desc) {
+  let parent;
+  let level;
+  let rootId;
+  let rootName;
+  if ("parent" in desc) {
+    parent = MapPrototypeGet(testStates, desc.parent.id).context;
+    level = desc.level;
+    rootId = desc.rootId;
+    rootName = desc.rootName;
+  } else {
+    parent = undefined;
+    level = 0;
+    rootId = desc.id;
+    rootName = desc.name;
   }
+  return {
+    [SymbolToStringTag]: "TestContext",
+    /**
+     * The current test name.
+     */
+    name: desc.name,
+    /**
+     * Parent test context.
+     */
+    parent,
+    /**
+     * File Uri of the test code.
+     */
+    origin: desc.origin,
+    /**
+     * @param nameOrFnOrOptions {string | TestStepDefinition | ((t: TestContext) => void | Promise<void>)}
+     * @param maybeFn {((t: TestContext) => void | Promise<void>) | undefined}
+     */
+    async step(nameOrFnOrOptions, maybeFn) {
+      if (MapPrototypeGet(testStates, desc.id).finalized) {
+        throw new Error(
+          "Cannot run test step after parent scope has finished execution. " +
+            "Ensure any `.step(...)` calls are executed before their parent scope completes execution.",
+        );
+      }
 
-  /** @param desc {TestDescription | TestStepDescription} */
-  function createTestContext(desc) {
-    let parent;
-    let level;
-    let rootId;
-    let rootName;
-    if ("parent" in desc) {
-      parent = MapPrototypeGet(testStates, desc.parent.id).context;
-      level = desc.level;
-      rootId = desc.rootId;
-      rootName = desc.rootName;
-    } else {
-      parent = undefined;
-      level = 0;
-      rootId = desc.id;
-      rootName = desc.name;
-    }
-    return {
-      [SymbolToStringTag]: "TestContext",
-      /**
-       * The current test name.
-       */
-      name: desc.name,
-      /**
-       * Parent test context.
-       */
-      parent,
-      /**
-       * File Uri of the test code.
-       */
-      origin: desc.origin,
-      /**
-       * @param nameOrFnOrOptions {string | TestStepDefinition | ((t: TestContext) => void | Promise<void>)}
-       * @param maybeFn {((t: TestContext) => void | Promise<void>) | undefined}
-       */
-      async step(nameOrFnOrOptions, maybeFn) {
-        if (MapPrototypeGet(testStates, desc.id).finalized) {
-          throw new Error(
-            "Cannot run test step after parent scope has finished execution. " +
-              "Ensure any `.step(...)` calls are executed before their parent scope completes execution.",
-          );
+      let stepDesc;
+      if (typeof nameOrFnOrOptions === "string") {
+        if (!(ObjectPrototypeIsPrototypeOf(FunctionPrototype, maybeFn))) {
+          throw new TypeError("Expected function for second argument.");
         }
-
-        let stepDesc;
-        if (typeof nameOrFnOrOptions === "string") {
-          if (!(ObjectPrototypeIsPrototypeOf(FunctionPrototype, maybeFn))) {
-            throw new TypeError("Expected function for second argument.");
-          }
-          stepDesc = {
-            name: nameOrFnOrOptions,
-            fn: maybeFn,
-          };
-        } else if (typeof nameOrFnOrOptions === "function") {
-          if (!nameOrFnOrOptions.name) {
-            throw new TypeError("The step function must have a name.");
-          }
-          if (maybeFn != undefined) {
-            throw new TypeError(
-              "Unexpected second argument to TestContext.step()",
-            );
-          }
-          stepDesc = {
-            name: nameOrFnOrOptions.name,
-            fn: nameOrFnOrOptions,
-          };
-        } else if (typeof nameOrFnOrOptions === "object") {
-          stepDesc = nameOrFnOrOptions;
-        } else {
+        stepDesc = {
+          name: nameOrFnOrOptions,
+          fn: maybeFn,
+        };
+      } else if (typeof nameOrFnOrOptions === "function") {
+        if (!nameOrFnOrOptions.name) {
+          throw new TypeError("The step function must have a name.");
+        }
+        if (maybeFn != undefined) {
           throw new TypeError(
-            "Expected a test definition or name and function.",
+            "Unexpected second argument to TestContext.step()",
           );
         }
-        stepDesc.ignore ??= false;
-        stepDesc.sanitizeOps ??= desc.sanitizeOps;
-        stepDesc.sanitizeResources ??= desc.sanitizeResources;
-        stepDesc.sanitizeExit ??= desc.sanitizeExit;
-        stepDesc.origin = getTestOrigin();
-        const jsError = core.destructureError(new Error());
-        stepDesc.location = {
-          fileName: jsError.frames[1].fileName,
-          lineNumber: jsError.frames[1].lineNumber,
-          columnNumber: jsError.frames[1].columnNumber,
-        };
-        stepDesc.level = level + 1;
-        stepDesc.parent = desc;
-        stepDesc.rootId = rootId;
-        stepDesc.rootName = rootName;
-        const { id } = ops.op_register_test_step(stepDesc);
-        stepDesc.id = id;
-        const state = {
-          context: createTestContext(stepDesc),
-          children: [],
-          finalized: false,
-          status: "pending",
-          error: null,
-          elapsed: null,
-          reportedWait: false,
-          reportedResult: false,
+        stepDesc = {
+          name: nameOrFnOrOptions.name,
+          fn: nameOrFnOrOptions,
         };
-        MapPrototypeSet(testStates, stepDesc.id, state);
-        ArrayPrototypePush(
-          MapPrototypeGet(testStates, stepDesc.parent.id).children,
-          stepDesc,
+      } else if (typeof nameOrFnOrOptions === "object") {
+        stepDesc = nameOrFnOrOptions;
+      } else {
+        throw new TypeError(
+          "Expected a test definition or name and function.",
         );
+      }
+      stepDesc.ignore ??= false;
+      stepDesc.sanitizeOps ??= desc.sanitizeOps;
+      stepDesc.sanitizeResources ??= desc.sanitizeResources;
+      stepDesc.sanitizeExit ??= desc.sanitizeExit;
+      stepDesc.origin = getTestOrigin();
+      const jsError = core.destructureError(new Error());
+      stepDesc.location = {
+        fileName: jsError.frames[1].fileName,
+        lineNumber: jsError.frames[1].lineNumber,
+        columnNumber: jsError.frames[1].columnNumber,
+      };
+      stepDesc.level = level + 1;
+      stepDesc.parent = desc;
+      stepDesc.rootId = rootId;
+      stepDesc.rootName = rootName;
+      const { id } = ops.op_register_test_step(stepDesc);
+      stepDesc.id = id;
+      const state = {
+        context: createTestContext(stepDesc),
+        children: [],
+        finalized: false,
+        status: "pending",
+        error: null,
+        elapsed: null,
+        reportedWait: false,
+        reportedResult: false,
+      };
+      MapPrototypeSet(testStates, stepDesc.id, state);
+      ArrayPrototypePush(
+        MapPrototypeGet(testStates, stepDesc.parent.id).children,
+        stepDesc,
+      );
 
-        try {
-          if (stepDesc.ignore) {
-            state.status = "ignored";
-            state.finalized = true;
-            if (canStreamReporting(stepDesc)) {
-              stepReportResult(stepDesc);
-            }
-            return false;
+      try {
+        if (stepDesc.ignore) {
+          state.status = "ignored";
+          state.finalized = true;
+          if (canStreamReporting(stepDesc)) {
+            stepReportResult(stepDesc);
           }
+          return false;
+        }
 
-          const testFn = wrapTestFnWithSanitizers(stepDesc.fn, stepDesc);
-          const start = DateNow();
+        const testFn = wrapTestFnWithSanitizers(stepDesc.fn, stepDesc);
+        const start = DateNow();
 
-          try {
-            await testFn(stepDesc);
+        try {
+          await testFn(stepDesc);
 
-            if (failedChildStepsCount(stepDesc) > 0) {
-              state.status = "failed";
-            } else {
-              state.status = "ok";
-            }
-          } catch (error) {
-            state.error = error;
+          if (failedChildStepsCount(stepDesc) > 0) {
             state.status = "failed";
+          } else {
+            state.status = "ok";
           }
+        } catch (error) {
+          state.error = error;
+          state.status = "failed";
+        }
 
-          state.elapsed = DateNow() - start;
+        state.elapsed = DateNow() - start;
 
-          if (MapPrototypeGet(testStates, stepDesc.parent.id).finalized) {
-            // always point this test out as one that was still running
-            // if the parent step finalized
-            state.status = "pending";
-          }
+        if (MapPrototypeGet(testStates, stepDesc.parent.id).finalized) {
+          // always point this test out as one that was still running
+          // if the parent step finalized
+          state.status = "pending";
+        }
 
-          state.finalized = true;
+        state.finalized = true;
 
-          if (state.reportedWait && canStreamReporting(stepDesc)) {
-            stepReportResult(stepDesc);
-          }
+        if (state.reportedWait && canStreamReporting(stepDesc)) {
+          stepReportResult(stepDesc);
+        }
 
-          return state.status === "ok";
-        } finally {
-          if (canStreamReporting(stepDesc.parent)) {
-            const parentState = MapPrototypeGet(testStates, stepDesc.parent.id);
-            // flush any buffered steps
-            for (const childDesc of parentState.children) {
-              stepReportResult(childDesc);
-            }
+        return state.status === "ok";
+      } finally {
+        if (canStreamReporting(stepDesc.parent)) {
+          const parentState = MapPrototypeGet(testStates, stepDesc.parent.id);
+          // flush any buffered steps
+          for (const childDesc of parentState.children) {
+            stepReportResult(childDesc);
           }
         }
-      },
-    };
-  }
-
-  /**
-   * @template T {Function}
-   * @param testFn {T}
-   * @param opts {{
-   *   sanitizeOps: boolean,
-   *   sanitizeResources: boolean,
-   *   sanitizeExit: boolean,
-   * }}
-   * @returns {T}
-   */
-  function wrapTestFnWithSanitizers(testFn, opts) {
-    testFn = assertTestStepScopes(testFn);
-
-    if (opts.sanitizeOps) {
-      testFn = assertOps(testFn);
-    }
-    if (opts.sanitizeResources) {
-      testFn = assertResources(testFn);
-    }
-    if (opts.sanitizeExit) {
-      testFn = assertExit(testFn, true);
-    }
-    return testFn;
-  }
-
-  window.__bootstrap.internals = {
-    ...window.__bootstrap.internals ?? {},
-    testing: {
-      runTests,
-      runBenchmarks,
-      enableTest,
-      enableBench,
+      }
     },
   };
-
-  window.__bootstrap.denoNs.bench = bench;
-  window.__bootstrap.denoNs.test = test;
-})(this);
+}
+
+/**
+ * @template T {Function}
+ * @param testFn {T}
+ * @param opts {{
+ *   sanitizeOps: boolean,
+ *   sanitizeResources: boolean,
+ *   sanitizeExit: boolean,
+ * }}
+ * @returns {T}
+ */
+function wrapTestFnWithSanitizers(testFn, opts) {
+  testFn = assertTestStepScopes(testFn);
+
+  if (opts.sanitizeOps) {
+    testFn = assertOps(testFn);
+  }
+  if (opts.sanitizeResources) {
+    testFn = assertResources(testFn);
+  }
+  if (opts.sanitizeExit) {
+    testFn = assertExit(testFn, true);
+  }
+  return testFn;
+}
+
+internals.testing = {
+  runTests,
+  runBenchmarks,
+  enableTest,
+  enableBench,
+};
+
+import { denoNs } from "internal:runtime/js/90_deno_ns.js";
+denoNs.bench = bench;
+denoNs.test = test;