Merge branch 'main' into open-flag-on-serve

2025-02-08 07:16:56 -05:00 · 2024-11-27 10:12:48 +02:00 · 2024-11-27 10:12:48 +02:00 · a45fdeb370
commit a45fdeb370
parent c64de5b4f3 927352bd4e
1474 changed files with 6087 additions and 10366 deletions
--- a/Cargo.lock
+++ b/Cargo.lock
@ -128,19 +128,6 @@ version = "0.2.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5c6cb57a04249c6480766f7f7cef5467412af1490f8d1e243141daddada3264f"
 [[package]]
 name = "ammonia"
 version = "4.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1ab99eae5ee58501ab236beb6f20f6ca39be615267b014899c89b2f0bc18a459"
 dependencies = [
 "html5ever",
 "maplit",
 "once_cell",
 "tendril",
 "url",
 ]
 [[package]]
 name = "android_system_properties"
 version = "0.1.5"
@ -1232,8 +1219,8 @@ dependencies = [
 "deno_resolver",
 "deno_runtime",
 "deno_semver",
 "deno_sqlformat",
 "deno_task_shell",
 "deno_telemetry",
 "deno_terminal 0.2.0",
 "deno_tower_lsp",
 "dhat",
@ -1292,6 +1279,7 @@ dependencies = [
 "sha2",
 "shell-escape",
 "spki",
 "sqlformat",
 "strsim",
 "tar",
 "tempfile",
@ -1556,18 +1544,16 @@ dependencies = [
 [[package]]
 name = "deno_doc"
-version = "0.160.0"
+version = "0.161.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "db2baa33e5d1ed235209c2990f5fe9644bac6b9e7bcb789dd92894f907b09ad7"
+checksum = "32d994915f85e873865fc341e592080a487b0a987d06177016b2d93fd62162f8"
 dependencies = [
 "ammonia",
 "anyhow",
 "cfg-if",
 "comrak",
 "deno_ast",
 "deno_graph",
 "deno_path_util",
 "futures",
 "handlebars",
 "html-escape",
 "import_map",
@ -1664,9 +1650,9 @@ dependencies = [
 [[package]]
 name = "deno_graph"
-version = "0.85.0"
+version = "0.86.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9d097305aba3f119781fe82b4d5a85a1ad10c586a388ee4d754e5bf82901cc5c"
+checksum = "4c3f4be49dad28e794ff4eeb2daaf7956c97f8557097ef6f9c3ff1292e0a5c28"
 dependencies = [
 "anyhow",
 "async-trait",
@ -2063,7 +2049,6 @@ dependencies = [
 name = "deno_runtime"
 version = "0.188.0"
 dependencies = [
 "async-trait",
 "color-print",
 "deno_ast",
 "deno_broadcast_channel",
@ -2084,6 +2069,7 @@ dependencies = [
 "deno_node",
 "deno_path_util",
 "deno_permissions",
 "deno_telemetry",
 "deno_terminal 0.2.0",
 "deno_tls",
 "deno_url",
@ -2109,13 +2095,7 @@ dependencies = [
 "notify",
 "ntapi",
 "once_cell",
 "opentelemetry",
 "opentelemetry-http",
 "opentelemetry-otlp",
 "opentelemetry-semantic-conventions",
 "opentelemetry_sdk",
 "percent-encoding",
 "pin-project",
 "regex",
 "rustyline",
 "same-file",
@ -2147,18 +2127,6 @@ dependencies = [
 "url",
 ]
 [[package]]
 name = "deno_sqlformat"
 version = "0.3.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0e196799ec0cc240fac1fb5c5bf813ef92a9602740a059cfcbb20593b2deee52"
 dependencies = [
 "nom 7.1.3",
 "once_cell",
 "regex",
 "unicode_categories",
 ]
 [[package]]
 name = "deno_task_shell"
 version = "0.18.1"
@ -2176,6 +2144,27 @@ dependencies = [
 "tokio-util",
 ]
 [[package]]
 name = "deno_telemetry"
 version = "0.1.0"
 dependencies = [
 "async-trait",
 "deno_core",
 "http-body-util",
 "hyper 1.4.1",
 "hyper-util",
 "log",
 "once_cell",
 "opentelemetry",
 "opentelemetry-http",
 "opentelemetry-otlp",
 "opentelemetry-semantic-conventions",
 "opentelemetry_sdk",
 "pin-project",
 "serde",
 "tokio",
 ]
 [[package]]
 name = "deno_terminal"
 version = "0.1.1"
@ -3261,16 +3250,6 @@ version = "2.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e6d5a32815ae3f33302d95fdcb2ce17862f8c65363dcfd29360480ba1001fc9c"
 [[package]]
 name = "futf"
 version = "0.1.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "df420e2e84819663797d1ec6544b13c5be84629e7bb00dc960d6917db2987843"
 dependencies = [
 "mac",
 "new_debug_unreachable",
 ]
 [[package]]
 name = "futures"
 version = "0.3.30"
@ -3798,20 +3777,6 @@ dependencies = [
 "utf8-width",
 ]
 [[package]]
 name = "html5ever"
 version = "0.27.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c13771afe0e6e846f1e67d038d4cb29998a6779f93c809212e4e9c32efd244d4"
 dependencies = [
 "log",
 "mac",
 "markup5ever",
 "proc-macro2",
 "quote",
 "syn 2.0.87",
 ]
 [[package]]
 name = "http"
 version = "0.2.12"
@ -4659,12 +4624,6 @@ dependencies = [
 "serde_repr",
 ]
 [[package]]
 name = "mac"
 version = "0.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c41e0c4fef86961ac6d6f8a82609f55f31b05e4fce149ac5710e439df7619ba4"
 [[package]]
 name = "malloc_buf"
 version = "0.0.6"
@ -4687,26 +4646,6 @@ dependencies = [
 "tiny_pretty",
 ]
 [[package]]
 name = "maplit"
 version = "1.0.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3e2e65a1a2e43cfcb47a895c4c8b10d1f4a61097f9f254f183aee60cad9c651d"
 [[package]]
 name = "markup5ever"
 version = "0.12.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "16ce3abbeba692c8b8441d036ef91aea6df8da2c6b6e21c7e14d3c18e526be45"
 dependencies = [
 "log",
 "phf",
 "phf_codegen",
 "string_cache",
 "string_cache_codegen",
 "tendril",
 ]
 [[package]]
 name = "markup_fmt"
 version = "0.16.0"
@ -5464,27 +5403,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ade2d8b8f33c7333b51bcf0428d37e217e9f32192ae4772156f65063b8ce03dc"
 dependencies = [
 "phf_macros",
- "phf_shared 0.11.2",
+ "phf_shared",
 ]
 [[package]]
 name = "phf_codegen"
 version = "0.11.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e8d39688d359e6b34654d328e262234662d16cc0f60ec8dcbe5e718709342a5a"
 dependencies = [
 "phf_generator 0.11.2",
 "phf_shared 0.11.2",
 ]
 [[package]]
 name = "phf_generator"
 version = "0.10.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5d5285893bb5eb82e6aaf5d59ee909a06a16737a8970984dd7746ba9283498d6"
 dependencies = [
 "phf_shared 0.10.0",
 "rand",
 ]
 [[package]]
@ -5493,7 +5412,7 @@ version = "0.11.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "48e4cc64c2ad9ebe670cb8fd69dd50ae301650392e81c05f9bfcb2d5bdbc24b0"
 dependencies = [
- "phf_shared 0.11.2",
+ "phf_shared",
 "rand",
 ]
@ -5503,22 +5422,13 @@ version = "0.11.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3444646e286606587e49f3bcf1679b8cef1dc2c5ecc29ddacaffc305180d464b"
 dependencies = [
- "phf_generator 0.11.2",
+ "phf_generator",
- "phf_shared 0.11.2",
+ "phf_shared",
 "proc-macro2",
 "quote",
 "syn 2.0.87",
 ]
 [[package]]
 name = "phf_shared"
 version = "0.10.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b6796ad771acdc0123d2a88dc428b5e38ef24456743ddb1744ed628f9815c096"
 dependencies = [
 "siphasher",
 ]
 [[package]]
 name = "phf_shared"
 version = "0.11.2"
@ -5641,12 +5551,6 @@ version = "0.2.17"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5b40af805b3121feab8a3c29f04d8ad262fa8e0561883e7653e024ae4479e6de"
 [[package]]
 name = "precomputed-hash"
 version = "0.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "925383efa346730478fb4838dbe9137d2a47675ad789c546d150a6e1dd4ab31c"
 [[package]]
 name = "pretty_assertions"
 version = "1.4.0"
@ -6944,6 +6848,18 @@ dependencies = [
 "der",
 ]
 [[package]]
 name = "sqlformat"
 version = "0.3.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "44c38684453189293372e6fffa3bed1015d20488ce4cc09a23de050fd7411e46"
 dependencies = [
 "nom 7.1.3",
 "once_cell",
 "regex",
 "unicode_categories",
 ]
 [[package]]
 name = "stable_deref_trait"
 version = "1.2.0"
@ -6969,32 +6885,6 @@ version = "1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a2eb9349b6444b326872e140eb1cf5e7c522154d69e7a0ffb0fb81c06b37543f"
 [[package]]
 name = "string_cache"
 version = "0.8.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f91138e76242f575eb1d3b38b4f1362f10d3a43f47d182a5b359af488a02293b"
 dependencies = [
 "new_debug_unreachable",
 "once_cell",
 "parking_lot",
 "phf_shared 0.10.0",
 "precomputed-hash",
 "serde",
 ]
 [[package]]
 name = "string_cache_codegen"
 version = "0.5.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6bb30289b722be4ff74a408c3cc27edeaad656e06cb1fe8fa9231fa59c728988"
 dependencies = [
 "phf_generator 0.10.0",
 "phf_shared 0.10.0",
 "proc-macro2",
 "quote",
 ]
 [[package]]
 name = "string_enum"
 version = "0.4.4"
@ -7582,17 +7472,6 @@ dependencies = [
 "windows-sys 0.52.0",
 ]
 [[package]]
 name = "tendril"
 version = "0.4.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d24a120c5fc464a3458240ee02c299ebcb9d67b5249c8848b09d639dca8d7bb0"
 dependencies = [
 "futf",
 "mac",
 "utf-8",
 ]
 [[package]]
 name = "termcolor"
 version = "1.4.1"
--- a/Cargo.toml
+++ b/Cargo.toml
@ -21,6 +21,7 @@ members = [
  "ext/napi/sym",
  "ext/net",
  "ext/node",
  "ext/telemetry",
  "ext/url",
  "ext/web",
  "ext/webgpu",
@ -82,6 +83,7 @@ deno_kv = { version = "0.87.0", path = "./ext/kv" }
 deno_napi = { version = "0.110.0", path = "./ext/napi" }
 deno_net = { version = "0.171.0", path = "./ext/net" }
 deno_node = { version = "0.116.0", path = "./ext/node" }
 deno_telemetry = { version = "0.1.0", path = "./ext/telemetry" }
 deno_tls = { version = "0.166.0", path = "./ext/tls" }
 deno_url = { version = "0.179.0", path = "./ext/url" }
 deno_web = { version = "0.210.0", path = "./ext/web" }
--- a/cli/Cargo.toml
+++ b/cli/Cargo.toml
@ -72,8 +72,8 @@ deno_ast = { workspace = true, features = ["bundler", "cjs", "codegen", "proposa
 deno_cache_dir.workspace = true
 deno_config.workspace = true
 deno_core = { workspace = true, features = ["include_js_files_for_snapshotting"] }
-deno_doc = { version = "0.160.0", features = ["rust", "comrak"] }
+deno_doc = { version = "=0.161.1", features = ["rust", "comrak"] }
-deno_graph = { version = "=0.85.0" }
+deno_graph = { version = "=0.86.2" }
 deno_lint = { version = "=0.68.0", features = ["docs"] }
 deno_lockfile.workspace = true
 deno_npm.workspace = true
@ -83,6 +83,7 @@ deno_resolver.workspace = true
 deno_runtime = { workspace = true, features = ["include_js_files_for_snapshotting"] }
 deno_semver.workspace = true
 deno_task_shell = "=0.18.1"
 deno_telemetry.workspace = true
 deno_terminal.workspace = true
 libsui = "0.5.0"
 node_resolver.workspace = true
@ -151,8 +152,7 @@ serde_repr.workspace = true
 sha2.workspace = true
 shell-escape = "=0.1.5"
 spki = { version = "0.7", features = ["pem"] }
-# NOTE(bartlomieju): using temporary fork for now, revert back to `sqlformat-rs` later
+sqlformat = "=0.3.2"
 sqlformat = { package = "deno_sqlformat", version = "0.3.2" }
 strsim = "0.11.1"
 tar.workspace = true
 tempfile.workspace = true
--- a/cli/args/flags.rs
+++ b/cli/args/flags.rs
@ -36,7 +36,7 @@ use deno_path_util::normalize_path;
 use deno_path_util::url_to_file_path;
 use deno_runtime::deno_permissions::PermissionsOptions;
 use deno_runtime::deno_permissions::SysDescriptor;
-use deno_runtime::ops::otel::OtelConfig;
+use deno_telemetry::OtelConfig;
 use log::debug;
 use log::Level;
 use serde::Deserialize;
@ -2664,7 +2664,7 @@ By default, outdated dependencies are only displayed.
 Display outdated dependencies:
  <p(245)>deno outdated</>
  <p(245)>deno outdated --compatible</>
-  
+
 Update dependencies:
  <p(245)>deno outdated --update</>
  <p(245)>deno outdated --update --latest</>
@ -3049,7 +3049,7 @@ fn task_subcommand() -> Command {
 List all available tasks:
  <p(245)>deno task</>
-  
+
 Evaluate a task from string
  <p(245)>deno task --eval \"echo $(pwd)\"</>"
    ),
--- a/cli/args/mod.rs
+++ b/cli/args/mod.rs
@ -28,8 +28,8 @@ use deno_npm::npm_rc::ResolvedNpmRc;
 use deno_npm::resolution::ValidSerializedNpmResolutionSnapshot;
 use deno_npm::NpmSystemInfo;
 use deno_path_util::normalize_path;
 use deno_runtime::ops::otel::OtelConfig;
 use deno_semver::npm::NpmPackageReqReference;
 use deno_telemetry::OtelConfig;
 use import_map::resolve_import_map_value_from_specifier;
 pub use deno_config::deno_json::BenchConfig;
--- a/cli/cache/module_info.rs
+++ b/cli/cache/module_info.rs
@ -284,6 +284,7 @@ fn serialize_media_type(media_type: MediaType) -> i64 {
 #[cfg(test)]
 mod test {
  use deno_graph::JsDocImportInfo;
  use deno_graph::PositionRange;
  use deno_graph::SpecifierWithRange;
@ -308,18 +309,21 @@ mod test {
    );
    let mut module_info = ModuleInfo::default();
-    module_info.jsdoc_imports.push(SpecifierWithRange {
+    module_info.jsdoc_imports.push(JsDocImportInfo {
-      range: PositionRange {
+      specifier: SpecifierWithRange {
-        start: deno_graph::Position {
+        range: PositionRange {
-          line: 0,
+          start: deno_graph::Position {
-          character: 3,
+            line: 0,
-        },
+            character: 3,
-        end: deno_graph::Position {
+          },
-          line: 1,
+          end: deno_graph::Position {
-          character: 2,
+            line: 1,
            character: 2,
          },
        },
        text: "test".to_string(),
      },
-      text: "test".to_string(),
+      resolution_mode: None,
    });
    cache
      .set_module_info(
--- a/cli/graph_util.rs
+++ b/cli/graph_util.rs
@ -25,7 +25,7 @@ use deno_config::deno_json::JsxImportSourceConfig;
 use deno_config::workspace::JsrPackageConfig;
 use deno_core::anyhow::bail;
 use deno_graph::source::LoaderChecksum;
-use deno_graph::source::ResolutionMode;
+use deno_graph::source::ResolutionKind;
 use deno_graph::FillFromLockfileOptions;
 use deno_graph::JsrLoadError;
 use deno_graph::ModuleLoadError;
@ -44,7 +44,7 @@ use deno_graph::ModuleGraphError;
 use deno_graph::ResolutionError;
 use deno_graph::SpecifierError;
 use deno_path_util::url_to_file_path;
-use deno_resolver::sloppy_imports::SloppyImportsResolutionMode;
+use deno_resolver::sloppy_imports::SloppyImportsResolutionKind;
 use deno_runtime::deno_fs::FileSystem;
 use deno_runtime::deno_node;
 use deno_runtime::deno_permissions::PermissionsContainer;
@ -795,7 +795,7 @@ fn enhanced_sloppy_imports_error_message(
    ModuleError::LoadingErr(specifier, _, ModuleLoadError::Loader(_)) // ex. "Is a directory" error
    | ModuleError::Missing(specifier, _) => {
      let additional_message = CliSloppyImportsResolver::new(SloppyImportsCachedFs::new(fs.clone()))
-        .resolve(specifier, SloppyImportsResolutionMode::Execution)?
+        .resolve(specifier, SloppyImportsResolutionKind::Execution)?
        .as_suggestion_message();
      Some(format!(
        "{} {} or run with --unstable-sloppy-imports",
@ -1100,12 +1100,12 @@ impl<'a> deno_graph::source::FileSystem for DenoGraphFsAdapter<'a> {
  }
 }
-pub fn format_range_with_colors(range: &deno_graph::Range) -> String {
+pub fn format_range_with_colors(referrer: &deno_graph::Range) -> String {
  format!(
    "{}:{}:{}",
-    colors::cyan(range.specifier.as_str()),
+    colors::cyan(referrer.specifier.as_str()),
-    colors::yellow(&(range.start.line + 1).to_string()),
+    colors::yellow(&(referrer.range.start.line + 1).to_string()),
-    colors::yellow(&(range.start.character + 1).to_string())
+    colors::yellow(&(referrer.range.start.character + 1).to_string())
  )
 }
@ -1195,26 +1195,54 @@ impl<'a> deno_graph::source::Resolver for CliGraphResolver<'a> {
    &self,
    raw_specifier: &str,
    referrer_range: &deno_graph::Range,
-    mode: ResolutionMode,
+    resolution_kind: ResolutionKind,
  ) -> Result<ModuleSpecifier, ResolveError> {
    self.resolver.resolve(
      raw_specifier,
-      referrer_range,
+      &referrer_range.specifier,
-      self
+      referrer_range.range.start,
-        .cjs_tracker
+      referrer_range
-        .get_referrer_kind(&referrer_range.specifier),
+        .resolution_mode
-      mode,
+        .map(to_node_resolution_mode)
        .unwrap_or_else(|| {
          self
            .cjs_tracker
            .get_referrer_kind(&referrer_range.specifier)
        }),
      to_node_resolution_kind(resolution_kind),
    )
  }
 }
 pub fn to_node_resolution_kind(
  kind: ResolutionKind,
 ) -> node_resolver::NodeResolutionKind {
  match kind {
    ResolutionKind::Execution => node_resolver::NodeResolutionKind::Execution,
    ResolutionKind::Types => node_resolver::NodeResolutionKind::Types,
  }
 }
 pub fn to_node_resolution_mode(
  mode: deno_graph::source::ResolutionMode,
 ) -> node_resolver::ResolutionMode {
  match mode {
    deno_graph::source::ResolutionMode::Import => {
      node_resolver::ResolutionMode::Import
    }
    deno_graph::source::ResolutionMode::Require => {
      node_resolver::ResolutionMode::Require
    }
  }
 }
 #[cfg(test)]
 mod test {
  use std::sync::Arc;
  use deno_ast::ModuleSpecifier;
  use deno_graph::source::ResolveError;
-  use deno_graph::Position;
+  use deno_graph::PositionRange;
  use deno_graph::Range;
  use deno_graph::ResolutionError;
  use deno_graph::SpecifierError;
@ -1235,8 +1263,8 @@ mod test {
        specifier: input.to_string(),
        range: Range {
          specifier,
-          start: Position::zeroed(),
+          resolution_mode: None,
-          end: Position::zeroed(),
+          range: PositionRange::zeroed(),
        },
      };
      assert_eq!(get_resolution_error_bare_node_specifier(&err), output);
@ -1251,8 +1279,8 @@ mod test {
      let err = ResolutionError::InvalidSpecifier {
        range: Range {
          specifier,
-          start: Position::zeroed(),
+          resolution_mode: None,
-          end: Position::zeroed(),
+          range: PositionRange::zeroed(),
        },
        error: SpecifierError::ImportPrefixMissing {
          specifier: input.to_string(),
--- a/cli/lsp/analysis.rs
+++ b/cli/lsp/analysis.rs
@ -15,7 +15,6 @@ use crate::lsp::search::PackageSearchApi;
 use crate::tools::lint::CliLinter;
 use crate::util::path::relative_specifier;
 use deno_config::workspace::MappedResolution;
 use deno_graph::source::ResolutionMode;
 use deno_lint::diagnostic::LintDiagnosticRange;
 use deno_ast::SourceRange;
@ -39,7 +38,8 @@ use deno_semver::package::PackageReq;
 use deno_semver::package::PackageReqReference;
 use deno_semver::Version;
 use import_map::ImportMap;
-use node_resolver::NodeModuleKind;
+use node_resolver::NodeResolutionKind;
 use node_resolver::ResolutionMode;
 use once_cell::sync::Lazy;
 use regex::Regex;
 use std::borrow::Cow;
@ -467,7 +467,7 @@ impl<'a> TsResponseImportMapper<'a> {
    &self,
    specifier: &str,
    referrer: &ModuleSpecifier,
-    referrer_kind: NodeModuleKind,
+    resolution_mode: ResolutionMode,
  ) -> Option<String> {
    let specifier_stem = specifier.strip_suffix(".js").unwrap_or(specifier);
    let specifiers = std::iter::once(Cow::Borrowed(specifier)).chain(
@ -481,13 +481,10 @@ impl<'a> TsResponseImportMapper<'a> {
        .as_cli_resolver(Some(&self.file_referrer))
        .resolve(
          &specifier,
-          &deno_graph::Range {
+          referrer,
-            specifier: referrer.clone(),
+          deno_graph::Position::zeroed(),
-            start: deno_graph::Position::zeroed(),
+          resolution_mode,
-            end: deno_graph::Position::zeroed(),
+          NodeResolutionKind::Types,
          },
          referrer_kind,
          ResolutionMode::Types,
        )
        .ok()
        .and_then(|s| self.tsc_specifier_map.normalize(s.as_str()).ok())
@ -509,20 +506,17 @@ impl<'a> TsResponseImportMapper<'a> {
    &self,
    specifier_text: &str,
    referrer: &ModuleSpecifier,
-    referrer_kind: NodeModuleKind,
+    resolution_mode: ResolutionMode,
  ) -> bool {
    self
      .resolver
      .as_cli_resolver(Some(&self.file_referrer))
      .resolve(
        specifier_text,
-        &deno_graph::Range {
+        referrer,
-          specifier: referrer.clone(),
+        deno_graph::Position::zeroed(),
-          start: deno_graph::Position::zeroed(),
+        resolution_mode,
-          end: deno_graph::Position::zeroed(),
+        NodeResolutionKind::Types,
        },
        referrer_kind,
        deno_graph::source::ResolutionMode::Types,
      )
      .is_ok()
  }
@ -590,7 +584,7 @@ fn try_reverse_map_package_json_exports(
 /// like an import and rewrite the import specifier to include the extension
 pub fn fix_ts_import_changes(
  referrer: &ModuleSpecifier,
-  referrer_kind: NodeModuleKind,
+  resolution_mode: ResolutionMode,
  changes: &[tsc::FileTextChanges],
  language_server: &language_server::Inner,
 ) -> Result<Vec<tsc::FileTextChanges>, AnyError> {
@ -608,7 +602,7 @@ pub fn fix_ts_import_changes(
            let specifier =
              captures.iter().skip(1).find_map(|s| s).unwrap().as_str();
            if let Some(new_specifier) = import_mapper
-              .check_unresolved_specifier(specifier, referrer, referrer_kind)
+              .check_unresolved_specifier(specifier, referrer, resolution_mode)
            {
              line.replace(specifier, &new_specifier)
            } else {
@ -638,7 +632,7 @@ pub fn fix_ts_import_changes(
 /// resolution by Deno (includes the extension).
 fn fix_ts_import_action<'a>(
  referrer: &ModuleSpecifier,
-  referrer_kind: NodeModuleKind,
+  resolution_mode: ResolutionMode,
  action: &'a tsc::CodeFixAction,
  language_server: &language_server::Inner,
 ) -> Option<Cow<'a, tsc::CodeFixAction>> {
@ -657,9 +651,11 @@ fn fix_ts_import_action<'a>(
    return Some(Cow::Borrowed(action));
  };
  let import_mapper = language_server.get_ts_response_import_mapper(referrer);
-  if let Some(new_specifier) =
+  if let Some(new_specifier) = import_mapper.check_unresolved_specifier(
-    import_mapper.check_unresolved_specifier(specifier, referrer, referrer_kind)
+    specifier,
-  {
+    referrer,
    resolution_mode,
  ) {
    let description = action.description.replace(specifier, &new_specifier);
    let changes = action
      .changes
@ -689,7 +685,8 @@ fn fix_ts_import_action<'a>(
      fix_id: None,
      fix_all_description: None,
    }))
-  } else if !import_mapper.is_valid_import(specifier, referrer, referrer_kind) {
+  } else if !import_mapper.is_valid_import(specifier, referrer, resolution_mode)
  {
    None
  } else {
    Some(Cow::Borrowed(action))
@ -1023,7 +1020,7 @@ impl CodeActionCollection {
  pub fn add_ts_fix_action(
    &mut self,
    specifier: &ModuleSpecifier,
-    specifier_kind: NodeModuleKind,
+    resolution_mode: ResolutionMode,
    action: &tsc::CodeFixAction,
    diagnostic: &lsp::Diagnostic,
    language_server: &language_server::Inner,
@ -1042,7 +1039,7 @@ impl CodeActionCollection {
      ));
    }
    let Some(action) =
-      fix_ts_import_action(specifier, specifier_kind, action, language_server)
+      fix_ts_import_action(specifier, resolution_mode, action, language_server)
    else {
      return Ok(());
    };
@ -1237,12 +1234,12 @@ impl CodeActionCollection {
      let text_info = parsed_source.text_info_lazy();
      let specifier_range = SourceRange::new(
        text_info.loc_to_source_pos(LineAndColumnIndex {
-          line_index: import.specifier_range.start.line,
+          line_index: import.specifier_range.range.start.line,
-          column_index: import.specifier_range.start.character,
+          column_index: import.specifier_range.range.start.character,
        }),
        text_info.loc_to_source_pos(LineAndColumnIndex {
-          line_index: import.specifier_range.end.line,
+          line_index: import.specifier_range.range.end.line,
-          column_index: import.specifier_range.end.character,
+          column_index: import.specifier_range.range.end.character,
        }),
      );
@ -1277,7 +1274,7 @@ impl CodeActionCollection {
        if json!(i.kind) != json!("es") && json!(i.kind) != json!("tsType") {
          return None;
        }
-        if !i.specifier_range.includes(&position) {
+        if !i.specifier_range.includes(position) {
          return None;
        }
@ -1286,7 +1283,7 @@ impl CodeActionCollection {
      let referrer = document.specifier();
      let referrer_kind = language_server
        .is_cjs_resolver
-        .get_doc_module_kind(document);
+        .get_doc_resolution_mode(document);
      let file_referrer = document.file_referrer();
      let config_data = language_server
        .config
--- a/cli/lsp/completions.rs
+++ b/cli/lsp/completions.rs
@ -14,11 +14,10 @@ use super::resolver::LspResolver;
 use super::search::PackageSearchApi;
 use super::tsc;
 use crate::graph_util::to_node_resolution_mode;
 use crate::jsr::JsrFetchResolver;
 use crate::util::path::is_importable_ext;
 use crate::util::path::relative_specifier;
 use deno_graph::source::ResolutionMode;
 use deno_graph::Range;
 use deno_runtime::deno_node::SUPPORTED_BUILTIN_NODE_MODULES;
 use deno_ast::LineAndColumnIndex;
@ -36,7 +35,8 @@ use deno_semver::package::PackageNv;
 use import_map::ImportMap;
 use indexmap::IndexSet;
 use lsp_types::CompletionList;
-use node_resolver::NodeModuleKind;
+use node_resolver::NodeResolutionKind;
 use node_resolver::ResolutionMode;
 use once_cell::sync::Lazy;
 use regex::Regex;
 use tower_lsp::lsp_types as lsp;
@ -113,7 +113,7 @@ async fn check_auto_config_registry(
 /// which we want to ignore when replacing text.
 fn to_narrow_lsp_range(
  text_info: &SourceTextInfo,
-  range: &deno_graph::Range,
+  range: deno_graph::PositionRange,
 ) -> lsp::Range {
  let end_byte_index = text_info
    .loc_to_source_pos(LineAndColumnIndex {
@ -166,21 +166,21 @@ pub async fn get_import_completions(
  maybe_import_map: Option<&ImportMap>,
 ) -> Option<lsp::CompletionResponse> {
  let document = documents.get(specifier)?;
  let specifier_kind = is_cjs_resolver.get_doc_module_kind(&document);
  let file_referrer = document.file_referrer();
-  let (text, _, range) = document.get_maybe_dependency(position)?;
+  let (text, _, graph_range) = document.get_maybe_dependency(position)?;
-  let range = to_narrow_lsp_range(document.text_info(), &range);
+  let resolution_mode = graph_range
    .resolution_mode
    .map(to_node_resolution_mode)
    .unwrap_or_else(|| is_cjs_resolver.get_doc_resolution_mode(&document));
  let range = to_narrow_lsp_range(document.text_info(), graph_range.range);
  let resolved = resolver
    .as_cli_resolver(file_referrer)
    .resolve(
      &text,
-      &Range {
+      specifier,
-        specifier: specifier.clone(),
+      deno_graph::Position::zeroed(),
-        start: deno_graph::Position::zeroed(),
+      resolution_mode,
-        end: deno_graph::Position::zeroed(),
+      NodeResolutionKind::Execution,
      },
      specifier_kind,
      ResolutionMode::Execution,
    )
    .ok();
  if let Some(completion_list) = get_jsr_completions(
@ -206,7 +206,7 @@ pub async fn get_import_completions(
    // completions for import map specifiers
    Some(lsp::CompletionResponse::List(completion_list))
  } else if let Some(completion_list) =
-    get_local_completions(specifier, specifier_kind, &text, &range, resolver)
+    get_local_completions(specifier, resolution_mode, &text, &range, resolver)
  {
    // completions for local relative modules
    Some(lsp::CompletionResponse::List(completion_list))
@ -361,7 +361,7 @@ fn get_import_map_completions(
 /// Return local completions that are relative to the base specifier.
 fn get_local_completions(
  referrer: &ModuleSpecifier,
-  referrer_kind: NodeModuleKind,
+  resolution_mode: ResolutionMode,
  text: &str,
  range: &lsp::Range,
  resolver: &LspResolver,
@ -374,13 +374,10 @@ fn get_local_completions(
    .as_cli_resolver(Some(referrer))
    .resolve(
      parent,
-      &Range {
+      referrer,
-        specifier: referrer.clone(),
+      deno_graph::Position::zeroed(),
-        start: deno_graph::Position::zeroed(),
+      resolution_mode,
-        end: deno_graph::Position::zeroed(),
+      NodeResolutionKind::Execution,
      },
      referrer_kind,
      ResolutionMode::Execution,
    )
    .ok()?;
  let resolved_parent_path = url_to_file_path(&resolved_parent).ok()?;
@ -831,7 +828,6 @@ mod tests {
  use crate::lsp::documents::LanguageId;
  use crate::lsp::search::tests::TestPackageSearchApi;
  use deno_core::resolve_url;
  use deno_graph::Range;
  use pretty_assertions::assert_eq;
  use std::collections::HashMap;
  use test_util::TempDir;
@ -912,7 +908,7 @@ mod tests {
      ModuleSpecifier::from_file_path(file_c).expect("could not create");
    let actual = get_local_completions(
      &specifier,
-      NodeModuleKind::Esm,
+      ResolutionMode::Import,
      "./",
      &lsp::Range {
        start: lsp::Position {
@ -1608,8 +1604,7 @@ mod tests {
    let text_info = SourceTextInfo::from_string(r#""te""#.to_string());
    let range = to_narrow_lsp_range(
      &text_info,
-      &Range {
+      deno_graph::PositionRange {
        specifier: ModuleSpecifier::parse("https://deno.land").unwrap(),
        start: deno_graph::Position {
          line: 0,
          character: 0,
@ -1632,8 +1627,7 @@ mod tests {
    let text_info = SourceTextInfo::from_string(r#""te"#.to_string());
    let range = to_narrow_lsp_range(
      &text_info,
-      &Range {
+      deno_graph::PositionRange {
        specifier: ModuleSpecifier::parse("https://deno.land").unwrap(),
        start: deno_graph::Position {
          line: 0,
          character: 0,
--- a/cli/lsp/diagnostics.rs
+++ b/cli/lsp/diagnostics.rs
@ -45,7 +45,7 @@ use deno_graph::Resolution;
 use deno_graph::ResolutionError;
 use deno_graph::SpecifierError;
 use deno_resolver::sloppy_imports::SloppyImportsResolution;
-use deno_resolver::sloppy_imports::SloppyImportsResolutionMode;
+use deno_resolver::sloppy_imports::SloppyImportsResolutionKind;
 use deno_runtime::deno_fs;
 use deno_runtime::deno_node;
 use deno_runtime::tokio_util::create_basic_runtime;
@ -1266,7 +1266,7 @@ impl DenoDiagnostic {
      Self::NoLocal(specifier) => {
        let maybe_sloppy_resolution = CliSloppyImportsResolver::new(
          SloppyImportsCachedFs::new(Arc::new(deno_fs::RealFs))
-        ).resolve(specifier, SloppyImportsResolutionMode::Execution);
+        ).resolve(specifier, SloppyImportsResolutionKind::Execution);
        let data = maybe_sloppy_resolution.as_ref().map(|res| {
          json!({
            "specifier": specifier,
@ -1531,7 +1531,7 @@ fn diagnose_dependency(
    && !dependency.imports.iter().any(|i| {
      dependency
        .maybe_type
-        .includes(&i.specifier_range.start)
+        .includes(i.specifier_range.range.start)
        .is_some()
    });
--- a/cli/lsp/documents.rs
+++ b/cli/lsp/documents.rs
@ -27,7 +27,6 @@ use deno_core::futures::future::Shared;
 use deno_core::futures::FutureExt;
 use deno_core::parking_lot::Mutex;
 use deno_core::ModuleSpecifier;
 use deno_graph::source::ResolutionMode;
 use deno_graph::Resolution;
 use deno_path_util::url_to_file_path;
 use deno_runtime::deno_node;
@ -36,7 +35,8 @@ use deno_semver::npm::NpmPackageReqReference;
 use deno_semver::package::PackageReq;
 use indexmap::IndexMap;
 use indexmap::IndexSet;
-use node_resolver::NodeModuleKind;
+use node_resolver::NodeResolutionKind;
 use node_resolver::ResolutionMode;
 use std::borrow::Cow;
 use std::collections::BTreeMap;
 use std::collections::HashMap;
@ -442,8 +442,8 @@ impl Document {
        config_data.and_then(|d| d.maybe_jsx_import_source_config());
      let resolver = SingleReferrerGraphResolver {
        valid_referrer: &self.specifier,
-        referrer_kind: is_cjs_resolver
+        module_resolution_mode: is_cjs_resolver
-          .get_lsp_referrer_kind(&self.specifier, self.is_script),
+          .get_lsp_resolution_mode(&self.specifier, self.is_script),
        cli_resolver,
        jsx_import_source_config: jsx_import_source_config.as_ref(),
      };
@ -768,7 +768,7 @@ impl Document {
    };
    self.dependencies().iter().find_map(|(s, dep)| {
      dep
-        .includes(&position)
+        .includes(position)
        .map(|r| (s.clone(), dep.clone(), r.clone()))
    })
  }
@ -809,15 +809,15 @@ fn resolve_media_type(
  MediaType::from_specifier(specifier)
 }
-pub fn to_lsp_range(range: &deno_graph::Range) -> lsp::Range {
+pub fn to_lsp_range(referrer: &deno_graph::Range) -> lsp::Range {
  lsp::Range {
    start: lsp::Position {
-      line: range.start.line as u32,
+      line: referrer.range.start.line as u32,
-      character: range.start.character as u32,
+      character: referrer.range.start.character as u32,
    },
    end: lsp::Position {
-      line: range.end.line as u32,
+      line: referrer.range.end.line as u32,
-      character: range.end.character as u32,
+      character: referrer.range.end.character as u32,
    },
  }
 }
@ -1271,7 +1271,8 @@ impl Documents {
  /// tsc when type checking.
  pub fn resolve(
    &self,
-    raw_specifiers: &[String],
+    // (is_cjs: bool, raw_specifier: String)
    raw_specifiers: &[(bool, String)],
    referrer: &ModuleSpecifier,
    file_referrer: Option<&ModuleSpecifier>,
  ) -> Vec<Option<(ModuleSpecifier, MediaType)>> {
@ -1281,11 +1282,12 @@ impl Documents {
      .and_then(|d| d.file_referrer())
      .or(file_referrer);
    let dependencies = referrer_doc.as_ref().map(|d| d.dependencies());
    let referrer_kind = self
      .is_cjs_resolver
      .get_maybe_doc_module_kind(referrer, referrer_doc.as_deref());
    let mut results = Vec::new();
-    for raw_specifier in raw_specifiers {
+    for (is_cjs, raw_specifier) in raw_specifiers {
      let resolution_mode = match is_cjs {
        true => ResolutionMode::Require,
        false => ResolutionMode::Import,
      };
      if raw_specifier.starts_with("asset:") {
        if let Ok(specifier) = ModuleSpecifier::parse(raw_specifier) {
          let media_type = MediaType::from_specifier(&specifier);
@ -1300,14 +1302,14 @@ impl Documents {
          results.push(self.resolve_dependency(
            specifier,
            referrer,
-            referrer_kind,
+            resolution_mode,
            file_referrer,
          ));
        } else if let Some(specifier) = dep.maybe_code.maybe_specifier() {
          results.push(self.resolve_dependency(
            specifier,
            referrer,
-            referrer_kind,
+            resolution_mode,
            file_referrer,
          ));
        } else {
@ -1316,19 +1318,16 @@ impl Documents {
      } else if let Ok(specifier) =
        self.resolver.as_cli_resolver(file_referrer).resolve(
          raw_specifier,
-          &deno_graph::Range {
+          referrer,
-            specifier: referrer.clone(),
+          deno_graph::Position::zeroed(),
-            start: deno_graph::Position::zeroed(),
+          resolution_mode,
-            end: deno_graph::Position::zeroed(),
+          NodeResolutionKind::Types,
          },
          referrer_kind,
          ResolutionMode::Types,
        )
      {
        results.push(self.resolve_dependency(
          &specifier,
          referrer,
-          referrer_kind,
+          resolution_mode,
          file_referrer,
        ));
      } else {
@ -1477,27 +1476,24 @@ impl Documents {
        let type_specifier = jsx_config.default_types_specifier.as_ref()?;
        let code_specifier = jsx_config.default_specifier.as_ref()?;
        let cli_resolver = self.resolver.as_cli_resolver(Some(scope));
        let range = deno_graph::Range {
          specifier: jsx_config.base_url.clone(),
          start: deno_graph::Position::zeroed(),
          end: deno_graph::Position::zeroed(),
        };
        let type_specifier = cli_resolver
          .resolve(
            type_specifier,
-            &range,
+            &jsx_config.base_url,
            deno_graph::Position::zeroed(),
            // todo(dsherret): this is wrong because it doesn't consider CJS referrers
-            deno_package_json::NodeModuleKind::Esm,
+            ResolutionMode::Import,
-            ResolutionMode::Types,
+            NodeResolutionKind::Types,
          )
          .ok()?;
        let code_specifier = cli_resolver
          .resolve(
            code_specifier,
-            &range,
+            &jsx_config.base_url,
            deno_graph::Position::zeroed(),
            // todo(dsherret): this is wrong because it doesn't consider CJS referrers
-            deno_package_json::NodeModuleKind::Esm,
+            ResolutionMode::Import,
-            ResolutionMode::Execution,
+            NodeResolutionKind::Execution,
          )
          .ok()?;
        dep_info
@ -1542,7 +1538,7 @@ impl Documents {
    &self,
    specifier: &ModuleSpecifier,
    referrer: &ModuleSpecifier,
-    referrer_kind: NodeModuleKind,
+    resolution_mode: ResolutionMode,
    file_referrer: Option<&ModuleSpecifier>,
  ) -> Option<(ModuleSpecifier, MediaType)> {
    if let Some(module_name) = specifier.as_str().strip_prefix("node:") {
@ -1559,7 +1555,7 @@ impl Documents {
      let (s, mt) = self.resolver.npm_to_file_url(
        &npm_ref,
        referrer,
-        referrer_kind,
+        resolution_mode,
        file_referrer,
      )?;
      specifier = s;
@ -1571,7 +1567,7 @@ impl Documents {
      return Some((specifier, media_type));
    };
    if let Some(types) = doc.maybe_types_dependency().maybe_specifier() {
-      let specifier_kind = self.is_cjs_resolver.get_doc_module_kind(&doc);
+      let specifier_kind = self.is_cjs_resolver.get_doc_resolution_mode(&doc);
      self.resolve_dependency(types, &specifier, specifier_kind, file_referrer)
    } else {
      Some((doc.specifier().clone(), doc.media_type()))
@ -1688,7 +1684,7 @@ fn analyze_module(
        config_data.and_then(|d| d.maybe_jsx_import_source_config());
      let resolver = SingleReferrerGraphResolver {
        valid_referrer: &valid_referrer,
-        referrer_kind: is_cjs_resolver.get_lsp_referrer_kind(
+        module_resolution_mode: is_cjs_resolver.get_lsp_resolution_mode(
          &specifier,
          Some(parsed_source.compute_is_script()),
        ),
--- a/cli/lsp/language_server.rs
+++ b/cli/lsp/language_server.rs
@ -22,7 +22,8 @@ use deno_semver::jsr::JsrPackageReqReference;
 use indexmap::Equivalent;
 use indexmap::IndexSet;
 use log::error;
-use node_resolver::NodeModuleKind;
+use node_resolver::NodeResolutionKind;
 use node_resolver::ResolutionMode;
 use serde::Deserialize;
 use serde_json::from_value;
 use std::collections::BTreeMap;
@ -993,13 +994,10 @@ impl Inner {
              let resolver = inner.resolver.as_cli_resolver(Some(&referrer));
              let Ok(specifier) = resolver.resolve(
                &specifier,
-                &deno_graph::Range {
+                &referrer,
-                  specifier: referrer.clone(),
+                deno_graph::Position::zeroed(),
-                  start: deno_graph::Position::zeroed(),
+                ResolutionMode::Import,
-                  end: deno_graph::Position::zeroed(),
+                NodeResolutionKind::Types,
                },
                NodeModuleKind::Esm,
                deno_graph::source::ResolutionMode::Types,
              ) else {
                return;
              };
@ -1640,8 +1638,8 @@ impl Inner {
        .get_ts_diagnostics(&specifier, asset_or_doc.document_lsp_version());
      let specifier_kind = asset_or_doc
        .document()
-        .map(|d| self.is_cjs_resolver.get_doc_module_kind(d))
+        .map(|d| self.is_cjs_resolver.get_doc_resolution_mode(d))
-        .unwrap_or(NodeModuleKind::Esm);
+        .unwrap_or(ResolutionMode::Import);
      let mut includes_no_cache = false;
      for diagnostic in &fixable_diagnostics {
        match diagnostic.source.as_deref() {
@ -1864,8 +1862,8 @@ impl Inner {
          maybe_asset_or_doc
            .as_ref()
            .and_then(|d| d.document())
-            .map(|d| self.is_cjs_resolver.get_doc_module_kind(d))
+            .map(|d| self.is_cjs_resolver.get_doc_resolution_mode(d))
-            .unwrap_or(NodeModuleKind::Esm),
+            .unwrap_or(ResolutionMode::Import),
          &combined_code_actions.changes,
          self,
        )
@ -1921,8 +1919,8 @@ impl Inner {
          &action_data.specifier,
          asset_or_doc
            .document()
-            .map(|d| self.is_cjs_resolver.get_doc_module_kind(d))
+            .map(|d| self.is_cjs_resolver.get_doc_resolution_mode(d))
-            .unwrap_or(NodeModuleKind::Esm),
+            .unwrap_or(ResolutionMode::Import),
          &refactor_edit_info.edits,
          self,
        )
@ -3781,14 +3779,11 @@ impl Inner {
  fn task_definitions(&self) -> LspResult<Vec<TaskDefinition>> {
    let mut result = vec![];
    for config_file in self.config.tree.config_files() {
-      if let Some(tasks) = json!(&config_file.json.tasks).as_object() {
+      if let Some(tasks) = config_file.to_tasks_config().ok().flatten() {
-        for (name, value) in tasks {
+        for (name, def) in tasks {
          let Some(command) = value.as_str() else {
            continue;
          };
          result.push(TaskDefinition {
            name: name.clone(),
-            command: command.to_string(),
+            command: def.command.clone(),
            source_uri: url_to_uri(&config_file.specifier)
              .map_err(|_| LspError::internal_error())?,
          });
--- a/cli/lsp/lsp_custom.rs
+++ b/cli/lsp/lsp_custom.rs
@ -14,8 +14,6 @@ pub const LATEST_DIAGNOSTIC_BATCH_INDEX: &str =
 #[serde(rename_all = "camelCase")]
 pub struct TaskDefinition {
  pub name: String,
  // TODO(nayeemrmn): Rename this to `command` in vscode_deno.
  #[serde(rename = "detail")]
  pub command: String,
  pub source_uri: lsp::Uri,
 }
--- a/cli/lsp/mod.rs
+++ b/cli/lsp/mod.rs
@ -56,9 +56,6 @@ pub async fn start() -> Result<(), AnyError> {
    LanguageServer::performance_request,
  )
  .custom_method(lsp_custom::TASK_REQUEST, LanguageServer::task_definitions)
  // TODO(nayeemrmn): Rename this to `deno/taskDefinitions` in vscode_deno and
  // remove this alias.
  .custom_method("deno/task", LanguageServer::task_definitions)
  .custom_method(testing::TEST_RUN_REQUEST, LanguageServer::test_run_request)
  .custom_method(
    testing::TEST_RUN_CANCEL_REQUEST,
--- a/cli/lsp/resolver.rs
+++ b/cli/lsp/resolver.rs
@ -9,7 +9,6 @@ use deno_config::workspace::PackageJsonDepResolution;
 use deno_config::workspace::WorkspaceResolver;
 use deno_core::parking_lot::Mutex;
 use deno_core::url::Url;
 use deno_graph::source::ResolutionMode;
 use deno_graph::GraphImport;
 use deno_graph::ModuleSpecifier;
 use deno_graph::Range;
@ -30,8 +29,8 @@ use deno_semver::package::PackageReq;
 use indexmap::IndexMap;
 use node_resolver::errors::ClosestPkgJsonError;
 use node_resolver::InNpmPackageChecker;
-use node_resolver::NodeModuleKind;
+use node_resolver::NodeResolutionKind;
-use node_resolver::NodeResolutionMode;
+use node_resolver::ResolutionMode;
 use std::borrow::Cow;
 use std::collections::BTreeMap;
 use std::collections::BTreeSet;
@ -48,6 +47,8 @@ use crate::args::CliLockfile;
 use crate::args::NpmInstallDepsProvider;
 use crate::cache::DenoCacheEnvFsAdapter;
 use crate::factory::Deferred;
 use crate::graph_util::to_node_resolution_kind;
 use crate::graph_util::to_node_resolution_mode;
 use crate::graph_util::CliJsrUrlProvider;
 use crate::http_util::HttpClientProvider;
 use crate::lsp::config::Config;
@ -146,7 +147,7 @@ impl LspScopeResolver {
            .map(|(referrer, imports)| {
              let resolver = SingleReferrerGraphResolver {
                valid_referrer: &referrer,
-                referrer_kind: NodeModuleKind::Esm,
+                module_resolution_mode: ResolutionMode::Import,
                cli_resolver: &cli_resolver,
                jsx_import_source_config: maybe_jsx_import_source_config
                  .as_ref(),
@ -180,16 +181,16 @@ impl LspScopeResolver {
                &req_ref,
                &referrer,
                // todo(dsherret): this is wrong because it doesn't consider CJS referrers
-                NodeModuleKind::Esm,
+                ResolutionMode::Import,
-                NodeResolutionMode::Types,
+                NodeResolutionKind::Types,
              )
              .or_else(|_| {
                npm_pkg_req_resolver.resolve_req_reference(
                  &req_ref,
                  &referrer,
                  // todo(dsherret): this is wrong because it doesn't consider CJS referrers
-                  NodeModuleKind::Esm,
+                  ResolutionMode::Import,
-                  NodeResolutionMode::Execution,
+                  NodeResolutionKind::Execution,
                )
              })
              .ok()?,
@ -424,7 +425,7 @@ impl LspResolver {
    &self,
    req_ref: &NpmPackageReqReference,
    referrer: &ModuleSpecifier,
-    referrer_kind: NodeModuleKind,
+    resolution_mode: ResolutionMode,
    file_referrer: Option<&ModuleSpecifier>,
  ) -> Option<(ModuleSpecifier, MediaType)> {
    let resolver = self.get_scope_resolver(file_referrer);
@ -434,8 +435,8 @@ impl LspResolver {
        .resolve_req_reference(
          req_ref,
          referrer,
-          referrer_kind,
+          resolution_mode,
-          NodeResolutionMode::Types,
+          NodeResolutionKind::Types,
        )
        .ok()?,
    )))
@ -492,7 +493,7 @@ impl LspResolver {
    &self,
    specifier_text: &str,
    referrer: &ModuleSpecifier,
-    referrer_kind: NodeModuleKind,
+    resolution_mode: ResolutionMode,
  ) -> bool {
    let resolver = self.get_scope_resolver(Some(referrer));
    let Some(npm_pkg_req_resolver) = resolver.npm_pkg_req_resolver.as_ref()
@ -503,8 +504,8 @@ impl LspResolver {
      .resolve_if_for_npm_pkg(
        specifier_text,
        referrer,
-        referrer_kind,
+        resolution_mode,
-        NodeResolutionMode::Types,
+        NodeResolutionKind::Types,
      )
      .ok()
      .flatten()
@ -868,34 +869,23 @@ impl LspIsCjsResolver {
    }
  }
-  pub fn get_maybe_doc_module_kind(
+  pub fn get_doc_resolution_mode(&self, document: &Document) -> ResolutionMode {
-    &self,
+    self.get_lsp_resolution_mode(document.specifier(), document.is_script())
    specifier: &ModuleSpecifier,
    maybe_document: Option<&Document>,
  ) -> NodeModuleKind {
    self.get_lsp_referrer_kind(
      specifier,
      maybe_document.and_then(|d| d.is_script()),
    )
  }
-  pub fn get_doc_module_kind(&self, document: &Document) -> NodeModuleKind {
+  pub fn get_lsp_resolution_mode(
    self.get_lsp_referrer_kind(document.specifier(), document.is_script())
  }
  pub fn get_lsp_referrer_kind(
    &self,
    specifier: &ModuleSpecifier,
    is_script: Option<bool>,
-  ) -> NodeModuleKind {
+  ) -> ResolutionMode {
-    self.inner.get_lsp_referrer_kind(specifier, is_script)
+    self.inner.get_lsp_resolution_mode(specifier, is_script)
  }
 }
 #[derive(Debug)]
 pub struct SingleReferrerGraphResolver<'a> {
  pub valid_referrer: &'a ModuleSpecifier,
-  pub referrer_kind: NodeModuleKind,
+  pub module_resolution_mode: ResolutionMode,
  pub cli_resolver: &'a CliResolver,
  pub jsx_import_source_config: Option<&'a JsxImportSourceConfig>,
 }
@ -924,16 +914,20 @@ impl<'a> deno_graph::source::Resolver for SingleReferrerGraphResolver<'a> {
    &self,
    specifier_text: &str,
    referrer_range: &Range,
-    mode: ResolutionMode,
+    resolution_kind: deno_graph::source::ResolutionKind,
  ) -> Result<ModuleSpecifier, deno_graph::source::ResolveError> {
    // this resolver assumes it will only be used with a single referrer
    // with the provided referrer kind
    debug_assert_eq!(referrer_range.specifier, *self.valid_referrer);
    self.cli_resolver.resolve(
      specifier_text,
-      referrer_range,
+      &referrer_range.specifier,
-      self.referrer_kind,
+      referrer_range.range.start,
-      mode,
+      referrer_range
        .resolution_mode
        .map(to_node_resolution_mode)
        .unwrap_or(self.module_resolution_mode),
      to_node_resolution_kind(resolution_kind),
    )
  }
 }
--- a/cli/lsp/tsc.rs
+++ b/cli/lsp/tsc.rs
@ -70,7 +70,7 @@ use indexmap::IndexMap;
 use indexmap::IndexSet;
 use lazy_regex::lazy_regex;
 use log::error;
-use node_resolver::NodeModuleKind;
+use node_resolver::ResolutionMode;
 use once_cell::sync::Lazy;
 use regex::Captures;
 use regex::Regex;
@ -4449,9 +4449,14 @@ fn op_load<'s>(
        version: state.script_version(&specifier),
        is_cjs: doc
          .document()
-          .map(|d| state.state_snapshot.is_cjs_resolver.get_doc_module_kind(d))
+          .map(|d| {
-          .unwrap_or(NodeModuleKind::Esm)
+            state
-          == NodeModuleKind::Cjs,
+              .state_snapshot
              .is_cjs_resolver
              .get_doc_resolution_mode(d)
          })
          .unwrap_or(ResolutionMode::Import)
          == ResolutionMode::Require,
      })
    };
  let serialized = serde_v8::to_v8(scope, maybe_load_response)?;
@ -4479,17 +4484,9 @@ fn op_release(
 fn op_resolve(
  state: &mut OpState,
  #[string] base: String,
-  is_base_cjs: bool,
+  #[serde] specifiers: Vec<(bool, String)>,
  #[serde] specifiers: Vec<String>,
 ) -> Result<Vec<Option<(String, String)>>, AnyError> {
-  op_resolve_inner(
+  op_resolve_inner(state, ResolveArgs { base, specifiers })
    state,
    ResolveArgs {
      base,
      is_base_cjs,
      specifiers,
    },
  )
 }
 struct TscRequestArray {
@ -4695,7 +4692,7 @@ fn op_script_names(state: &mut OpState) -> ScriptNames {
          state
            .state_snapshot
            .is_cjs_resolver
-            .get_doc_module_kind(doc),
+            .get_doc_resolution_mode(doc),
          doc.file_referrer(),
        )?;
        let types_doc = documents.get_or_load(&types, doc.file_referrer())?;
@ -6430,8 +6427,7 @@ mod tests {
      &mut state,
      ResolveArgs {
        base: temp_dir.url().join("a.ts").unwrap().to_string(),
-        is_base_cjs: false,
+        specifiers: vec![(false, "./b.ts".to_string())],
        specifiers: vec!["./b.ts".to_string()],
      },
    )
    .unwrap();
--- a/cli/main.rs
+++ b/cli/main.rs
@ -448,7 +448,7 @@ fn resolve_flags_and_init(
  };
  if let Some(otel_config) = flags.otel_config() {
-    deno_runtime::ops::otel::init(otel_config)?;
+    deno_telemetry::init(otel_config)?;
  }
  util::logger::init(flags.log_level);
--- a/cli/mainrt.rs
+++ b/cli/mainrt.rs
@ -88,7 +88,7 @@ fn main() {
    match standalone {
      Ok(Some(data)) => {
        if let Some(otel_config) = data.metadata.otel_config.clone() {
-          deno_runtime::ops::otel::init(otel_config)?;
+          deno_telemetry::init(otel_config)?;
        }
        util::logger::init(data.metadata.log_level);
        load_env_vars(&data.metadata.env_vars_from_env_file);
--- a/cli/module_loader.rs
+++ b/cli/module_loader.rs
@ -57,9 +57,7 @@ use deno_core::ModuleSourceCode;
 use deno_core::ModuleSpecifier;
 use deno_core::ModuleType;
 use deno_core::RequestedModuleType;
 use deno_core::ResolutionKind;
 use deno_core::SourceCodeCacheInfo;
 use deno_graph::source::ResolutionMode;
 use deno_graph::GraphKind;
 use deno_graph::JsModule;
 use deno_graph::JsonModule;
@ -76,7 +74,8 @@ use deno_runtime::deno_permissions::PermissionsContainer;
 use deno_semver::npm::NpmPackageReqReference;
 use node_resolver::errors::ClosestPkgJsonError;
 use node_resolver::InNpmPackageChecker;
-use node_resolver::NodeResolutionMode;
+use node_resolver::NodeResolutionKind;
 use node_resolver::ResolutionMode;
 pub struct ModuleLoadPreparer {
  options: Arc<CliOptions>,
@ -498,13 +497,11 @@ impl<TGraphContainer: ModuleGraphContainer>
      }
      Resolution::None => Cow::Owned(self.shared.resolver.resolve(
        raw_specifier,
-        &deno_graph::Range {
+        referrer,
-          specifier: referrer.clone(),
+        deno_graph::Position::zeroed(),
-          start: deno_graph::Position::zeroed(),
+        // if we're here, that means it's resolving a dynamic import
-          end: deno_graph::Position::zeroed(),
+        ResolutionMode::Import,
-        },
+        NodeResolutionKind::Execution,
        self.shared.cjs_tracker.get_referrer_kind(referrer),
        ResolutionMode::Execution,
      )?),
    };
@ -517,8 +514,8 @@ impl<TGraphContainer: ModuleGraphContainer>
          .resolve_req_reference(
            &reference,
            referrer,
-            self.shared.cjs_tracker.get_referrer_kind(referrer),
+            ResolutionMode::Import,
-            NodeResolutionMode::Execution,
+            NodeResolutionKind::Execution,
          )
          .map_err(AnyError::from);
      }
@ -539,8 +536,8 @@ impl<TGraphContainer: ModuleGraphContainer>
            &package_folder,
            module.nv_reference.sub_path(),
            Some(referrer),
-            self.shared.cjs_tracker.get_referrer_kind(referrer),
+            ResolutionMode::Import,
-            NodeResolutionMode::Execution,
+            NodeResolutionKind::Execution,
          )
          .with_context(|| {
            format!("Could not resolve '{}'.", module.nv_reference)
@ -806,7 +803,7 @@ impl<TGraphContainer: ModuleGraphContainer> ModuleLoader
    &self,
    specifier: &str,
    referrer: &str,
-    _kind: ResolutionKind,
+    _kind: deno_core::ResolutionKind,
  ) -> Result<ModuleSpecifier, AnyError> {
    fn ensure_not_jsr_non_jsr_remote_import(
      specifier: &ModuleSpecifier,
--- a/cli/npm/managed/resolvers/common/lifecycle_scripts.rs
+++ b/cli/npm/managed/resolvers/common/lifecycle_scripts.rs
@ -182,6 +182,12 @@ impl<'a> LifecycleScripts<'a> {
      );
      let mut env_vars = crate::task_runner::real_env_vars();
      // so the subprocess can detect that it is running as part of a lifecycle script,
      // and avoid trying to set up node_modules again
      env_vars.insert(
        LIFECYCLE_SCRIPTS_RUNNING_ENV_VAR.to_string(),
        "1".to_string(),
      );
      // we want to pass the current state of npm resolution down to the deno subprocess
      // (that may be running as part of the script). we do this with an inherited temp file
      //
@ -303,6 +309,13 @@ impl<'a> LifecycleScripts<'a> {
  }
 }
 const LIFECYCLE_SCRIPTS_RUNNING_ENV_VAR: &str =
  "DENO_INTERNAL_IS_LIFECYCLE_SCRIPT";
 pub fn is_running_lifecycle_script() -> bool {
  std::env::var(LIFECYCLE_SCRIPTS_RUNNING_ENV_VAR).is_ok()
 }
 // take in all (non copy) packages from snapshot,
 // and resolve the set of available binaries to create
 // custom commands available to the task runner
--- a/cli/npm/managed/resolvers/local.rs
+++ b/cli/npm/managed/resolvers/local.rs
@ -298,6 +298,12 @@ async fn sync_resolution_with_fs(
    return Ok(()); // don't create the directory
  }
  // don't set up node_modules (and more importantly try to acquire the file lock)
  // if we're running as part of a lifecycle script
  if super::common::lifecycle_scripts::is_running_lifecycle_script() {
    return Ok(());
  }
  let deno_local_registry_dir = root_node_modules_dir_path.join(".deno");
  let deno_node_modules_dir = deno_local_registry_dir.join("node_modules");
  fs::create_dir_all(&deno_node_modules_dir).with_context(|| {
--- a/cli/resolver.rs
+++ b/cli/resolver.rs
@ -12,7 +12,6 @@ use deno_core::error::AnyError;
 use deno_core::url::Url;
 use deno_core::ModuleSourceCode;
 use deno_core::ModuleSpecifier;
 use deno_graph::source::ResolutionMode;
 use deno_graph::source::ResolveError;
 use deno_graph::source::UnknownBuiltInNodeModuleError;
 use deno_graph::NpmLoadError;
@ -25,8 +24,8 @@ use deno_runtime::deno_fs::FileSystem;
 use deno_runtime::deno_node::is_builtin_node_module;
 use deno_runtime::deno_node::DenoFsNodeResolverEnv;
 use deno_semver::package::PackageReq;
-use node_resolver::NodeModuleKind;
+use node_resolver::NodeResolutionKind;
-use node_resolver::NodeResolutionMode;
+use node_resolver::ResolutionMode;
 use std::borrow::Cow;
 use std::path::Path;
 use std::path::PathBuf;
@ -247,25 +246,14 @@ impl CliResolver {
  pub fn resolve(
    &self,
    raw_specifier: &str,
-    referrer_range: &deno_graph::Range,
+    referrer: &ModuleSpecifier,
-    referrer_kind: NodeModuleKind,
+    referrer_range_start: deno_graph::Position,
-    mode: ResolutionMode,
+    resolution_mode: ResolutionMode,
    resolution_kind: NodeResolutionKind,
  ) -> Result<ModuleSpecifier, ResolveError> {
    fn to_node_mode(mode: ResolutionMode) -> NodeResolutionMode {
      match mode {
        ResolutionMode::Execution => NodeResolutionMode::Execution,
        ResolutionMode::Types => NodeResolutionMode::Types,
      }
    }
    let resolution = self
      .deno_resolver
-      .resolve(
+      .resolve(raw_specifier, referrer, resolution_mode, resolution_kind)
        raw_specifier,
        &referrer_range.specifier,
        referrer_kind,
        to_node_mode(mode),
      )
      .map_err(|err| match err.into_kind() {
        deno_resolver::DenoResolveErrorKind::MappedResolution(
          mapped_resolution_error,
@ -291,10 +279,11 @@ impl CliResolver {
        } => {
          if self.warned_pkgs.insert(reference.req().clone()) {
            log::warn!(
-              "{} {}\n    at {}",
+              "{} {}\n    at {}:{}",
              colors::yellow("Warning"),
              diagnostic,
-              referrer_range
+              referrer,
              referrer_range_start,
            );
          }
        }
@ -335,13 +324,10 @@ impl<'a> deno_graph::source::NpmResolver for WorkerCliNpmGraphResolver<'a> {
    module_name: &str,
    range: &deno_graph::Range,
  ) {
-    let deno_graph::Range {
+    let start = range.range.start;
-      start, specifier, ..
+    let specifier = &range.specifier;
    } = range;
    let line = start.line + 1;
    let column = start.character + 1;
    if !*DENO_DISABLE_PEDANTIC_NODE_WARNINGS {
-      log::warn!("{} Resolving \"{module_name}\" as \"node:{module_name}\" at {specifier}:{line}:{column}. If you want to use a built-in Node module, add a \"node:\" prefix.", colors::yellow("Warning"))
+      log::warn!("{} Resolving \"{module_name}\" as \"node:{module_name}\" at {specifier}:{start}. If you want to use a built-in Node module, add a \"node:\" prefix.", colors::yellow("Warning"))
    }
  }
--- a/cli/standalone/binary.rs
+++ b/cli/standalone/binary.rs
@ -4,6 +4,7 @@ use std::borrow::Cow;
 use std::collections::BTreeMap;
 use std::collections::HashMap;
 use std::collections::VecDeque;
 use std::env;
 use std::env::current_exe;
 use std::ffi::OsString;
 use std::fs;
@ -15,6 +16,7 @@ use std::io::Seek;
 use std::io::SeekFrom;
 use std::io::Write;
 use std::ops::Range;
 use std::path::Component;
 use std::path::Path;
 use std::path::PathBuf;
 use std::process::Command;
@ -47,11 +49,11 @@ use deno_runtime::deno_fs::FileSystem;
 use deno_runtime::deno_fs::RealFs;
 use deno_runtime::deno_io::fs::FsError;
 use deno_runtime::deno_node::PackageJson;
 use deno_runtime::ops::otel::OtelConfig;
 use deno_semver::npm::NpmVersionReqParseError;
 use deno_semver::package::PackageReq;
 use deno_semver::Version;
 use deno_semver::VersionReqSpecifierParseError;
 use deno_telemetry::OtelConfig;
 use indexmap::IndexMap;
 use log::Level;
 use serde::Deserialize;
@ -87,6 +89,7 @@ use super::serialization::RemoteModulesStore;
 use super::serialization::RemoteModulesStoreBuilder;
 use super::virtual_fs::FileBackedVfs;
 use super::virtual_fs::VfsBuilder;
 use super::virtual_fs::VfsFileSubDataKind;
 use super::virtual_fs::VfsRoot;
 use super::virtual_fs::VirtualDirectory;
@ -275,7 +278,9 @@ impl StandaloneModules {
    if specifier.scheme() == "file" {
      let path = deno_path_util::url_to_file_path(specifier)?;
      let bytes = match self.vfs.file_entry(&path) {
-        Ok(entry) => self.vfs.read_file_all(entry)?,
+        Ok(entry) => self
          .vfs
          .read_file_all(entry, VfsFileSubDataKind::ModuleGraph)?,
        Err(err) if err.kind() == ErrorKind::NotFound => {
          let bytes = match RealFs.read_file_sync(&path, None) {
            Ok(bytes) => bytes,
@ -454,7 +459,7 @@ impl<'a> DenoCompileBinaryWriter<'a> {
    //
    // Phase 2 of the 'min sized' deno compile RFC talks
    // about adding this as a flag.
-    if let Some(path) = std::env::var_os("DENORT_BIN") {
+    if let Some(path) = get_dev_binary_path() {
      return std::fs::read(&path).with_context(|| {
        format!("Could not find denort at '{}'", path.to_string_lossy())
      });
@ -691,6 +696,7 @@ impl<'a> DenoCompileBinaryWriter<'a> {
              Some(source) => source,
              None => RealFs.read_file_sync(&file_path, None)?,
            },
            VfsFileSubDataKind::ModuleGraph,
          )
          .with_context(|| {
            format!("Failed adding '{}'", file_path.display())
@ -904,6 +910,31 @@ impl<'a> DenoCompileBinaryWriter<'a> {
  }
 }
 fn get_denort_path(deno_exe: PathBuf) -> Option<OsString> {
  let mut denort = deno_exe;
  denort.set_file_name(if cfg!(windows) {
    "denort.exe"
  } else {
    "denort"
  });
  denort.exists().then(|| denort.into_os_string())
 }
 fn get_dev_binary_path() -> Option<OsString> {
  env::var_os("DENORT_BIN").or_else(|| {
    env::current_exe().ok().and_then(|exec_path| {
      if exec_path
        .components()
        .any(|component| component == Component::Normal("target".as_ref()))
      {
        get_denort_path(exec_path)
      } else {
        None
      }
    })
  })
 }
 /// This function returns the environment variables specified
 /// in the passed environment file.
 fn get_file_env_vars(
--- a/cli/standalone/file_system.rs
+++ b/cli/standalone/file_system.rs
@ -17,6 +17,7 @@ use deno_runtime::deno_io::fs::FsResult;
 use deno_runtime::deno_io::fs::FsStat;
 use super::virtual_fs::FileBackedVfs;
 use super::virtual_fs::VfsFileSubDataKind;
 #[derive(Debug, Clone)]
 pub struct DenoCompileFileSystem(Arc<FileBackedVfs>);
@ -36,7 +37,8 @@ impl DenoCompileFileSystem {
  fn copy_to_real_path(&self, oldpath: &Path, newpath: &Path) -> FsResult<()> {
    let old_file = self.0.file_entry(oldpath)?;
-    let old_file_bytes = self.0.read_file_all(old_file)?;
+    let old_file_bytes =
      self.0.read_file_all(old_file, VfsFileSubDataKind::Raw)?;
    RealFs.write_file_sync(
      newpath,
      OpenOptions {
--- a/cli/standalone/mod.rs
+++ b/cli/standalone/mod.rs
@ -50,12 +50,14 @@ use deno_semver::npm::NpmPackageReqReference;
 use import_map::parse_from_json;
 use node_resolver::analyze::NodeCodeTranslator;
 use node_resolver::errors::ClosestPkgJsonError;
-use node_resolver::NodeModuleKind;
+use node_resolver::NodeResolutionKind;
-use node_resolver::NodeResolutionMode;
+use node_resolver::ResolutionMode;
 use serialization::DenoCompileModuleSource;
 use std::borrow::Cow;
 use std::rc::Rc;
 use std::sync::Arc;
 use virtual_fs::FileBackedVfs;
 use virtual_fs::VfsFileSubDataKind;
 use crate::args::create_default_npmrc;
 use crate::args::get_root_cert_store;
@ -111,6 +113,7 @@ use self::file_system::DenoCompileFileSystem;
 struct SharedModuleLoaderState {
  cjs_tracker: Arc<CjsTracker>,
  code_cache: Option<Arc<dyn CliCodeCache>>,
  fs: Arc<dyn deno_fs::FileSystem>,
  modules: StandaloneModules,
  node_code_translator: Arc<CliNodeCodeTranslator>,
@ -118,8 +121,8 @@ struct SharedModuleLoaderState {
  npm_module_loader: Arc<NpmModuleLoader>,
  npm_req_resolver: Arc<CliNpmReqResolver>,
  npm_resolver: Arc<dyn CliNpmResolver>,
  vfs: Arc<FileBackedVfs>,
  workspace_resolver: WorkspaceResolver,
  code_cache: Option<Arc<dyn CliCodeCache>>,
 }
 impl SharedModuleLoaderState {
@ -190,9 +193,9 @@ impl ModuleLoader for EmbeddedModuleLoader {
      .cjs_tracker
      .is_maybe_cjs(&referrer, MediaType::from_specifier(&referrer))?
    {
-      NodeModuleKind::Cjs
+      ResolutionMode::Require
    } else {
-      NodeModuleKind::Esm
+      ResolutionMode::Import
    };
    if self.shared.node_resolver.in_npm_package(&referrer) {
@ -204,7 +207,7 @@ impl ModuleLoader for EmbeddedModuleLoader {
            raw_specifier,
            &referrer,
            referrer_kind,
-            NodeResolutionMode::Execution,
+            NodeResolutionKind::Execution,
          )?
          .into_url(),
      );
@ -232,7 +235,7 @@ impl ModuleLoader for EmbeddedModuleLoader {
            sub_path.as_deref(),
            Some(&referrer),
            referrer_kind,
-            NodeResolutionMode::Execution,
+            NodeResolutionKind::Execution,
          )?,
      ),
      Ok(MappedResolution::PackageJson {
@ -249,7 +252,7 @@ impl ModuleLoader for EmbeddedModuleLoader {
            sub_path.as_deref(),
            &referrer,
            referrer_kind,
-            NodeResolutionMode::Execution,
+            NodeResolutionKind::Execution,
          )
          .map_err(AnyError::from),
        PackageJsonDepValue::Workspace(version_req) => {
@ -269,7 +272,7 @@ impl ModuleLoader for EmbeddedModuleLoader {
                sub_path.as_deref(),
                Some(&referrer),
                referrer_kind,
-                NodeResolutionMode::Execution,
+                NodeResolutionKind::Execution,
              )?,
          )
        }
@ -283,7 +286,7 @@ impl ModuleLoader for EmbeddedModuleLoader {
            &reference,
            &referrer,
            referrer_kind,
-            NodeResolutionMode::Execution,
+            NodeResolutionKind::Execution,
          )?);
        }
@ -310,7 +313,7 @@ impl ModuleLoader for EmbeddedModuleLoader {
          raw_specifier,
          &referrer,
          referrer_kind,
-          NodeResolutionMode::Execution,
+          NodeResolutionKind::Execution,
        )?;
        if let Some(res) = maybe_res {
          return Ok(res.into_url());
@ -514,7 +517,12 @@ impl NodeRequireLoader for EmbeddedModuleLoader {
    &self,
    path: &std::path::Path,
  ) -> Result<String, AnyError> {
-    Ok(self.shared.fs.read_text_file_lossy_sync(path, None)?)
+    let file_entry = self.shared.vfs.file_entry(path)?;
    let file_bytes = self
      .shared
      .vfs
      .read_file_all(file_entry, VfsFileSubDataKind::ModuleGraph)?;
    Ok(String::from_utf8(file_bytes.into_owned())?)
  }
  fn is_maybe_cjs(
@ -817,6 +825,7 @@ pub async fn run(data: StandaloneData) -> Result<i32, AnyError> {
  let module_loader_factory = StandaloneModuleLoaderFactory {
    shared: Arc::new(SharedModuleLoaderState {
      cjs_tracker: cjs_tracker.clone(),
      code_cache: code_cache.clone(),
      fs: fs.clone(),
      modules,
      node_code_translator: node_code_translator.clone(),
@ -826,10 +835,10 @@ pub async fn run(data: StandaloneData) -> Result<i32, AnyError> {
        fs.clone(),
        node_code_translator,
      )),
      code_cache: code_cache.clone(),
      npm_resolver: npm_resolver.clone(),
      workspace_resolver,
      npm_req_resolver,
      vfs,
      workspace_resolver,
    }),
  };
--- a/cli/standalone/virtual_fs.rs
+++ b/cli/standalone/virtual_fs.rs
@ -32,6 +32,15 @@ use thiserror::Error;
 use crate::util;
 use crate::util::fs::canonicalize_path;
 #[derive(Debug, Copy, Clone)]
 pub enum VfsFileSubDataKind {
  /// Raw bytes of the file.
  Raw,
  /// Bytes to use for module loading. For example, for TypeScript
  /// files this will be the transpiled JavaScript source.
  ModuleGraph,
 }
 #[derive(Error, Debug)]
 #[error(
  "Failed to strip prefix '{}' from '{}'", root_path.display(), target.display()
@ -141,7 +150,11 @@ impl VfsBuilder {
                // inline the symlink and make the target file
                let file_bytes = std::fs::read(&target)
                  .with_context(|| format!("Reading {}", path.display()))?;
-                self.add_file_with_data_inner(&path, file_bytes)?;
+                self.add_file_with_data_inner(
                  &path,
                  file_bytes,
                  VfsFileSubDataKind::Raw,
                )?;
              } else {
                log::warn!(
                  "{} Symlink target is outside '{}'. Excluding symlink at '{}' with target '{}'.",
@ -219,25 +232,27 @@ impl VfsBuilder {
  ) -> Result<(), AnyError> {
    let file_bytes = std::fs::read(path)
      .with_context(|| format!("Reading {}", path.display()))?;
-    self.add_file_with_data_inner(path, file_bytes)
+    self.add_file_with_data_inner(path, file_bytes, VfsFileSubDataKind::Raw)
  }
  pub fn add_file_with_data(
    &mut self,
    path: &Path,
    data: Vec<u8>,
    sub_data_kind: VfsFileSubDataKind,
  ) -> Result<(), AnyError> {
    let target_path = canonicalize_path(path)?;
    if target_path != path {
      self.add_symlink(path, &target_path)?;
    }
-    self.add_file_with_data_inner(&target_path, data)
+    self.add_file_with_data_inner(&target_path, data, sub_data_kind)
  }
  fn add_file_with_data_inner(
    &mut self,
    path: &Path,
    data: Vec<u8>,
    sub_data_kind: VfsFileSubDataKind,
  ) -> Result<(), AnyError> {
    log::debug!("Adding file '{}'", path.display());
    let checksum = util::checksum::gen(&[&data]);
@ -253,8 +268,19 @@ impl VfsBuilder {
    let name = path.file_name().unwrap().to_string_lossy();
    let data_len = data.len();
    match dir.entries.binary_search_by(|e| e.name().cmp(&name)) {
-      Ok(_) => {
+      Ok(index) => {
-        // already added, just ignore
+        let entry = &mut dir.entries[index];
        match entry {
          VfsEntry::File(virtual_file) => match sub_data_kind {
            VfsFileSubDataKind::Raw => {
              virtual_file.offset = offset;
            }
            VfsFileSubDataKind::ModuleGraph => {
              virtual_file.module_graph_offset = offset;
            }
          },
          VfsEntry::Dir(_) | VfsEntry::Symlink(_) => unreachable!(),
        }
      }
      Err(insert_index) => {
        dir.entries.insert(
@ -262,6 +288,7 @@ impl VfsBuilder {
          VfsEntry::File(VirtualFile {
            name: name.to_string(),
            offset,
            module_graph_offset: offset,
            len: data.len() as u64,
          }),
        );
@ -302,7 +329,7 @@ impl VfsBuilder {
    let dir = self.add_dir(path.parent().unwrap())?;
    let name = path.file_name().unwrap().to_string_lossy();
    match dir.entries.binary_search_by(|e| e.name().cmp(&name)) {
-      Ok(_) => unreachable!(),
+      Ok(_) => Ok(()), // previously inserted
      Err(insert_index) => {
        dir.entries.insert(
          insert_index,
@ -314,9 +341,9 @@ impl VfsBuilder {
              .collect::<Vec<_>>(),
          }),
        );
        Ok(())
      }
    }
    Ok(())
  }
  pub fn into_dir_and_files(self) -> (VirtualDirectory, Vec<Vec<u8>>) {
@ -454,6 +481,12 @@ pub struct VirtualDirectory {
 pub struct VirtualFile {
  pub name: String,
  pub offset: u64,
  /// Offset file to use for module loading when it differs from the
  /// raw file. Often this will be the same offset as above for data
  /// such as JavaScript files, but for TypeScript files the `offset`
  /// will be the original raw bytes when included as an asset and this
  /// offset will be to the transpiled JavaScript source.
  pub module_graph_offset: u64,
  pub len: u64,
 }
@ -647,7 +680,7 @@ impl FileBackedVfsFile {
      .map_err(|err| err.into())
  }
-  fn read_to_end(&self) -> FsResult<Vec<u8>> {
+  fn read_to_end(&self) -> FsResult<Cow<'static, [u8]>> {
    let read_pos = {
      let mut pos = self.pos.lock();
      let read_pos = *pos;
@ -659,12 +692,20 @@ impl FileBackedVfsFile {
      read_pos
    };
    if read_pos > self.file.len {
-      return Ok(Vec::new());
+      return Ok(Cow::Borrowed(&[]));
    }
    if read_pos == 0 {
      Ok(
        self
          .vfs
          .read_file_all(&self.file, VfsFileSubDataKind::Raw)?,
      )
    } else {
      let size = (self.file.len - read_pos) as usize;
      let mut buf = vec![0; size];
      self.vfs.read_file(&self.file, read_pos, &mut buf)?;
      Ok(Cow::Owned(buf))
    }
    let size = (self.file.len - read_pos) as usize;
    let mut buf = vec![0; size];
    self.vfs.read_file(&self.file, read_pos, &mut buf)?;
    Ok(buf)
  }
 }
@ -703,11 +744,14 @@ impl deno_io::fs::File for FileBackedVfsFile {
  }
  fn read_all_sync(self: Rc<Self>) -> FsResult<Vec<u8>> {
-    self.read_to_end()
+    self.read_to_end().map(|bytes| bytes.into_owned())
  }
  async fn read_all_async(self: Rc<Self>) -> FsResult<Vec<u8>> {
    let inner = (*self).clone();
-    tokio::task::spawn_blocking(move || inner.read_to_end()).await?
+    tokio::task::spawn_blocking(move || {
      inner.read_to_end().map(|bytes| bytes.into_owned())
    })
    .await?
  }
  fn chmod_sync(self: Rc<Self>, _pathmode: u32) -> FsResult<()> {
@ -878,8 +922,9 @@ impl FileBackedVfs {
  pub fn read_file_all(
    &self,
    file: &VirtualFile,
    sub_data_kind: VfsFileSubDataKind,
  ) -> std::io::Result<Cow<'static, [u8]>> {
-    let read_range = self.get_read_range(file, 0, file.len)?;
+    let read_range = self.get_read_range(file, sub_data_kind, 0, file.len)?;
    match &self.vfs_data {
      Cow::Borrowed(data) => Ok(Cow::Borrowed(&data[read_range])),
      Cow::Owned(data) => Ok(Cow::Owned(data[read_range].to_vec())),
@ -892,7 +937,12 @@ impl FileBackedVfs {
    pos: u64,
    buf: &mut [u8],
  ) -> std::io::Result<usize> {
-    let read_range = self.get_read_range(file, pos, buf.len() as u64)?;
+    let read_range = self.get_read_range(
      file,
      VfsFileSubDataKind::Raw,
      pos,
      buf.len() as u64,
    )?;
    let read_len = read_range.len();
    buf[..read_len].copy_from_slice(&self.vfs_data[read_range]);
    Ok(read_len)
@ -901,6 +951,7 @@ impl FileBackedVfs {
  fn get_read_range(
    &self,
    file: &VirtualFile,
    sub_data_kind: VfsFileSubDataKind,
    pos: u64,
    len: u64,
  ) -> std::io::Result<Range<usize>> {
@ -910,7 +961,11 @@ impl FileBackedVfs {
        "unexpected EOF",
      ));
    }
-    let file_offset = self.fs_root.start_file_offset + file.offset;
+    let offset = match sub_data_kind {
      VfsFileSubDataKind::Raw => file.offset,
      VfsFileSubDataKind::ModuleGraph => file.module_graph_offset,
    };
    let file_offset = self.fs_root.start_file_offset + offset;
    let start = file_offset + pos;
    let end = file_offset + std::cmp::min(pos + len, file.len);
    Ok(start as usize..end as usize)
@ -951,7 +1006,13 @@ mod test {
  #[track_caller]
  fn read_file(vfs: &FileBackedVfs, path: &Path) -> String {
    let file = vfs.file_entry(path).unwrap();
-    String::from_utf8(vfs.read_file_all(file).unwrap().into_owned()).unwrap()
+    String::from_utf8(
      vfs
        .read_file_all(file, VfsFileSubDataKind::Raw)
        .unwrap()
        .into_owned(),
    )
    .unwrap()
  }
  #[test]
@ -964,23 +1025,40 @@ mod test {
    let src_path = src_path.to_path_buf();
    let mut builder = VfsBuilder::new(src_path.clone()).unwrap();
    builder
-      .add_file_with_data_inner(&src_path.join("a.txt"), "data".into())
+      .add_file_with_data_inner(
        &src_path.join("a.txt"),
        "data".into(),
        VfsFileSubDataKind::Raw,
      )
      .unwrap();
    builder
-      .add_file_with_data_inner(&src_path.join("b.txt"), "data".into())
+      .add_file_with_data_inner(
        &src_path.join("b.txt"),
        "data".into(),
        VfsFileSubDataKind::Raw,
      )
      .unwrap();
    assert_eq!(builder.files.len(), 1); // because duplicate data
    builder
-      .add_file_with_data_inner(&src_path.join("c.txt"), "c".into())
+      .add_file_with_data_inner(
        &src_path.join("c.txt"),
        "c".into(),
        VfsFileSubDataKind::Raw,
      )
      .unwrap();
    builder
      .add_file_with_data_inner(
        &src_path.join("sub_dir").join("d.txt"),
        "d".into(),
        VfsFileSubDataKind::Raw,
      )
      .unwrap();
    builder
-      .add_file_with_data_inner(&src_path.join("e.txt"), "e".into())
+      .add_file_with_data_inner(
        &src_path.join("e.txt"),
        "e".into(),
        VfsFileSubDataKind::Raw,
      )
      .unwrap();
    builder
      .add_symlink(
@ -1151,6 +1229,7 @@ mod test {
      .add_file_with_data_inner(
        temp_path.join("a.txt").as_path(),
        "0123456789".to_string().into_bytes(),
        VfsFileSubDataKind::Raw,
      )
      .unwrap();
    let (dest_path, virtual_fs) = into_virtual_fs(builder, &temp_dir);
--- a/cli/tools/doc.rs
+++ b/cli/tools/doc.rs
@ -427,33 +427,7 @@ fn generate_docs_directory(
    symbol_redirect_map,
    default_symbol_map,
    markdown_renderer: deno_doc::html::comrak::create_renderer(
-      None,
+      None, None, None,
      Some(Box::new(|ammonia| {
        ammonia.add_allowed_classes(
          "code",
          &[
            "language-ts",
            "language-tsx",
            "language-typescript",
            "language-js",
            "language-jsx",
            "language-javascript",
            "language-bash",
            "language-shell",
            "language-md",
            "language-markdown",
            "language-rs",
            "language-rust",
            "language-html",
            "language-xml",
            "language-css",
            "language-json",
            "language-regex",
            "language-svg",
          ],
        );
      })),
      None,
    ),
    markdown_stripper: Rc::new(deno_doc::html::comrak::strip),
    head_inject: Some(Rc::new(|root| {
--- a/cli/tools/info.rs
+++ b/cli/tools/info.rs
@ -235,22 +235,31 @@ fn add_npm_packages_to_json(
        .get_mut("dependencies")
        .and_then(|d| d.as_array_mut());
      if let Some(dependencies) = dependencies {
-        for dep in dependencies.iter_mut() {
+        for dep in dependencies.iter_mut().flat_map(|d| d.as_object_mut()) {
-          if let serde_json::Value::Object(dep) = dep {
+          if let Some(specifier) = dep.get("specifier").and_then(|s| s.as_str())
-            let specifier = dep.get("specifier").and_then(|s| s.as_str());
+          {
-            if let Some(specifier) = specifier {
+            if let Ok(npm_ref) = NpmPackageReqReference::from_str(specifier) {
-              if let Ok(npm_ref) = NpmPackageReqReference::from_str(specifier) {
+              if let Ok(pkg) = snapshot.resolve_pkg_from_pkg_req(npm_ref.req())
-                if let Ok(pkg) =
+              {
-                  snapshot.resolve_pkg_from_pkg_req(npm_ref.req())
+                dep.insert(
-                {
+                  "npmPackage".to_string(),
-                  dep.insert(
+                  pkg.id.as_serialized().into(),
-                    "npmPackage".to_string(),
+                );
                    pkg.id.as_serialized().into(),
                  );
                }
              }
            }
          }
          // don't show this in the output unless someone needs it
          if let Some(code) =
            dep.get_mut("code").and_then(|c| c.as_object_mut())
          {
            code.remove("resolutionMode");
          }
          if let Some(types) =
            dep.get_mut("types").and_then(|c| c.as_object_mut())
          {
            types.remove("resolutionMode");
          }
        }
      }
    }
--- a/cli/tools/init/mod.rs
+++ b/cli/tools/init/mod.rs
@ -9,6 +9,7 @@ use crate::args::RunFlags;
 use crate::colors;
 use color_print::cformat;
 use color_print::cstr;
 use deno_config::deno_json::NodeModulesDirMode;
 use deno_core::anyhow::Context;
 use deno_core::error::AnyError;
 use deno_core::serde_json::json;
@ -288,6 +289,7 @@ async fn init_npm(name: &str, args: Vec<String>) -> Result<i32, AnyError> {
    },
    allow_scripts: PackagesAllowedScripts::All,
    argv: args,
    node_modules_dir: Some(NodeModulesDirMode::Auto),
    subcommand: DenoSubcommand::Run(RunFlags {
      script: script_name,
      ..Default::default()
--- a/cli/tools/lint/rules/no_sloppy_imports.rs
+++ b/cli/tools/lint/rules/no_sloppy_imports.rs
@ -8,7 +8,7 @@ use std::sync::Arc;
 use deno_ast::SourceRange;
 use deno_config::workspace::WorkspaceResolver;
 use deno_core::anyhow::anyhow;
-use deno_graph::source::ResolutionMode;
+use deno_graph::source::ResolutionKind;
 use deno_graph::source::ResolveError;
 use deno_graph::Range;
 use deno_lint::diagnostic::LintDiagnosticDetails;
@ -17,7 +17,7 @@ use deno_lint::diagnostic::LintFix;
 use deno_lint::diagnostic::LintFixChange;
 use deno_lint::rules::LintRule;
 use deno_resolver::sloppy_imports::SloppyImportsResolution;
-use deno_resolver::sloppy_imports::SloppyImportsResolutionMode;
+use deno_resolver::sloppy_imports::SloppyImportsResolutionKind;
 use text_lines::LineAndColumnIndex;
 use crate::graph_util::CliJsrUrlProvider;
@ -101,16 +101,16 @@ impl LintRule for NoSloppyImportsRule {
      maybe_npm_resolver: None,
    });
-    for (range, sloppy_import) in resolver.captures.borrow_mut().drain() {
+    for (referrer, sloppy_import) in resolver.captures.borrow_mut().drain() {
      let start_range =
        context.text_info().loc_to_source_pos(LineAndColumnIndex {
-          line_index: range.start.line,
+          line_index: referrer.range.start.line,
-          column_index: range.start.character,
+          column_index: referrer.range.start.character,
        });
      let end_range =
        context.text_info().loc_to_source_pos(LineAndColumnIndex {
-          line_index: range.end.line,
+          line_index: referrer.range.end.line,
-          column_index: range.end.character,
+          column_index: referrer.range.end.character,
        });
      let source_range = SourceRange::new(start_range, end_range);
      context.add_diagnostic_details(
@ -183,7 +183,7 @@ impl<'a> deno_graph::source::Resolver for SloppyImportCaptureResolver<'a> {
    &self,
    specifier_text: &str,
    referrer_range: &Range,
-    mode: ResolutionMode,
+    resolution_kind: ResolutionKind,
  ) -> Result<deno_ast::ModuleSpecifier, deno_graph::source::ResolveError> {
    let resolution = self
      .workspace_resolver
@ -198,9 +198,9 @@ impl<'a> deno_graph::source::Resolver for SloppyImportCaptureResolver<'a> {
        specifier, ..
      } => match self.sloppy_imports_resolver.resolve(
        &specifier,
-        match mode {
+        match resolution_kind {
-          ResolutionMode::Execution => SloppyImportsResolutionMode::Execution,
+          ResolutionKind::Execution => SloppyImportsResolutionKind::Execution,
-          ResolutionMode::Types => SloppyImportsResolutionMode::Types,
+          ResolutionKind::Types => SloppyImportsResolutionKind::Types,
        },
      ) {
        Some(res) => {
--- a/cli/tools/registry/diagnostics.rs
+++ b/cli/tools/registry/diagnostics.rs
@ -234,8 +234,8 @@ impl Diagnostic for PublishDiagnostic {
        specifier: Cow::Borrowed(&referrer.specifier),
        text_info: Cow::Borrowed(text_info),
        source_pos: DiagnosticSourcePos::LineAndCol {
-          line: referrer.start.line,
+          line: referrer.range.start.line,
-          column: referrer.start.character,
+          column: referrer.range.start.character,
        },
      }
    }
@ -300,7 +300,7 @@ impl Diagnostic for PublishDiagnostic {
      text_info: &'a SourceTextInfo,
      referrer: &'a deno_graph::Range,
    ) -> Option<DiagnosticSnippet<'a>> {
-      if referrer.start.line == 0 && referrer.start.character == 0 {
+      if referrer.range.start.line == 0 && referrer.range.start.character == 0 {
        return None; // no range, probably a jsxImportSource import
      }
@ -310,12 +310,12 @@ impl Diagnostic for PublishDiagnostic {
          style: DiagnosticSnippetHighlightStyle::Error,
          range: DiagnosticSourceRange {
            start: DiagnosticSourcePos::LineAndCol {
-              line: referrer.start.line,
+              line: referrer.range.start.line,
-              column: referrer.start.character,
+              column: referrer.range.start.character,
            },
            end: DiagnosticSourcePos::LineAndCol {
-              line: referrer.end.line,
+              line: referrer.range.end.line,
-              column: referrer.end.character,
+              column: referrer.range.end.character,
            },
          },
          description: Some("the specifier".into()),
--- a/cli/tools/registry/unfurl.rs
+++ b/cli/tools/registry/unfurl.rs
@ -12,7 +12,7 @@ use deno_graph::DynamicTemplatePart;
 use deno_graph::ParserModuleAnalyzer;
 use deno_graph::TypeScriptReference;
 use deno_package_json::PackageJsonDepValue;
-use deno_resolver::sloppy_imports::SloppyImportsResolutionMode;
+use deno_resolver::sloppy_imports::SloppyImportsResolutionKind;
 use deno_runtime::deno_node::is_builtin_node_module;
 use crate::resolver::CliSloppyImportsResolver;
@ -180,7 +180,7 @@ impl SpecifierUnfurler {
    let resolved =
      if let Some(sloppy_imports_resolver) = &self.sloppy_imports_resolver {
        sloppy_imports_resolver
-          .resolve(&resolved, SloppyImportsResolutionMode::Execution)
+          .resolve(&resolved, SloppyImportsResolutionKind::Execution)
          .map(|res| res.into_specifier())
          .unwrap_or(resolved)
      } else {
@ -319,8 +319,8 @@ impl SpecifierUnfurler {
    }
    for ts_ref in &module_info.ts_references {
      let specifier_with_range = match ts_ref {
-        TypeScriptReference::Path(range) => range,
+        TypeScriptReference::Path(s) => s,
-        TypeScriptReference::Types(range) => range,
+        TypeScriptReference::Types { specifier, .. } => specifier,
      };
      analyze_specifier(
        &specifier_with_range.text,
@ -328,10 +328,10 @@ impl SpecifierUnfurler {
        &mut text_changes,
      );
    }
-    for specifier_with_range in &module_info.jsdoc_imports {
+    for jsdoc in &module_info.jsdoc_imports {
      analyze_specifier(
-        &specifier_with_range.text,
+        &jsdoc.specifier.text,
-        &specifier_with_range.range,
+        &jsdoc.specifier.range,
        &mut text_changes,
      );
    }
--- a/cli/tools/repl/session.rs
+++ b/cli/tools/repl/session.rs
@ -43,13 +43,13 @@ use deno_core::unsync::spawn;
 use deno_core::url::Url;
 use deno_core::LocalInspectorSession;
 use deno_core::PollEventLoopOptions;
 use deno_graph::source::ResolutionMode;
 use deno_graph::Position;
 use deno_graph::PositionRange;
 use deno_graph::SpecifierWithRange;
 use deno_runtime::worker::MainWorker;
 use deno_semver::npm::NpmPackageReqReference;
-use node_resolver::NodeModuleKind;
+use node_resolver::NodeResolutionKind;
 use node_resolver::ResolutionMode;
 use once_cell::sync::Lazy;
 use regex::Match;
 use regex::Regex;
@ -701,11 +701,6 @@ impl ReplSession {
    let mut collector = ImportCollector::new();
    program.visit_with(&mut collector);
    let referrer_range = deno_graph::Range {
      specifier: self.referrer.clone(),
      start: deno_graph::Position::zeroed(),
      end: deno_graph::Position::zeroed(),
    };
    let resolved_imports = collector
      .imports
      .iter()
@ -714,9 +709,10 @@ impl ReplSession {
          .resolver
          .resolve(
            i,
-            &referrer_range,
+            &self.referrer,
-            NodeModuleKind::Esm,
+            deno_graph::Position::zeroed(),
-            ResolutionMode::Execution,
+            ResolutionMode::Import,
            NodeResolutionKind::Execution,
          )
          .ok()
          .or_else(|| ModuleSpecifier::parse(i).ok())
--- a/cli/tools/task.rs
+++ b/cli/tools/task.rs
@ -721,11 +721,9 @@ fn print_available_tasks(
    )?;
    if let Some(description) = &desc.task.description {
      let slash_slash = colors::italic_gray("//");
-      writeln!(
+      for line in description.lines() {
-        writer,
+        writeln!(writer, "    {slash_slash} {}", colors::italic_gray(line))?;
-        "    {slash_slash} {}",
+      }
        colors::italic_gray(description)
      )?;
    }
    writeln!(writer, "    {}", desc.task.command)?;
    if !desc.task.dependencies.is_empty() {
--- a/cli/tsc/99_main_compiler.js
+++ b/cli/tsc/99_main_compiler.js
@ -681,14 +681,18 @@ delete Object.prototype.__proto__;
    getNewLine() {
      return "\n";
    },
-    resolveTypeReferenceDirectives(
+    resolveTypeReferenceDirectiveReferences(
-      typeDirectiveNames,
+      typeDirectiveReferences,
      containingFilePath,
      redirectedReference,
      options,
-      containingFileMode,
+      containingSourceFile,
      _reusedNames,
    ) {
-      return typeDirectiveNames.map((arg) => {
+      const isCjs =
        containingSourceFile?.impliedNodeFormat === ts.ModuleKind.CommonJS;
      /** @type {Array<ts.ResolvedTypeReferenceDirectiveWithFailedLookupLocations>} */
      const result = typeDirectiveReferences.map((arg) => {
        /** @type {ts.FileReference} */
        const fileReference = typeof arg === "string"
          ? {
@ -701,16 +705,28 @@ delete Object.prototype.__proto__;
          /** @type {[string, ts.Extension] | undefined} */
          const resolved = ops.op_resolve(
            containingFilePath,
-            containingFileMode === ts.ModuleKind.CommonJS,
+            [
-            [fileReference.fileName],
+              [
                fileReference.resolutionMode == null
                  ? isCjs
                  : fileReference.resolutionMode === ts.ModuleKind.CommonJS,
                fileReference.fileName,
              ],
            ],
          )?.[0];
          if (resolved) {
            return {
-              primary: true,
+              resolvedTypeReferenceDirective: {
-              resolvedFileName: resolved[0],
+                primary: true,
                resolvedFileName: resolved[0],
                // todo(dsherret): we should probably be setting this
                isExternalLibraryImport: undefined,
              },
            };
          } else {
-            return undefined;
+            return {
              resolvedTypeReferenceDirective: undefined,
            };
          }
        } else {
          return ts.resolveTypeReferenceDirective(
@ -720,41 +736,56 @@ delete Object.prototype.__proto__;
            host,
            redirectedReference,
            undefined,
-            containingFileMode ?? fileReference.resolutionMode,
+            containingSourceFile?.impliedNodeFormat ??
-          ).resolvedTypeReferenceDirective;
+              fileReference.resolutionMode,
          );
        }
      });
      return result;
    },
-    resolveModuleNames(
+    resolveModuleNameLiterals(
-      specifiers,
+      moduleLiterals,
      base,
      _reusedNames,
      _redirectedReference,
-      _options,
+      compilerOptions,
      containingSourceFile,
      _reusedNames,
    ) {
      const specifiers = moduleLiterals.map((literal) => [
        ts.getModeForUsageLocation(
          containingSourceFile,
          literal,
          compilerOptions,
        ) === ts.ModuleKind.CommonJS,
        literal.text,
      ]);
      if (logDebug) {
        debug(`host.resolveModuleNames()`);
        debug(`  base: ${base}`);
-        debug(`  specifiers: ${specifiers.join(", ")}`);
+        debug(`  specifiers: ${specifiers.map((s) => s[1]).join(", ")}`);
      }
      /** @type {Array<[string, ts.Extension] | undefined>} */
      const resolved = ops.op_resolve(
        base,
        containingSourceFile?.impliedNodeFormat === ts.ModuleKind.CommonJS,
        specifiers,
      );
      if (resolved) {
        /** @type {Array<ts.ResolvedModuleWithFailedLookupLocations>} */
        const result = resolved.map((item) => {
          if (item) {
            const [resolvedFileName, extension] = item;
            return {
-              resolvedFileName,
+              resolvedModule: {
-              extension,
+                resolvedFileName,
-              isExternalLibraryImport: false,
+                extension,
                // todo(dsherret): we should probably be setting this
                isExternalLibraryImport: false,
              },
            };
          }
-          return undefined;
+          return {
            resolvedModule: undefined,
          };
        });
        result.length = specifiers.length;
        return result;
--- a/cli/tsc/dts/lib.dom.d.ts
+++ b/cli/tsc/dts/lib.dom.d.ts
@ -18277,7 +18277,7 @@ declare var ReadableStream: {
    new(underlyingSource: UnderlyingByteSource, strategy?: { highWaterMark?: number }): ReadableStream<Uint8Array>;
    new<R = any>(underlyingSource: UnderlyingDefaultSource<R>, strategy?: QueuingStrategy<R>): ReadableStream<R>;
    new<R = any>(underlyingSource?: UnderlyingSource<R>, strategy?: QueuingStrategy<R>): ReadableStream<R>;
-    from<R>(asyncIterable: AsyncIterable<R> | Iterable<R | PromiseLike<R>>): ReadableStream<R>;
+    from<R>(asyncIterable: AsyncIterable<R> | Iterable<R | PromiseLike<R>> & object): ReadableStream<R>;
 };
 /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/ReadableStreamBYOBReader) */
--- a/cli/tsc/mod.rs
+++ b/cli/tsc/mod.rs
@ -41,8 +41,8 @@ use deno_semver::npm::NpmPackageReqReference;
 use node_resolver::errors::NodeJsErrorCode;
 use node_resolver::errors::NodeJsErrorCoded;
 use node_resolver::errors::PackageSubpathResolveError;
-use node_resolver::NodeModuleKind;
+use node_resolver::NodeResolutionKind;
-use node_resolver::NodeResolutionMode;
+use node_resolver::ResolutionMode;
 use once_cell::sync::Lazy;
 use std::borrow::Cow;
 use std::collections::HashMap;
@ -703,10 +703,9 @@ pub struct ResolveArgs {
  /// The base specifier that the supplied specifier strings should be resolved
  /// relative to.
  pub base: String,
  /// If the base is cjs.
  pub is_base_cjs: bool,
  /// A list of specifiers that should be resolved.
-  pub specifiers: Vec<String>,
+  /// (is_cjs: bool, raw_specifier: String)
  pub specifiers: Vec<(bool, String)>,
 }
 #[op2]
@ -714,17 +713,9 @@ pub struct ResolveArgs {
 fn op_resolve(
  state: &mut OpState,
  #[string] base: String,
-  is_base_cjs: bool,
+  #[serde] specifiers: Vec<(bool, String)>,
  #[serde] specifiers: Vec<String>,
 ) -> Result<Vec<(String, &'static str)>, AnyError> {
-  op_resolve_inner(
+  op_resolve_inner(state, ResolveArgs { base, specifiers })
    state,
    ResolveArgs {
      base,
      is_base_cjs,
      specifiers,
    },
  )
 }
 #[inline]
@ -735,11 +726,6 @@ fn op_resolve_inner(
  let state = state.borrow_mut::<State>();
  let mut resolved: Vec<(String, &'static str)> =
    Vec::with_capacity(args.specifiers.len());
  let referrer_kind = if args.is_base_cjs {
    NodeModuleKind::Cjs
  } else {
    NodeModuleKind::Esm
  };
  let referrer = if let Some(remapped_specifier) =
    state.remapped_specifiers.get(&args.base)
  {
@ -752,7 +738,7 @@ fn op_resolve_inner(
    )?
  };
  let referrer_module = state.graph.get(&referrer);
-  for specifier in args.specifiers {
+  for (is_cjs, specifier) in args.specifiers {
    if specifier.starts_with("node:") {
      resolved.push((
        MISSING_DEPENDENCY_SPECIFIER.to_string(),
@ -771,13 +757,20 @@ fn op_resolve_inner(
      .and_then(|m| m.js())
      .and_then(|m| m.dependencies_prefer_fast_check().get(&specifier))
      .and_then(|d| d.maybe_type.ok().or_else(|| d.maybe_code.ok()));
    let resolution_mode = if is_cjs {
      ResolutionMode::Require
    } else {
      ResolutionMode::Import
    };
    let maybe_result = match resolved_dep {
      Some(ResolutionResolved { specifier, .. }) => {
        resolve_graph_specifier_types(
          specifier,
          &referrer,
-          referrer_kind,
+          // we could get this from the resolved dep, but for now assume
          // the value resolved in TypeScript is better
          resolution_mode,
          state,
        )?
      }
@ -785,7 +778,7 @@ fn op_resolve_inner(
        match resolve_non_graph_specifier_types(
          &specifier,
          &referrer,
-          referrer_kind,
+          resolution_mode,
          state,
        ) {
          Ok(maybe_result) => maybe_result,
@ -852,7 +845,7 @@ fn op_resolve_inner(
 fn resolve_graph_specifier_types(
  specifier: &ModuleSpecifier,
  referrer: &ModuleSpecifier,
-  referrer_kind: NodeModuleKind,
+  resolution_mode: ResolutionMode,
  state: &State,
 ) -> Result<Option<(ModuleSpecifier, MediaType)>, AnyError> {
  let graph = &state.graph;
@ -908,8 +901,8 @@ fn resolve_graph_specifier_types(
            &package_folder,
            module.nv_reference.sub_path(),
            Some(referrer),
-            referrer_kind,
+            resolution_mode,
-            NodeResolutionMode::Types,
+            NodeResolutionKind::Types,
          );
        let maybe_url = match res_result {
          Ok(url) => Some(url),
@ -949,7 +942,7 @@ enum ResolveNonGraphSpecifierTypesError {
 fn resolve_non_graph_specifier_types(
  raw_specifier: &str,
  referrer: &ModuleSpecifier,
-  referrer_kind: NodeModuleKind,
+  resolution_mode: ResolutionMode,
  state: &State,
 ) -> Result<
  Option<(ModuleSpecifier, MediaType)>,
@ -967,8 +960,8 @@ fn resolve_non_graph_specifier_types(
        .resolve(
          raw_specifier,
          referrer,
-          referrer_kind,
+          resolution_mode,
-          NodeResolutionMode::Types,
+          NodeResolutionKind::Types,
        )
        .ok()
        .map(|res| res.into_url()),
@ -976,7 +969,7 @@ fn resolve_non_graph_specifier_types(
  } else if let Ok(npm_req_ref) =
    NpmPackageReqReference::from_str(raw_specifier)
  {
-    debug_assert_eq!(referrer_kind, NodeModuleKind::Esm);
+    debug_assert_eq!(resolution_mode, ResolutionMode::Import);
    // todo(dsherret): add support for injecting this in the graph so
    // we don't need this special code here.
    // This could occur when resolving npm:@types/node when it is
@ -988,8 +981,8 @@ fn resolve_non_graph_specifier_types(
      &package_folder,
      npm_req_ref.sub_path(),
      Some(referrer),
-      referrer_kind,
+      resolution_mode,
-      NodeResolutionMode::Types,
+      NodeResolutionKind::Types,
    );
    let maybe_url = match res_result {
      Ok(url) => Some(url),
@ -1388,8 +1381,7 @@ mod tests {
      &mut state,
      ResolveArgs {
        base: "https://deno.land/x/a.ts".to_string(),
-        is_base_cjs: false,
+        specifiers: vec![(false, "./b.ts".to_string())],
        specifiers: vec!["./b.ts".to_string()],
      },
    )
    .expect("should have invoked op");
@ -1408,8 +1400,7 @@ mod tests {
      &mut state,
      ResolveArgs {
        base: "https://deno.land/x/a.ts".to_string(),
-        is_base_cjs: false,
+        specifiers: vec![(false, "./bad.ts".to_string())],
        specifiers: vec!["./bad.ts".to_string()],
      },
    )
    .expect("should have not errored");
--- a/cli/util/fs.rs
+++ b/cli/util/fs.rs
@ -659,7 +659,7 @@ impl LaxSingleProcessFsFlag {
              //
              // This uses a blocking task because we use a single threaded
              // runtime and this is time sensitive so we don't want it to update
-              // at the whims of of whatever is occurring on the runtime thread.
+              // at the whims of whatever is occurring on the runtime thread.
              spawn_blocking({
                let token = token.clone();
                let last_updated_path = last_updated_path.clone();
--- a/cli/util/logger.rs
+++ b/cli/util/logger.rs
@ -29,7 +29,7 @@ impl log::Log for CliLogger {
      // thread's state
      DrawThread::hide();
      self.0.log(record);
-      deno_runtime::ops::otel::handle_log(record);
+      deno_telemetry::handle_log(record);
      DrawThread::show();
    }
  }
--- a/cli/worker.rs
+++ b/cli/worker.rs
@ -30,7 +30,6 @@ use deno_runtime::deno_tls::RootCertStoreProvider;
 use deno_runtime::deno_web::BlobStore;
 use deno_runtime::fmt_errors::format_js_error;
 use deno_runtime::inspector_server::InspectorServer;
 use deno_runtime::ops::otel::OtelConfig;
 use deno_runtime::ops::process::NpmProcessStateProviderRc;
 use deno_runtime::ops::worker_host::CreateWebWorkerCb;
 use deno_runtime::web_worker::WebWorker;
@ -43,9 +42,10 @@ use deno_runtime::BootstrapOptions;
 use deno_runtime::WorkerExecutionMode;
 use deno_runtime::WorkerLogLevel;
 use deno_semver::npm::NpmPackageReqReference;
 use deno_telemetry::OtelConfig;
 use deno_terminal::colors;
-use node_resolver::NodeModuleKind;
+use node_resolver::NodeResolutionKind;
-use node_resolver::NodeResolutionMode;
+use node_resolver::ResolutionMode;
 use tokio::select;
 use crate::args::CliLockfile;
@ -698,8 +698,8 @@ impl CliMainWorkerFactory {
        package_folder,
        sub_path,
        /* referrer */ None,
-        NodeModuleKind::Esm,
+        ResolutionMode::Import,
-        NodeResolutionMode::Execution,
+        NodeResolutionKind::Execution,
      )?;
    if specifier
      .to_file_path()
--- a/ext/fetch/22_body.js
+++ b/ext/fetch/22_body.js
@ -286,8 +286,13 @@ function mixinBody(prototype, bodySymbol, mimeTypeSymbol) {
       */
      get() {
        webidl.assertBranded(this, prototype);
-        if (this[bodySymbol] !== null) {
+        try {
-          return this[bodySymbol].consumed();
+          if (this[bodySymbol] !== null) {
            return this[bodySymbol].consumed();
          }
        } catch (_) {
          // Request is closed.
          return true;
        }
        return false;
      },
--- a/ext/fetch/26_fetch.js
+++ b/ext/fetch/26_fetch.js
@ -13,6 +13,7 @@
 import { core, primordials } from "ext:core/mod.js";
 import {
  op_fetch,
  op_fetch_promise_is_settled,
  op_fetch_send,
  op_wasm_streaming_feed,
  op_wasm_streaming_set_url,
@ -28,7 +29,9 @@ const {
  PromisePrototypeThen,
  PromisePrototypeCatch,
  SafeArrayIterator,
  SafePromisePrototypeFinally,
  String,
  StringPrototypeEndsWith,
  StringPrototypeStartsWith,
  StringPrototypeToLowerCase,
  TypeError,
@ -55,6 +58,17 @@ import {
  toInnerResponse,
 } from "ext:deno_fetch/23_response.js";
 import * as abortSignal from "ext:deno_web/03_abort_signal.js";
 import {
  endSpan,
  enterSpan,
  exitSpan,
  Span,
  TRACING_ENABLED,
 } from "ext:deno_telemetry/telemetry.ts";
 import {
  updateSpanFromRequest,
  updateSpanFromResponse,
 } from "ext:deno_telemetry/util.ts";
 const REQUEST_BODY_HEADER_NAMES = [
  "content-encoding",
@ -63,6 +77,12 @@ const REQUEST_BODY_HEADER_NAMES = [
  "content-type",
 ];
 const REDIRECT_SENSITIVE_HEADER_NAMES = [
  "authorization",
  "proxy-authorization",
  "cookie",
 ];
 /**
 * @param {number} rid
 * @returns {Promise<{ status: number, statusText: string, headers: [string, string][], url: string, responseRid: number, error: [string, string]? }>}
@ -250,12 +270,14 @@ function httpRedirectFetch(request, response, terminator) {
  if (locationHeaders.length === 0) {
    return response;
  }
  const currentURL = new URL(request.currentUrl());
  const locationURL = new URL(
    locationHeaders[0][1],
    response.url() ?? undefined,
  );
  if (locationURL.hash === "") {
-    locationURL.hash = request.currentUrl().hash;
+    locationURL.hash = currentURL.hash;
  }
  if (locationURL.protocol !== "https:" && locationURL.protocol !== "http:") {
    return networkError("Can not redirect to a non HTTP(s) url");
@ -294,6 +316,28 @@ function httpRedirectFetch(request, response, terminator) {
      }
    }
  }
  // Drop confidential headers when redirecting to a less secure protocol
  // or to a different domain that is not a superdomain
  if (
    locationURL.protocol !== currentURL.protocol &&
      locationURL.protocol !== "https:" ||
    locationURL.host !== currentURL.host &&
      !isSubdomain(locationURL.host, currentURL.host)
  ) {
    for (let i = 0; i < request.headerList.length; i++) {
      if (
        ArrayPrototypeIncludes(
          REDIRECT_SENSITIVE_HEADER_NAMES,
          byteLowerCase(request.headerList[i][0]),
        )
      ) {
        ArrayPrototypeSplice(request.headerList, i, 1);
        i--;
      }
    }
  }
  if (request.body !== null) {
    const res = extractBody(request.body.source);
    request.body = res.body;
@ -307,93 +351,138 @@ function httpRedirectFetch(request, response, terminator) {
 * @param {RequestInit} init
 */
 function fetch(input, init = { __proto__: null }) {
-  // There is an async dispatch later that causes a stack trace disconnect.
+  let span;
-  // We reconnect it by assigning the result of that dispatch to `opPromise`,
+  try {
-  // awaiting `opPromise` in an inner function also named `fetch()` and
+    if (TRACING_ENABLED) {
-  // returning the result from that.
+      span = new Span("fetch", { kind: 2 });
-  let opPromise = undefined;
+      enterSpan(span);
  // 1.
  const result = new Promise((resolve, reject) => {
    const prefix = "Failed to execute 'fetch'";
    webidl.requiredArguments(arguments.length, 1, prefix);
    // 2.
    const requestObject = new Request(input, init);
    // 3.
    const request = toInnerRequest(requestObject);
    // 4.
    if (requestObject.signal.aborted) {
      reject(abortFetch(request, null, requestObject.signal.reason));
      return;
    }
-    // 7.
+    // There is an async dispatch later that causes a stack trace disconnect.
-    let responseObject = null;
+    // We reconnect it by assigning the result of that dispatch to `opPromise`,
-    // 9.
+    // awaiting `opPromise` in an inner function also named `fetch()` and
-    let locallyAborted = false;
+    // returning the result from that.
-    // 10.
+    let opPromise = undefined;
-    function onabort() {
+    // 1.
-      locallyAborted = true;
+    const result = new Promise((resolve, reject) => {
-      reject(
+      const prefix = "Failed to execute 'fetch'";
-        abortFetch(request, responseObject, requestObject.signal.reason),
+      webidl.requiredArguments(arguments.length, 1, prefix);
-      );
+      // 2.
-    }
+      const requestObject = new Request(input, init);
    requestObject.signal[abortSignal.add](onabort);
-    if (!requestObject.headers.has("Accept")) {
+      if (span) {
-      ArrayPrototypePush(request.headerList, ["Accept", "*/*"]);
+        updateSpanFromRequest(span, requestObject);
-    }
+      }
-    if (!requestObject.headers.has("Accept-Language")) {
+      // 3.
-      ArrayPrototypePush(request.headerList, ["Accept-Language", "*"]);
+      const request = toInnerRequest(requestObject);
-    }
+      // 4.
      if (requestObject.signal.aborted) {
        reject(abortFetch(request, null, requestObject.signal.reason));
        return;
      }
      // 7.
      let responseObject = null;
      // 9.
      let locallyAborted = false;
      // 10.
      function onabort() {
        locallyAborted = true;
        reject(
          abortFetch(request, responseObject, requestObject.signal.reason),
        );
      }
      requestObject.signal[abortSignal.add](onabort);
-    // 12.
+      if (!requestObject.headers.has("Accept")) {
-    opPromise = PromisePrototypeCatch(
+        ArrayPrototypePush(request.headerList, ["Accept", "*/*"]);
-      PromisePrototypeThen(
+      }
-        mainFetch(request, false, requestObject.signal),
+
-        (response) => {
+      if (!requestObject.headers.has("Accept-Language")) {
-          // 12.1.
+        ArrayPrototypePush(request.headerList, ["Accept-Language", "*"]);
-          if (locallyAborted) return;
+      }
-          // 12.2.
+
-          if (response.aborted) {
+      // 12.
-            reject(
+      opPromise = PromisePrototypeCatch(
-              abortFetch(
+        PromisePrototypeThen(
-                request,
+          mainFetch(request, false, requestObject.signal),
-                responseObject,
+          (response) => {
-                requestObject.signal.reason,
+            // 12.1.
-              ),
+            if (locallyAborted) return;
-            );
+            // 12.2.
            if (response.aborted) {
              reject(
                abortFetch(
                  request,
                  responseObject,
                  requestObject.signal.reason,
                ),
              );
              requestObject.signal[abortSignal.remove](onabort);
              return;
            }
            // 12.3.
            if (response.type === "error") {
              const err = new TypeError(
                "Fetch failed: " + (response.error ?? "unknown error"),
              );
              reject(err);
              requestObject.signal[abortSignal.remove](onabort);
              return;
            }
            responseObject = fromInnerResponse(response, "immutable");
            if (span) {
              updateSpanFromResponse(span, responseObject);
            }
            resolve(responseObject);
            requestObject.signal[abortSignal.remove](onabort);
-            return;
+          },
-          }
+        ),
-          // 12.3.
+        (err) => {
-          if (response.type === "error") {
+          reject(err);
            const err = new TypeError(
              "Fetch failed: " + (response.error ?? "unknown error"),
            );
            reject(err);
            requestObject.signal[abortSignal.remove](onabort);
            return;
          }
          responseObject = fromInnerResponse(response, "immutable");
          resolve(responseObject);
          requestObject.signal[abortSignal.remove](onabort);
        },
-      ),
+      );
-      (err) => {
+    });
-        reject(err);
+
-        requestObject.signal[abortSignal.remove](onabort);
+    if (opPromise) {
-      },
+      PromisePrototypeCatch(result, () => {});
-    );
+      return (async function fetch() {
-  });
+        try {
-  if (opPromise) {
+          await opPromise;
-    PromisePrototypeCatch(result, () => {});
+          return result;
-    return (async function fetch() {
+        } finally {
-      await opPromise;
+          if (span) {
-      return result;
+            endSpan(span);
-    })();
+          }
        }
      })();
    }
    // We need to end the span when the promise settles.
    // WPT has a test that aborted fetch is settled in the same tick.
    // This means we cannot wrap the promise if it is already settled.
    // But this is OK, because we can just immediately end the span
    // in that case.
    if (span) {
      // XXX: This should always be true, otherwise `opPromise` would be present.
      if (op_fetch_promise_is_settled(result)) {
        // It's already settled.
        endSpan(span);
      } else {
        // Not settled yet, we can return a new wrapper promise.
        return SafePromisePrototypeFinally(result, () => {
          endSpan(span);
        });
      }
    }
    return result;
  } finally {
    if (span) {
      exitSpan(span);
    }
  }
  return result;
 }
 function abortFetch(request, responseObject, error) {
@ -410,6 +499,19 @@ function abortFetch(request, responseObject, error) {
  return error;
 }
 /**
 * Checks if the given string is a subdomain of the given domain.
 *
 * @param {String} subdomain
 * @param {String} domain
 * @returns {Boolean}
 */
 function isSubdomain(subdomain, domain) {
  const dot = subdomain.length - domain.length - 1;
  return dot > 0 && subdomain[dot] === "." &&
    StringPrototypeEndsWith(subdomain, domain);
 }
 /**
 * Handle the Response argument to the WebAssembly streaming APIs, after
 * resolving if it was passed as a promise. This function should be registered
--- a/ext/fetch/lib.rs
+++ b/ext/fetch/lib.rs
@ -27,6 +27,7 @@ use deno_core::futures::TryFutureExt;
 use deno_core::op2;
 use deno_core::url;
 use deno_core::url::Url;
 use deno_core::v8;
 use deno_core::AsyncRefCell;
 use deno_core::AsyncResult;
 use deno_core::BufView;
@ -141,6 +142,7 @@ deno_core::extension!(deno_fetch,
    op_fetch_send,
    op_utf8_to_byte_string,
    op_fetch_custom_client<FP>,
    op_fetch_promise_is_settled,
  ],
  esm = [
    "20_headers.js",
@ -1206,3 +1208,8 @@ pub fn extract_authority(url: &mut Url) -> Option<(String, Option<String>)> {
  None
 }
 #[op2(fast)]
 fn op_fetch_promise_is_settled(promise: v8::Local<v8::Promise>) -> bool {
  promise.state() != v8::PromiseState::Pending
 }
--- a/ext/http/00_serve.ts
+++ b/ext/http/00_serve.ts
@ -36,9 +36,7 @@ const {
  PromisePrototypeCatch,
  SafePromisePrototypeFinally,
  PromisePrototypeThen,
  String,
  StringPrototypeIncludes,
  StringPrototypeSlice,
  Symbol,
  TypeError,
  TypedArrayPrototypeGetSymbolToStringTag,
@ -91,6 +89,16 @@ import {
 } from "ext:deno_net/01_net.js";
 import { hasTlsKeyPairOptions, listenTls } from "ext:deno_net/02_tls.js";
 import { SymbolAsyncDispose } from "ext:deno_web/00_infra.js";
 import {
  endSpan,
  enterSpan,
  Span,
  TRACING_ENABLED,
 } from "ext:deno_telemetry/telemetry.ts";
 import {
  updateSpanFromRequest,
  updateSpanFromResponse,
 } from "ext:deno_telemetry/util.ts";
 const _upgraded = Symbol("_upgraded");
@ -527,16 +535,7 @@ function mapToCallback(context, callback, onError) {
      innerRequest.request = request;
      if (span) {
-        span.updateName(request.method);
+        updateSpanFromRequest(span, request);
        span.setAttribute("http.request.method", request.method);
        const url = new URL(request.url);
        span.setAttribute("url.full", request.url);
        span.setAttribute(
          "url.scheme",
          StringPrototypeSlice(url.protocol, 0, -1),
        );
        span.setAttribute("url.path", url.pathname);
        span.setAttribute("url.query", StringPrototypeSlice(url.search, 1));
      }
      response = await callback(
@ -578,10 +577,7 @@ function mapToCallback(context, callback, onError) {
    }
    if (span) {
-      span.setAttribute(
+      updateSpanFromResponse(span, response);
        "http.response.status_code",
        String(response.status),
      );
    }
    const inner = toInnerResponse(response);
@ -617,13 +613,12 @@ function mapToCallback(context, callback, onError) {
    fastSyncResponseOrStream(req, inner.body, status, innerRequest);
  };
-  if (internals.telemetry.tracingEnabled) {
+  if (TRACING_ENABLED) {
    const { Span, enterSpan, endSpan } = internals.telemetry;
    const origMapped = mapped;
    mapped = function (req, _span) {
      const oldCtx = getAsyncContext();
      setAsyncContext(context.asyncContext);
-      const span = new Span("deno.serve");
+      const span = new Span("deno.serve", { kind: 1 });
      try {
        enterSpan(span);
        return SafePromisePrototypeFinally(
--- a/ext/node/ops/require.rs
+++ b/ext/node/ops/require.rs
@ -8,13 +8,13 @@ use deno_core::v8;
 use deno_core::JsRuntimeInspector;
 use deno_core::OpState;
 use deno_fs::FileSystemRc;
 use deno_package_json::NodeModuleKind;
 use deno_package_json::PackageJsonRc;
 use deno_path_util::normalize_path;
 use deno_path_util::url_from_file_path;
 use deno_path_util::url_to_file_path;
 use node_resolver::errors::ClosestPkgJsonError;
-use node_resolver::NodeResolutionMode;
+use node_resolver::NodeResolutionKind;
 use node_resolver::ResolutionMode;
 use node_resolver::REQUIRE_CONDITIONS;
 use std::borrow::Cow;
 use std::cell::RefCell;
@ -462,9 +462,9 @@ where
      &expansion,
      exports,
      Some(&referrer),
-      NodeModuleKind::Cjs,
+      ResolutionMode::Require,
      REQUIRE_CONDITIONS,
-      NodeResolutionMode::Execution,
+      NodeResolutionKind::Execution,
    )?;
    Ok(Some(if r.scheme() == "file" {
      url_to_file_path_string(&r)?
@ -559,9 +559,9 @@ where
    &format!(".{expansion}"),
    exports,
    referrer.as_ref(),
-    NodeModuleKind::Cjs,
+    ResolutionMode::Require,
    REQUIRE_CONDITIONS,
-    NodeResolutionMode::Execution,
+    NodeResolutionKind::Execution,
  )?;
  Ok(Some(if r.scheme() == "file" {
    url_to_file_path_string(&r)?
@ -630,10 +630,10 @@ where
    let url = node_resolver.package_imports_resolve(
      &request,
      Some(&referrer_url),
-      NodeModuleKind::Cjs,
+      ResolutionMode::Require,
      Some(&pkg),
      REQUIRE_CONDITIONS,
-      NodeResolutionMode::Execution,
+      NodeResolutionKind::Execution,
    )?;
    Ok(Some(url_to_file_path_string(&url)?))
  } else {
--- a/ext/node/polyfills/_fs/_fs_stat.ts
+++ b/ext/node/polyfills/_fs/_fs_stat.ts
@ -6,6 +6,7 @@
 import { denoErrorToNodeError } from "ext:deno_node/internal/errors.ts";
 import { promisify } from "ext:deno_node/internal/util.mjs";
 import { primordials } from "ext:core/mod.js";
 import { getValidatedPath } from "ext:deno_node/internal/fs/utils.mjs";
 const { ObjectCreate, ObjectAssign } = primordials;
@ -379,6 +380,7 @@ export function stat(
    ? optionsOrCallback
    : { bigint: false };
  path = getValidatedPath(path).toString();
  if (!callback) throw new Error("No callback function supplied");
  Deno.stat(path).then(
@ -409,6 +411,8 @@ export function statSync(
  path: string | URL,
  options: statOptions = { bigint: false, throwIfNoEntry: true },
 ): Stats | BigIntStats | undefined {
  path = getValidatedPath(path).toString();
  try {
    const origin = Deno.statSync(path);
    return CFISBIS(origin, options.bigint);
--- a/ext/telemetry/Cargo.toml
+++ b/ext/telemetry/Cargo.toml
@ -0,0 +1,31 @@
 # Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
 [package]
 name = "deno_telemetry"
 version = "0.1.0"
 authors.workspace = true
 edition.workspace = true
 license.workspace = true
 readme = "README.md"
 repository.workspace = true
 description = "Telemetry for Deno"
 [lib]
 path = "lib.rs"
 [dependencies]
 async-trait.workspace = true
 deno_core.workspace = true
 http-body-util.workspace = true
 hyper.workspace = true
 hyper-util.workspace = true
 log.workspace = true
 once_cell.workspace = true
 opentelemetry.workspace = true
 opentelemetry-http.workspace = true
 opentelemetry-otlp.workspace = true
 opentelemetry-semantic-conventions.workspace = true
 opentelemetry_sdk.workspace = true
 pin-project.workspace = true
 serde.workspace = true
 tokio.workspace = true
--- a/ext/telemetry/README.md
+++ b/ext/telemetry/README.md
@ -0,0 +1,3 @@
 # `deno_telemetry`
 This crate implements telemetry for Deno using OpenTelemetry.
--- a/ext/telemetry/lib.rs
+++ b/ext/telemetry/lib.rs
@ -1,6 +1,5 @@
 // Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
 use crate::tokio_util::create_basic_runtime;
 use deno_core::anyhow;
 use deno_core::anyhow::anyhow;
 use deno_core::futures::channel::mpsc;
@ -59,7 +58,7 @@ type SpanProcessor = BatchSpanProcessor<OtelSharedRuntime>;
 type LogProcessor = BatchLogProcessor<OtelSharedRuntime>;
 deno_core::extension!(
-  deno_otel,
+  deno_telemetry,
  ops = [
    op_otel_log,
    op_otel_instrumentation_scope_create_and_enter,
@ -73,6 +72,7 @@ deno_core::extension!(
    op_otel_span_set_dropped,
    op_otel_span_flush,
  ],
  esm = ["telemetry.ts", "util.ts"],
 );
 #[derive(Debug, Clone, Serialize, Deserialize)]
@ -111,7 +111,26 @@ fn otel_create_shared_runtime() -> UnboundedSender<BoxFuture<'static, ()>> {
    mpsc::unbounded::<BoxFuture<'static, ()>>();
  thread::spawn(move || {
-    let rt = create_basic_runtime();
+    let rt = tokio::runtime::Builder::new_current_thread()
      .enable_io()
      .enable_time()
      // This limits the number of threads for blocking operations (like for
      // synchronous fs ops) or CPU bound tasks like when we run dprint in
      // parallel for deno fmt.
      // The default value is 512, which is an unhelpfully large thread pool. We
      // don't ever want to have more than a couple dozen threads.
      .max_blocking_threads(if cfg!(windows) {
        // on windows, tokio uses blocking tasks for child process IO, make sure
        // we have enough available threads for other tasks to run
        4 * std::thread::available_parallelism()
          .map(|n| n.get())
          .unwrap_or(8)
      } else {
        32
      })
      .build()
      .unwrap();
    rt.block_on(async move {
      while let Some(task) = spawn_task_rx.next().await {
        tokio::spawn(task);
--- a/ext/telemetry/telemetry.ts
+++ b/ext/telemetry/telemetry.ts
@ -1,6 +1,6 @@
 // Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
-import { core, internals, primordials } from "ext:core/mod.js";
+import { core, primordials } from "ext:core/mod.js";
 import {
  op_crypto_get_random_values,
  op_otel_instrumentation_scope_create_and_enter,
@ -38,9 +38,11 @@ const {
 } = primordials;
 const { AsyncVariable, setAsyncContext } = core;
-let TRACING_ENABLED = false;
+export let TRACING_ENABLED = false;
 let DETERMINISTIC = false;
 // Note: These start at 0 in the JS library,
 // but start at 1 when serialized with JSON.
 enum SpanKind {
  INTERNAL = 0,
  SERVER = 1,
@ -91,6 +93,11 @@ interface Attributes {
 type SpanAttributes = Attributes;
 interface SpanOptions {
  attributes?: Attributes;
  kind?: SpanKind;
 }
 interface Link {
  context: SpanContext;
  attributes?: SpanAttributes;
@ -354,7 +361,7 @@ export class Span {
  #recording = TRACING_ENABLED;
-  #kind: number = 0;
+  #kind: number = SpanKind.INTERNAL;
  #name: string;
  #startTime: number;
  #status: { code: number; message?: string } | null = null;
@ -429,7 +436,7 @@ export class Span {
  constructor(
    name: string,
-    attributes?: Attributes,
+    options?: SpanOptions,
  ) {
    if (!this.isRecording) {
      this.#name = "";
@ -442,7 +449,8 @@ export class Span {
    this.#name = name;
    this.#startTime = now();
-    this.#attributes = attributes ?? { __proto__: null } as never;
+    this.#attributes = options?.attributes ?? { __proto__: null } as never;
    this.#kind = options?.kind ?? SpanKind.INTERNAL;
    const currentSpan: Span | {
      spanContext(): { traceId: string; spanId: string };
@ -701,12 +709,3 @@ export const telemetry = {
  SpanExporter,
  ContextManager,
 };
 internals.telemetry = {
  Span,
  enterSpan,
  exitSpan,
  endSpan,
  get tracingEnabled() {
    return TRACING_ENABLED;
  },
 };
--- a/ext/telemetry/util.ts
+++ b/ext/telemetry/util.ts
@ -0,0 +1,27 @@
 // Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
 import { primordials } from "ext:core/mod.js";
 import type { Span } from "ext:deno_telemetry/telemetry.ts";
 const { String, StringPrototypeSlice } = primordials;
 export function updateSpanFromRequest(span: Span, request: Request) {
  span.updateName(request.method);
  span.setAttribute("http.request.method", request.method);
  const url = new URL(request.url);
  span.setAttribute("url.full", request.url);
  span.setAttribute(
    "url.scheme",
    StringPrototypeSlice(url.protocol, 0, -1),
  );
  span.setAttribute("url.path", url.pathname);
  span.setAttribute("url.query", StringPrototypeSlice(url.search, 1));
 }
 export function updateSpanFromResponse(span: Span, response: Response) {
  span.setAttribute(
    "http.response.status_code",
    String(response.status),
  );
 }
--- a/ext/web/06_streams.js
+++ b/ext/web/06_streams.js
@ -2922,7 +2922,7 @@ function readableStreamPipeTo(
 }
 /**
- * @param {ReadableStreamGenericReader<any> | ReadableStreamBYOBReader} reader
+ * @param {ReadableStreamGenericReader | ReadableStreamBYOBReader} reader
 * @param {any} reason
 * @returns {Promise<void>}
 */
@ -2955,7 +2955,7 @@ function readableStreamReaderGenericInitialize(reader, stream) {
 /**
 * @template R
- * @param {ReadableStreamGenericReader<R> | ReadableStreamBYOBReader} reader
+ * @param {ReadableStreamGenericReader | ReadableStreamBYOBReader} reader
 */
 function readableStreamReaderGenericRelease(reader) {
  const stream = reader[_stream];
--- a/ext/web/06_streams_types.d.ts
+++ b/ext/web/06_streams_types.d.ts
@ -60,8 +60,8 @@ interface VoidFunction {
  (): void;
 }
-interface ReadableStreamGenericReader<T> {
+interface ReadableStreamGenericReader {
-  readonly closed: Promise<void>;
+  readonly closed: Promise<undefined>;
  // deno-lint-ignore no-explicit-any
  cancel(reason?: any): Promise<void>;
 }
--- a/ext/web/lib.deno_web.d.ts
+++ b/ext/web/lib.deno_web.d.ts
@ -882,7 +882,7 @@ declare var ReadableStream: {
    strategy?: QueuingStrategy<R>,
  ): ReadableStream<R>;
  from<R>(
-    asyncIterable: AsyncIterable<R> | Iterable<R | PromiseLike<R>>,
+    asyncIterable: AsyncIterable<R> | Iterable<R | PromiseLike<R>> & object,
  ): ReadableStream<R>;
 };
--- a/ext/webgpu/01_webgpu.js
+++ b/ext/webgpu/01_webgpu.js
@ -98,6 +98,11 @@ const {
  ArrayPrototypePush,
  DataViewPrototypeGetBuffer,
  Error,
  Number,
  NumberPOSITIVE_INFINITY,
  NumberMAX_SAFE_INTEGER,
  NumberNEGATIVE_INFINITY,
  NumberMIN_SAFE_INTEGER,
  MathMax,
  ObjectDefineProperty,
  ObjectHasOwn,
@ -614,6 +619,19 @@ function createGPUSupportedLimits(limits) {
  return adapterFeatures;
 }
 function normalizeLimit(limit) {
  if (typeof num === "bigint") {
    limit = Number(limit);
    if (limit === NumberPOSITIVE_INFINITY) {
      limit = NumberMAX_SAFE_INTEGER;
    } else if (limit === NumberNEGATIVE_INFINITY) {
      limit = NumberMIN_SAFE_INTEGER;
    }
  }
  return limit;
 }
 /**
 * @typedef InnerAdapterLimits
 * @property {number} maxTextureDimension1D
@ -653,123 +671,127 @@ class GPUSupportedLimits {
  get maxTextureDimension1D() {
    webidl.assertBranded(this, GPUSupportedLimitsPrototype);
-    return this[_limits].maxTextureDimension1D;
+    return normalizeLimit(this[_limits].maxTextureDimension1D);
  }
  get maxTextureDimension2D() {
    webidl.assertBranded(this, GPUSupportedLimitsPrototype);
-    return this[_limits].maxTextureDimension2D;
+    return normalizeLimit(this[_limits].maxTextureDimension2D);
  }
  get maxTextureDimension3D() {
    webidl.assertBranded(this, GPUSupportedLimitsPrototype);
-    return this[_limits].maxTextureDimension3D;
+    return normalizeLimit(this[_limits].maxTextureDimension3D);
  }
  get maxTextureArrayLayers() {
    webidl.assertBranded(this, GPUSupportedLimitsPrototype);
-    return this[_limits].maxTextureArrayLayers;
+    return normalizeLimit(this[_limits].maxTextureArrayLayers);
  }
  get maxBindGroups() {
    webidl.assertBranded(this, GPUSupportedLimitsPrototype);
-    return this[_limits].maxBindGroups;
+    return normalizeLimit(this[_limits].maxBindGroups);
  }
  get maxBindingsPerBindGroup() {
    webidl.assertBranded(this, GPUSupportedLimitsPrototype);
-    return this[_limits].maxBindingsPerBindGroup;
+    return normalizeLimit(this[_limits].maxBindingsPerBindGroup);
  }
  get maxBufferSize() {
    webidl.assertBranded(this, GPUSupportedLimitsPrototype);
-    return this[_limits].maxBufferSize;
+    return normalizeLimit(this[_limits].maxBufferSize);
  }
  get maxDynamicUniformBuffersPerPipelineLayout() {
    webidl.assertBranded(this, GPUSupportedLimitsPrototype);
-    return this[_limits].maxDynamicUniformBuffersPerPipelineLayout;
+    return normalizeLimit(
      this[_limits].maxDynamicUniformBuffersPerPipelineLayout,
    );
  }
  get maxDynamicStorageBuffersPerPipelineLayout() {
    webidl.assertBranded(this, GPUSupportedLimitsPrototype);
-    return this[_limits].maxDynamicStorageBuffersPerPipelineLayout;
+    return normalizeLimit(
      this[_limits].maxDynamicStorageBuffersPerPipelineLayout,
    );
  }
  get maxSampledTexturesPerShaderStage() {
    webidl.assertBranded(this, GPUSupportedLimitsPrototype);
-    return this[_limits].maxSampledTexturesPerShaderStage;
+    return normalizeLimit(this[_limits].maxSampledTexturesPerShaderStage);
  }
  get maxSamplersPerShaderStage() {
    webidl.assertBranded(this, GPUSupportedLimitsPrototype);
-    return this[_limits].maxSamplersPerShaderStage;
+    return normalizeLimit(this[_limits].maxSamplersPerShaderStage);
  }
  get maxStorageBuffersPerShaderStage() {
    webidl.assertBranded(this, GPUSupportedLimitsPrototype);
-    return this[_limits].maxStorageBuffersPerShaderStage;
+    return normalizeLimit(this[_limits].maxStorageBuffersPerShaderStage);
  }
  get maxStorageTexturesPerShaderStage() {
    webidl.assertBranded(this, GPUSupportedLimitsPrototype);
-    return this[_limits].maxStorageTexturesPerShaderStage;
+    return normalizeLimit(this[_limits].maxStorageTexturesPerShaderStage);
  }
  get maxUniformBuffersPerShaderStage() {
    webidl.assertBranded(this, GPUSupportedLimitsPrototype);
-    return this[_limits].maxUniformBuffersPerShaderStage;
+    return normalizeLimit(this[_limits].maxUniformBuffersPerShaderStage);
  }
  get maxUniformBufferBindingSize() {
    webidl.assertBranded(this, GPUSupportedLimitsPrototype);
-    return this[_limits].maxUniformBufferBindingSize;
+    return normalizeLimit(this[_limits].maxUniformBufferBindingSize);
  }
  get maxStorageBufferBindingSize() {
    webidl.assertBranded(this, GPUSupportedLimitsPrototype);
-    return this[_limits].maxStorageBufferBindingSize;
+    return normalizeLimit(this[_limits].maxStorageBufferBindingSize);
  }
  get minUniformBufferOffsetAlignment() {
    webidl.assertBranded(this, GPUSupportedLimitsPrototype);
-    return this[_limits].minUniformBufferOffsetAlignment;
+    return normalizeLimit(this[_limits].minUniformBufferOffsetAlignment);
  }
  get minStorageBufferOffsetAlignment() {
    webidl.assertBranded(this, GPUSupportedLimitsPrototype);
-    return this[_limits].minStorageBufferOffsetAlignment;
+    return normalizeLimit(this[_limits].minStorageBufferOffsetAlignment);
  }
  get maxVertexBuffers() {
    webidl.assertBranded(this, GPUSupportedLimitsPrototype);
-    return this[_limits].maxVertexBuffers;
+    return normalizeLimit(this[_limits].maxVertexBuffers);
  }
  get maxVertexAttributes() {
    webidl.assertBranded(this, GPUSupportedLimitsPrototype);
-    return this[_limits].maxVertexAttributes;
+    return normalizeLimit(this[_limits].maxVertexAttributes);
  }
  get maxVertexBufferArrayStride() {
    webidl.assertBranded(this, GPUSupportedLimitsPrototype);
-    return this[_limits].maxVertexBufferArrayStride;
+    return normalizeLimit(this[_limits].maxVertexBufferArrayStride);
  }
  get maxInterStageShaderComponents() {
    webidl.assertBranded(this, GPUSupportedLimitsPrototype);
-    return this[_limits].maxInterStageShaderComponents;
+    return normalizeLimit(this[_limits].maxInterStageShaderComponents);
  }
  get maxColorAttachments() {
    webidl.assertBranded(this, GPUSupportedLimitsPrototype);
-    return this[_limits].maxColorAttachments;
+    return normalizeLimit(this[_limits].maxColorAttachments);
  }
  get maxColorAttachmentBytesPerSample() {
    webidl.assertBranded(this, GPUSupportedLimitsPrototype);
-    return this[_limits].maxColorAttachmentBytesPerSample;
+    return normalizeLimit(this[_limits].maxColorAttachmentBytesPerSample);
  }
  get maxComputeWorkgroupStorageSize() {
    webidl.assertBranded(this, GPUSupportedLimitsPrototype);
-    return this[_limits].maxComputeWorkgroupStorageSize;
+    return normalizeLimit(this[_limits].maxComputeWorkgroupStorageSize);
  }
  get maxComputeInvocationsPerWorkgroup() {
    webidl.assertBranded(this, GPUSupportedLimitsPrototype);
-    return this[_limits].maxComputeInvocationsPerWorkgroup;
+    return normalizeLimit(this[_limits].maxComputeInvocationsPerWorkgroup);
  }
  get maxComputeWorkgroupSizeX() {
    webidl.assertBranded(this, GPUSupportedLimitsPrototype);
-    return this[_limits].maxComputeWorkgroupSizeX;
+    return normalizeLimit(this[_limits].maxComputeWorkgroupSizeX);
  }
  get maxComputeWorkgroupSizeY() {
    webidl.assertBranded(this, GPUSupportedLimitsPrototype);
-    return this[_limits].maxComputeWorkgroupSizeY;
+    return normalizeLimit(this[_limits].maxComputeWorkgroupSizeY);
  }
  get maxComputeWorkgroupSizeZ() {
    webidl.assertBranded(this, GPUSupportedLimitsPrototype);
-    return this[_limits].maxComputeWorkgroupSizeZ;
+    return normalizeLimit(this[_limits].maxComputeWorkgroupSizeZ);
  }
  get maxComputeWorkgroupsPerDimension() {
    webidl.assertBranded(this, GPUSupportedLimitsPrototype);
-    return this[_limits].maxComputeWorkgroupsPerDimension;
+    return normalizeLimit(this[_limits].maxComputeWorkgroupsPerDimension);
  }
  [SymbolFor("Deno.privateCustomInspect")](inspect, inspectOptions) {
--- a/resolvers/deno/cjs.rs
+++ b/resolvers/deno/cjs.rs
@ -7,8 +7,8 @@ use deno_media_type::MediaType;
 use node_resolver::env::NodeResolverEnv;
 use node_resolver::errors::ClosestPkgJsonError;
 use node_resolver::InNpmPackageChecker;
 use node_resolver::NodeModuleKind;
 use node_resolver::PackageJsonResolver;
 use node_resolver::ResolutionMode;
 use url::Url;
 /// Keeps track of what module specifiers were resolved as CJS.
@ -19,7 +19,7 @@ use url::Url;
 #[derive(Debug)]
 pub struct CjsTracker<TEnv: NodeResolverEnv> {
  is_cjs_resolver: IsCjsResolver<TEnv>,
-  known: DashMap<Url, NodeModuleKind>,
+  known: DashMap<Url, ResolutionMode>,
 }
 impl<TEnv: NodeResolverEnv> CjsTracker<TEnv> {
@ -70,42 +70,42 @@ impl<TEnv: NodeResolverEnv> CjsTracker<TEnv> {
    is_script: Option<bool>,
  ) -> Result<bool, ClosestPkgJsonError> {
    let kind = match self
-      .get_known_kind_with_is_script(specifier, media_type, is_script)
+      .get_known_mode_with_is_script(specifier, media_type, is_script)
    {
      Some(kind) => kind,
      None => self.is_cjs_resolver.check_based_on_pkg_json(specifier)?,
    };
-    Ok(kind == NodeModuleKind::Cjs)
+    Ok(kind == ResolutionMode::Require)
  }
  /// Gets the referrer for the specified module specifier.
  ///
  /// Generally the referrer should already be tracked by calling
  /// `is_cjs_with_known_is_script` before calling this method.
-  pub fn get_referrer_kind(&self, specifier: &Url) -> NodeModuleKind {
+  pub fn get_referrer_kind(&self, specifier: &Url) -> ResolutionMode {
    if specifier.scheme() != "file" {
-      return NodeModuleKind::Esm;
+      return ResolutionMode::Import;
    }
    self
-      .get_known_kind(specifier, MediaType::from_specifier(specifier))
+      .get_known_mode(specifier, MediaType::from_specifier(specifier))
-      .unwrap_or(NodeModuleKind::Esm)
+      .unwrap_or(ResolutionMode::Import)
  }
-  fn get_known_kind(
+  fn get_known_mode(
    &self,
    specifier: &Url,
    media_type: MediaType,
-  ) -> Option<NodeModuleKind> {
+  ) -> Option<ResolutionMode> {
-    self.get_known_kind_with_is_script(specifier, media_type, None)
+    self.get_known_mode_with_is_script(specifier, media_type, None)
  }
-  fn get_known_kind_with_is_script(
+  fn get_known_mode_with_is_script(
    &self,
    specifier: &Url,
    media_type: MediaType,
    is_script: Option<bool>,
-  ) -> Option<NodeModuleKind> {
+  ) -> Option<ResolutionMode> {
-    self.is_cjs_resolver.get_known_kind_with_is_script(
+    self.is_cjs_resolver.get_known_mode_with_is_script(
      specifier,
      media_type,
      is_script,
@ -141,25 +141,25 @@ impl<TEnv: NodeResolverEnv> IsCjsResolver<TEnv> {
    }
  }
-  /// Gets the referrer kind for a script in the LSP.
+  /// Gets the resolution mode for a module in the LSP.
-  pub fn get_lsp_referrer_kind(
+  pub fn get_lsp_resolution_mode(
    &self,
    specifier: &Url,
    is_script: Option<bool>,
-  ) -> NodeModuleKind {
+  ) -> ResolutionMode {
    if specifier.scheme() != "file" {
-      return NodeModuleKind::Esm;
+      return ResolutionMode::Import;
    }
    match MediaType::from_specifier(specifier) {
-      MediaType::Mts | MediaType::Mjs | MediaType::Dmts => NodeModuleKind::Esm,
+      MediaType::Mts | MediaType::Mjs | MediaType::Dmts => ResolutionMode::Import,
-      MediaType::Cjs | MediaType::Cts | MediaType::Dcts => NodeModuleKind::Cjs,
+      MediaType::Cjs | MediaType::Cts | MediaType::Dcts => ResolutionMode::Require,
      MediaType::Dts => {
        // dts files are always determined based on the package.json because
        // they contain imports/exports even when considered CJS
-        self.check_based_on_pkg_json(specifier).unwrap_or(NodeModuleKind::Esm)
+        self.check_based_on_pkg_json(specifier).unwrap_or(ResolutionMode::Import)
      }
      MediaType::Wasm |
-      MediaType::Json => NodeModuleKind::Esm,
+      MediaType::Json => ResolutionMode::Import,
      MediaType::JavaScript
      | MediaType::Jsx
      | MediaType::TypeScript
@ -169,27 +169,27 @@ impl<TEnv: NodeResolverEnv> IsCjsResolver<TEnv> {
      | MediaType::SourceMap
      | MediaType::Unknown => {
        match is_script {
-          Some(true) => self.check_based_on_pkg_json(specifier).unwrap_or(NodeModuleKind::Esm),
+          Some(true) => self.check_based_on_pkg_json(specifier).unwrap_or(ResolutionMode::Import),
-          Some(false) | None => NodeModuleKind::Esm,
+          Some(false) | None => ResolutionMode::Import,
        }
      }
    }
  }
-  fn get_known_kind_with_is_script(
+  fn get_known_mode_with_is_script(
    &self,
    specifier: &Url,
    media_type: MediaType,
    is_script: Option<bool>,
-    known_cache: &DashMap<Url, NodeModuleKind>,
+    known_cache: &DashMap<Url, ResolutionMode>,
-  ) -> Option<NodeModuleKind> {
+  ) -> Option<ResolutionMode> {
    if specifier.scheme() != "file" {
-      return Some(NodeModuleKind::Esm);
+      return Some(ResolutionMode::Import);
    }
    match media_type {
-      MediaType::Mts | MediaType::Mjs | MediaType::Dmts => Some(NodeModuleKind::Esm),
+      MediaType::Mts | MediaType::Mjs | MediaType::Dmts => Some(ResolutionMode::Import),
-      MediaType::Cjs | MediaType::Cts | MediaType::Dcts => Some(NodeModuleKind::Cjs),
+      MediaType::Cjs | MediaType::Cts | MediaType::Dcts => Some(ResolutionMode::Require),
      MediaType::Dts => {
        // dts files are always determined based on the package.json because
        // they contain imports/exports even when considered CJS
@ -200,11 +200,11 @@ impl<TEnv: NodeResolverEnv> IsCjsResolver<TEnv> {
          if let Some(value) = value {
            known_cache.insert(specifier.clone(), value);
          }
-          Some(value.unwrap_or(NodeModuleKind::Esm))
+          Some(value.unwrap_or(ResolutionMode::Import))
        }
      }
      MediaType::Wasm |
-      MediaType::Json => Some(NodeModuleKind::Esm),
+      MediaType::Json => Some(ResolutionMode::Import),
      MediaType::JavaScript
      | MediaType::Jsx
      | MediaType::TypeScript
@ -214,17 +214,17 @@ impl<TEnv: NodeResolverEnv> IsCjsResolver<TEnv> {
      | MediaType::SourceMap
      | MediaType::Unknown => {
        if let Some(value) = known_cache.get(specifier).map(|v| *v) {
-          if value == NodeModuleKind::Cjs && is_script == Some(false) {
+          if value == ResolutionMode::Require && is_script == Some(false) {
            // we now know this is actually esm
-            known_cache.insert(specifier.clone(), NodeModuleKind::Esm);
+            known_cache.insert(specifier.clone(), ResolutionMode::Import);
-            Some(NodeModuleKind::Esm)
+            Some(ResolutionMode::Import)
          } else {
            Some(value)
          }
        } else if is_script == Some(false) {
          // we know this is esm
-            known_cache.insert(specifier.clone(), NodeModuleKind::Esm);
+            known_cache.insert(specifier.clone(), ResolutionMode::Import);
-          Some(NodeModuleKind::Esm)
+          Some(ResolutionMode::Import)
        } else {
          None
        }
@ -235,19 +235,19 @@ impl<TEnv: NodeResolverEnv> IsCjsResolver<TEnv> {
  fn check_based_on_pkg_json(
    &self,
    specifier: &Url,
-  ) -> Result<NodeModuleKind, ClosestPkgJsonError> {
+  ) -> Result<ResolutionMode, ClosestPkgJsonError> {
    if self.in_npm_pkg_checker.in_npm_package(specifier) {
      if let Some(pkg_json) =
        self.pkg_json_resolver.get_closest_package_json(specifier)?
      {
        let is_file_location_cjs = pkg_json.typ != "module";
        Ok(if is_file_location_cjs {
-          NodeModuleKind::Cjs
+          ResolutionMode::Require
        } else {
-          NodeModuleKind::Esm
+          ResolutionMode::Import
        })
      } else {
-        Ok(NodeModuleKind::Cjs)
+        Ok(ResolutionMode::Require)
      }
    } else if self.options.detect_cjs || self.options.is_node_main {
      if let Some(pkg_json) =
@ -256,17 +256,17 @@ impl<TEnv: NodeResolverEnv> IsCjsResolver<TEnv> {
        let is_cjs_type = pkg_json.typ == "commonjs"
          || self.options.is_node_main && pkg_json.typ == "none";
        Ok(if is_cjs_type {
-          NodeModuleKind::Cjs
+          ResolutionMode::Require
        } else {
-          NodeModuleKind::Esm
+          ResolutionMode::Import
        })
      } else if self.options.is_node_main {
-        Ok(NodeModuleKind::Cjs)
+        Ok(ResolutionMode::Require)
      } else {
-        Ok(NodeModuleKind::Esm)
+        Ok(ResolutionMode::Import)
      }
    } else {
-      Ok(NodeModuleKind::Esm)
+      Ok(ResolutionMode::Import)
    }
  }
 }
--- a/resolvers/deno/lib.rs
+++ b/resolvers/deno/lib.rs
@ -20,10 +20,10 @@ use node_resolver::env::NodeResolverEnv;
 use node_resolver::errors::NodeResolveError;
 use node_resolver::errors::PackageSubpathResolveError;
 use node_resolver::InNpmPackageChecker;
 use node_resolver::NodeModuleKind;
 use node_resolver::NodeResolution;
-use node_resolver::NodeResolutionMode;
+use node_resolver::NodeResolutionKind;
 use node_resolver::NodeResolver;
 use node_resolver::ResolutionMode;
 use npm::MissingPackageNodeModulesFolderError;
 use npm::NodeModulesOutOfDateError;
 use npm::NpmReqResolver;
@ -31,7 +31,7 @@ use npm::ResolveIfForNpmPackageErrorKind;
 use npm::ResolvePkgFolderFromDenoReqError;
 use npm::ResolveReqWithSubPathErrorKind;
 use sloppy_imports::SloppyImportResolverFs;
-use sloppy_imports::SloppyImportsResolutionMode;
+use sloppy_imports::SloppyImportsResolutionKind;
 use sloppy_imports::SloppyImportsResolver;
 use thiserror::Error;
 use url::Url;
@ -145,8 +145,8 @@ impl<
    &self,
    raw_specifier: &str,
    referrer: &Url,
-    referrer_kind: NodeModuleKind,
+    resolution_mode: ResolutionMode,
-    mode: NodeResolutionMode,
+    resolution_kind: NodeResolutionKind,
  ) -> Result<DenoResolution, DenoResolveError> {
    let mut found_package_json_dep = false;
    let mut maybe_diagnostic = None;
@ -157,7 +157,7 @@ impl<
        && self.in_npm_pkg_checker.in_npm_package(referrer)
      {
        return node_resolver
-          .resolve(raw_specifier, referrer, referrer_kind, mode)
+          .resolve(raw_specifier, referrer, resolution_mode, resolution_kind)
          .map(|res| DenoResolution {
            url: res.into_url(),
            found_package_json_dep,
@ -189,12 +189,12 @@ impl<
              sloppy_imports_resolver
                .resolve(
                  &specifier,
-                  match mode {
+                  match resolution_kind {
-                    NodeResolutionMode::Execution => {
+                    NodeResolutionKind::Execution => {
-                      SloppyImportsResolutionMode::Execution
+                      SloppyImportsResolutionKind::Execution
                    }
-                    NodeResolutionMode::Types => {
+                    NodeResolutionKind::Types => {
-                      SloppyImportsResolutionMode::Types
+                      SloppyImportsResolutionKind::Types
                    }
                  },
                )
@ -221,8 +221,8 @@ impl<
            pkg_json.dir_path(),
            sub_path.as_deref(),
            Some(referrer),
-            referrer_kind,
+            resolution_mode,
-            mode,
+            resolution_kind,
          )
          .map_err(|e| e.into()),
        MappedResolution::PackageJson {
@ -272,8 +272,8 @@ impl<
                      pkg_folder,
                      sub_path.as_deref(),
                      Some(referrer),
-                      referrer_kind,
+                      resolution_mode,
-                      mode,
+                      resolution_kind,
                    )
                    .map_err(|e| {
                      DenoResolveErrorKind::PackageSubpathResolve(e).into_box()
@ -328,8 +328,8 @@ impl<
                pkg_folder,
                npm_req_ref.sub_path(),
                Some(referrer),
-                referrer_kind,
+                resolution_mode,
-                mode,
+                resolution_kind,
              )
              .map(|url| DenoResolution {
                url,
@ -345,8 +345,8 @@ impl<
              .resolve_req_reference(
                &npm_req_ref,
                referrer,
-                referrer_kind,
+                resolution_mode,
-                mode,
+                resolution_kind,
              )
              .map(|url| DenoResolution {
                url,
@ -384,8 +384,8 @@ impl<
            .resolve_if_for_npm_pkg(
              raw_specifier,
              referrer,
-              referrer_kind,
+              resolution_mode,
-              mode,
+              resolution_kind,
            )
            .map_err(|e| match e.into_kind() {
              ResolveIfForNpmPackageErrorKind::NodeResolve(e) => {
--- a/resolvers/deno/npm/mod.rs
+++ b/resolvers/deno/npm/mod.rs
@ -16,10 +16,10 @@ use node_resolver::errors::PackageNotFoundError;
 use node_resolver::errors::PackageResolveErrorKind;
 use node_resolver::errors::PackageSubpathResolveError;
 use node_resolver::InNpmPackageChecker;
 use node_resolver::NodeModuleKind;
 use node_resolver::NodeResolution;
-use node_resolver::NodeResolutionMode;
+use node_resolver::NodeResolutionKind;
 use node_resolver::NodeResolver;
 use node_resolver::ResolutionMode;
 use thiserror::Error;
 use url::Url;
@ -132,15 +132,15 @@ impl<Fs: DenoResolverFs, TNodeResolverEnv: NodeResolverEnv>
    &self,
    req_ref: &NpmPackageReqReference,
    referrer: &Url,
-    referrer_kind: NodeModuleKind,
+    resolution_mode: ResolutionMode,
-    mode: NodeResolutionMode,
+    resolution_kind: NodeResolutionKind,
  ) -> Result<Url, ResolveReqWithSubPathError> {
    self.resolve_req_with_sub_path(
      req_ref.req(),
      req_ref.sub_path(),
      referrer,
-      referrer_kind,
+      resolution_mode,
-      mode,
+      resolution_kind,
    )
  }
@ -149,8 +149,8 @@ impl<Fs: DenoResolverFs, TNodeResolverEnv: NodeResolverEnv>
    req: &PackageReq,
    sub_path: Option<&str>,
    referrer: &Url,
-    referrer_kind: NodeModuleKind,
+    resolution_mode: ResolutionMode,
-    mode: NodeResolutionMode,
+    resolution_kind: NodeResolutionKind,
  ) -> Result<Url, ResolveReqWithSubPathError> {
    let package_folder = self
      .npm_resolver
@ -160,8 +160,8 @@ impl<Fs: DenoResolverFs, TNodeResolverEnv: NodeResolverEnv>
        &package_folder,
        sub_path,
        Some(referrer),
-        referrer_kind,
+        resolution_mode,
-        mode,
+        resolution_kind,
      );
    match resolution_result {
      Ok(url) => Ok(url),
@ -183,13 +183,15 @@ impl<Fs: DenoResolverFs, TNodeResolverEnv: NodeResolverEnv>
    &self,
    specifier: &str,
    referrer: &Url,
-    referrer_kind: NodeModuleKind,
+    resolution_mode: ResolutionMode,
-    mode: NodeResolutionMode,
+    resolution_kind: NodeResolutionKind,
  ) -> Result<Option<NodeResolution>, ResolveIfForNpmPackageError> {
-    let resolution_result =
+    let resolution_result = self.node_resolver.resolve(
-      self
+      specifier,
-        .node_resolver
+      referrer,
-        .resolve(specifier, referrer, referrer_kind, mode);
+      resolution_mode,
      resolution_kind,
    );
    match resolution_result {
      Ok(res) => Ok(Some(res)),
      Err(err) => {
--- a/resolvers/deno/sloppy_imports.rs
+++ b/resolvers/deno/sloppy_imports.rs
@ -80,16 +80,16 @@ impl SloppyImportsResolution {
 /// The kind of resolution currently being done.
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub enum SloppyImportsResolutionMode {
+pub enum SloppyImportsResolutionKind {
  /// Resolving for code that will be executed.
  Execution,
  /// Resolving for code that will be used for type information.
  Types,
 }
-impl SloppyImportsResolutionMode {
+impl SloppyImportsResolutionKind {
  pub fn is_types(&self) -> bool {
-    *self == SloppyImportsResolutionMode::Types
+    *self == SloppyImportsResolutionKind::Types
  }
 }
@ -114,7 +114,7 @@ impl<Fs: SloppyImportResolverFs> SloppyImportsResolver<Fs> {
  pub fn resolve(
    &self,
    specifier: &Url,
-    mode: SloppyImportsResolutionMode,
+    resolution_kind: SloppyImportsResolutionKind,
  ) -> Option<SloppyImportsResolution> {
    fn path_without_ext(
      path: &Path,
@ -167,7 +167,7 @@ impl<Fs: SloppyImportResolverFs> SloppyImportsResolver<Fs> {
    let probe_paths: Vec<(PathBuf, SloppyImportsResolutionReason)> =
      match self.fs.stat_sync(&path) {
        Some(SloppyImportsFsEntry::File) => {
-          if mode.is_types() {
+          if resolution_kind.is_types() {
            let media_type = MediaType::from_specifier(specifier);
            // attempt to resolve the .d.ts file before the .js file
            let probe_media_type_types = match media_type {
@ -197,7 +197,7 @@ impl<Fs: SloppyImportResolverFs> SloppyImportsResolver<Fs> {
          let media_type = MediaType::from_specifier(specifier);
          let probe_media_type_types = match media_type {
            MediaType::JavaScript => (
-              if mode.is_types() {
+              if resolution_kind.is_types() {
                vec![MediaType::TypeScript, MediaType::Tsx, MediaType::Dts]
              } else {
                vec![MediaType::TypeScript, MediaType::Tsx]
@ -208,7 +208,7 @@ impl<Fs: SloppyImportResolverFs> SloppyImportsResolver<Fs> {
              (vec![MediaType::Tsx], SloppyImportsResolutionReason::JsToTs)
            }
            MediaType::Mjs => (
-              if mode.is_types() {
+              if resolution_kind.is_types() {
                vec![MediaType::Mts, MediaType::Dmts, MediaType::Dts]
              } else {
                vec![MediaType::Mts]
@ -216,7 +216,7 @@ impl<Fs: SloppyImportResolverFs> SloppyImportsResolver<Fs> {
              SloppyImportsResolutionReason::JsToTs,
            ),
            MediaType::Cjs => (
-              if mode.is_types() {
+              if resolution_kind.is_types() {
                vec![MediaType::Cts, MediaType::Dcts, MediaType::Dts]
              } else {
                vec![MediaType::Cts]
@ -237,7 +237,7 @@ impl<Fs: SloppyImportResolverFs> SloppyImportsResolver<Fs> {
              return None;
            }
            MediaType::Unknown => (
-              if mode.is_types() {
+              if resolution_kind.is_types() {
                vec![
                  MediaType::TypeScript,
                  MediaType::Tsx,
@ -274,7 +274,7 @@ impl<Fs: SloppyImportResolverFs> SloppyImportsResolver<Fs> {
          if matches!(entry, Some(SloppyImportsFsEntry::Dir)) {
            // try to resolve at the index file
-            if mode.is_types() {
+            if resolution_kind.is_types() {
              probe_paths.push((
                path.join("index.ts"),
                SloppyImportsResolutionReason::Directory,
@ -373,16 +373,22 @@ mod test {
  #[test]
  fn test_unstable_sloppy_imports() {
    fn resolve(specifier: &Url) -> Option<SloppyImportsResolution> {
-      resolve_with_mode(specifier, SloppyImportsResolutionMode::Execution)
+      resolve_with_resolution_kind(
        specifier,
        SloppyImportsResolutionKind::Execution,
      )
    }
    fn resolve_types(specifier: &Url) -> Option<SloppyImportsResolution> {
-      resolve_with_mode(specifier, SloppyImportsResolutionMode::Types)
+      resolve_with_resolution_kind(
        specifier,
        SloppyImportsResolutionKind::Types,
      )
    }
-    fn resolve_with_mode(
+    fn resolve_with_resolution_kind(
      specifier: &Url,
-      mode: SloppyImportsResolutionMode,
+      resolution_kind: SloppyImportsResolutionKind,
    ) -> Option<SloppyImportsResolution> {
      struct RealSloppyImportsResolverFs;
      impl SloppyImportResolverFs for RealSloppyImportsResolverFs {
@ -400,7 +406,7 @@ mod test {
      }
      SloppyImportsResolver::new(RealSloppyImportsResolverFs)
-        .resolve(specifier, mode)
+        .resolve(specifier, resolution_kind)
    }
    let context = TestContext::default();
--- a/resolvers/node/analyze.rs
+++ b/resolvers/node/analyze.rs
@ -21,11 +21,11 @@ use url::Url;
 use crate::env::NodeResolverEnv;
 use crate::npm::InNpmPackageCheckerRc;
 use crate::resolution::NodeResolverRc;
-use crate::NodeModuleKind;
+use crate::NodeResolutionKind;
 use crate::NodeResolutionMode;
 use crate::NpmPackageFolderResolverRc;
 use crate::PackageJsonResolverRc;
 use crate::PathClean;
 use crate::ResolutionMode;
 #[derive(Debug, Clone)]
 pub enum CjsAnalysis<'a> {
@ -209,7 +209,7 @@ impl<TCjsCodeAnalyzer: CjsCodeAnalyzer, TNodeResolverEnv: NodeResolverEnv>
            // FIXME(bartlomieju): check if these conditions are okay, probably
            // should be `deno-require`, because `deno` is already used in `esm_resolver.rs`
            &["deno", "node", "require", "default"],
-            NodeResolutionMode::Execution,
+            NodeResolutionKind::Execution,
          );
          let reexport_specifier = match result {
            Ok(Some(specifier)) => specifier,
@ -303,7 +303,7 @@ impl<TCjsCodeAnalyzer: CjsCodeAnalyzer, TNodeResolverEnv: NodeResolverEnv>
    specifier: &str,
    referrer: &Url,
    conditions: &[&str],
-    mode: NodeResolutionMode,
+    resolution_kind: NodeResolutionKind,
  ) -> Result<Option<Url>, AnyError> {
    if specifier.starts_with('/') {
      todo!();
@ -354,9 +354,9 @@ impl<TCjsCodeAnalyzer: CjsCodeAnalyzer, TNodeResolverEnv: NodeResolverEnv>
              &package_subpath,
              exports,
              Some(referrer),
-              NodeModuleKind::Esm,
+              ResolutionMode::Import,
              conditions,
-              mode,
+              resolution_kind,
            )
            .map_err(AnyError::from),
        )
@ -373,7 +373,9 @@ impl<TCjsCodeAnalyzer: CjsCodeAnalyzer, TNodeResolverEnv: NodeResolverEnv>
            .pkg_json_resolver
            .load_package_json(&package_json_path)?;
          if let Some(package_json) = maybe_package_json {
-            if let Some(main) = package_json.main(NodeModuleKind::Cjs) {
+            if let Some(main) =
              package_json.main(deno_package_json::NodeModuleKind::Cjs)
            {
              return Ok(Some(url_from_file_path(&d.join(main).clean())?));
            }
          }
@ -384,7 +386,9 @@ impl<TCjsCodeAnalyzer: CjsCodeAnalyzer, TNodeResolverEnv: NodeResolverEnv>
          .file_extension_probe(d, &referrer_path)
          .and_then(|p| url_from_file_path(&p).map_err(AnyError::from))
          .map(Some);
-      } else if let Some(main) = package_json.main(NodeModuleKind::Cjs) {
+      } else if let Some(main) =
        package_json.main(deno_package_json::NodeModuleKind::Cjs)
      {
        return Ok(Some(url_from_file_path(&module_dir.join(main).clean())?));
      } else {
        return Ok(Some(url_from_file_path(
--- a/resolvers/node/errors.rs
+++ b/resolvers/node/errors.rs
@ -8,8 +8,8 @@ use boxed_error::Boxed;
 use thiserror::Error;
 use url::Url;
-use crate::NodeModuleKind;
+use crate::NodeResolutionKind;
-use crate::NodeResolutionMode;
+use crate::ResolutionMode;
 #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
 #[allow(non_camel_case_types)]
@ -203,24 +203,24 @@ pub enum PackageSubpathResolveErrorKind {
  maybe_referrer.as_ref().map(|r|
    format!(
      " from{} referrer {}",
-      match referrer_kind {
+      match resolution_mode {
-        NodeModuleKind::Esm => "",
+        ResolutionMode::Import => "",
-        NodeModuleKind::Cjs => " cjs",
+        ResolutionMode::Require => " cjs",
      },
      r
    )
  ).unwrap_or_default(),
-  match mode {
+  match resolution_kind {
-    NodeResolutionMode::Execution => "",
+    NodeResolutionKind::Execution => "",
-    NodeResolutionMode::Types => " for types",
+    NodeResolutionKind::Types => " for types",
  }
 )]
 pub struct PackageTargetNotFoundError {
  pub pkg_json_path: PathBuf,
  pub target: String,
  pub maybe_referrer: Option<Url>,
-  pub referrer_kind: NodeModuleKind,
+  pub resolution_mode: ResolutionMode,
-  pub mode: NodeResolutionMode,
+  pub resolution_kind: NodeResolutionKind,
 }
 impl NodeJsErrorCoded for PackageTargetNotFoundError {
@ -586,7 +586,7 @@ pub struct PackagePathNotExportedError {
  pub pkg_json_path: PathBuf,
  pub subpath: String,
  pub maybe_referrer: Option<Url>,
-  pub mode: NodeResolutionMode,
+  pub resolution_kind: NodeResolutionKind,
 }
 impl NodeJsErrorCoded for PackagePathNotExportedError {
@ -603,9 +603,9 @@ impl std::fmt::Display for PackagePathNotExportedError {
    f.write_str(self.code().as_str())?;
    f.write_char(']')?;
-    let types_msg = match self.mode {
+    let types_msg = match self.resolution_kind {
-      NodeResolutionMode::Execution => String::new(),
+      NodeResolutionKind::Execution => String::new(),
-      NodeResolutionMode::Types => " for types".to_string(),
+      NodeResolutionKind::Types => " for types".to_string(),
    };
    if self.subpath == "." {
      write!(
@ -678,7 +678,7 @@ mod test {
        pkg_json_path: PathBuf::from("test_path").join("package.json"),
        subpath: "./jsx-runtime".to_string(), 
        maybe_referrer: None,
-        mode: NodeResolutionMode::Types
+        resolution_kind: NodeResolutionKind::Types
      }.to_string(),
      format!("[ERR_PACKAGE_PATH_NOT_EXPORTED] Package subpath './jsx-runtime' is not defined for types by \"exports\" in 'test_path{separator_char}package.json'")
    );
@ -687,7 +687,7 @@ mod test {
        pkg_json_path: PathBuf::from("test_path").join("package.json"),
        subpath: ".".to_string(), 
        maybe_referrer: None,
-        mode: NodeResolutionMode::Types
+        resolution_kind: NodeResolutionKind::Types
      }.to_string(),
      format!("[ERR_PACKAGE_PATH_NOT_EXPORTED] No \"exports\" main defined for types in 'test_path{separator_char}package.json'")
    );
--- a/resolvers/node/lib.rs
+++ b/resolvers/node/lib.rs
@ -23,9 +23,9 @@ pub use package_json::PackageJsonThreadLocalCache;
 pub use path::PathClean;
 pub use resolution::parse_npm_pkg_name;
 pub use resolution::resolve_specifier_into_node_modules;
 pub use resolution::NodeModuleKind;
 pub use resolution::NodeResolution;
-pub use resolution::NodeResolutionMode;
+pub use resolution::NodeResolutionKind;
 pub use resolution::NodeResolver;
 pub use resolution::ResolutionMode;
 pub use resolution::DEFAULT_CONDITIONS;
 pub use resolution::REQUIRE_CONDITIONS;
--- a/resolvers/node/resolution.rs
+++ b/resolvers/node/resolution.rs
@ -50,26 +50,30 @@ pub static DEFAULT_CONDITIONS: &[&str] = &["deno", "node", "import"];
 pub static REQUIRE_CONDITIONS: &[&str] = &["require", "node"];
 static TYPES_ONLY_CONDITIONS: &[&str] = &["types"];
-fn conditions_from_module_kind(
+fn conditions_from_resolution_mode(
-  kind: NodeModuleKind,
+  resolution_mode: ResolutionMode,
 ) -> &'static [&'static str] {
-  match kind {
+  match resolution_mode {
-    NodeModuleKind::Esm => DEFAULT_CONDITIONS,
+    ResolutionMode::Import => DEFAULT_CONDITIONS,
-    NodeModuleKind::Cjs => REQUIRE_CONDITIONS,
+    ResolutionMode::Require => REQUIRE_CONDITIONS,
  }
 }
-pub type NodeModuleKind = deno_package_json::NodeModuleKind;
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
 pub enum ResolutionMode {
  Import,
  Require,
 }
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
-pub enum NodeResolutionMode {
+pub enum NodeResolutionKind {
  Execution,
  Types,
 }
-impl NodeResolutionMode {
+impl NodeResolutionKind {
  pub fn is_types(&self) -> bool {
-    matches!(self, NodeResolutionMode::Types)
+    matches!(self, NodeResolutionKind::Types)
  }
 }
@ -130,8 +134,8 @@ impl<TEnv: NodeResolverEnv> NodeResolver<TEnv> {
    &self,
    specifier: &str,
    referrer: &Url,
-    referrer_kind: NodeModuleKind,
+    resolution_mode: ResolutionMode,
-    mode: NodeResolutionMode,
+    resolution_kind: NodeResolutionKind,
  ) -> Result<NodeResolution, NodeResolveError> {
    // Note: if we are here, then the referrer is an esm module
    // TODO(bartlomieju): skipped "policy" part as we don't plan to support it
@ -174,14 +178,18 @@ impl<TEnv: NodeResolverEnv> NodeResolver<TEnv> {
    let url = self.module_resolve(
      specifier,
      referrer,
-      referrer_kind,
+      resolution_mode,
-      conditions_from_module_kind(referrer_kind),
+      conditions_from_resolution_mode(resolution_mode),
-      mode,
+      resolution_kind,
    )?;
-    let url = if mode.is_types() {
+    let url = if resolution_kind.is_types() {
      let file_path = to_file_path(&url);
-      self.path_to_declaration_url(&file_path, Some(referrer), referrer_kind)?
+      self.path_to_declaration_url(
        &file_path,
        Some(referrer),
        resolution_mode,
      )?
    } else {
      url
    };
@ -197,9 +205,9 @@ impl<TEnv: NodeResolverEnv> NodeResolver<TEnv> {
    &self,
    specifier: &str,
    referrer: &Url,
-    referrer_kind: NodeModuleKind,
+    resolution_mode: ResolutionMode,
    conditions: &[&str],
-    mode: NodeResolutionMode,
+    resolution_kind: NodeResolutionKind,
  ) -> Result<Url, NodeResolveError> {
    if should_be_treated_as_relative_or_absolute_path(specifier) {
      Ok(node_join_url(referrer, specifier).map_err(|err| {
@ -218,10 +226,10 @@ impl<TEnv: NodeResolverEnv> NodeResolver<TEnv> {
      Ok(self.package_imports_resolve(
        specifier,
        Some(referrer),
-        referrer_kind,
+        resolution_mode,
        pkg_config.as_deref(),
        conditions,
-        mode,
+        resolution_kind,
      )?)
    } else if let Ok(resolved) = Url::parse(specifier) {
      Ok(resolved)
@ -229,9 +237,9 @@ impl<TEnv: NodeResolverEnv> NodeResolver<TEnv> {
      Ok(self.package_resolve(
        specifier,
        referrer,
-        referrer_kind,
+        resolution_mode,
        conditions,
-        mode,
+        resolution_kind,
      )?)
    }
  }
@ -307,8 +315,8 @@ impl<TEnv: NodeResolverEnv> NodeResolver<TEnv> {
    package_dir: &Path,
    package_subpath: Option<&str>,
    maybe_referrer: Option<&Url>,
-    referrer_kind: NodeModuleKind,
+    resolution_mode: ResolutionMode,
-    mode: NodeResolutionMode,
+    resolution_kind: NodeResolutionKind,
  ) -> Result<Url, PackageSubpathResolveError> {
    let package_subpath = package_subpath
      .map(|s| format!("./{s}"))
@ -317,9 +325,9 @@ impl<TEnv: NodeResolverEnv> NodeResolver<TEnv> {
      package_dir,
      &package_subpath,
      maybe_referrer,
-      referrer_kind,
+      resolution_mode,
-      conditions_from_module_kind(referrer_kind),
+      conditions_from_resolution_mode(resolution_mode),
-      mode,
+      resolution_kind,
    )?;
    // TODO(bartlomieju): skipped checking errors for commonJS resolution and
    // "preserveSymlinksMain"/"preserveSymlinks" options.
@ -385,13 +393,13 @@ impl<TEnv: NodeResolverEnv> NodeResolver<TEnv> {
    &self,
    path: &Path,
    maybe_referrer: Option<&Url>,
-    referrer_kind: NodeModuleKind,
+    resolution_mode: ResolutionMode,
  ) -> Result<Url, TypesNotFoundError> {
    fn probe_extensions<TEnv: NodeResolverEnv>(
      fs: &TEnv,
      path: &Path,
      lowercase_path: &str,
-      referrer_kind: NodeModuleKind,
+      resolution_mode: ResolutionMode,
    ) -> Option<PathBuf> {
      let mut searched_for_d_mts = false;
      let mut searched_for_d_cts = false;
@ -414,11 +422,11 @@ impl<TEnv: NodeResolverEnv> NodeResolver<TEnv> {
        return Some(dts_path);
      }
-      let specific_dts_path = match referrer_kind {
+      let specific_dts_path = match resolution_mode {
-        NodeModuleKind::Cjs if !searched_for_d_cts => {
+        ResolutionMode::Require if !searched_for_d_cts => {
          Some(with_known_extension(path, "d.cts"))
        }
-        NodeModuleKind::Esm if !searched_for_d_mts => {
+        ResolutionMode::Import if !searched_for_d_mts => {
          Some(with_known_extension(path, "d.mts"))
        }
        _ => None, // already searched above
@ -439,7 +447,7 @@ impl<TEnv: NodeResolverEnv> NodeResolver<TEnv> {
      return Ok(url_from_file_path(path).unwrap());
    }
    if let Some(path) =
-      probe_extensions(&self.env, path, &lowercase_path, referrer_kind)
+      probe_extensions(&self.env, path, &lowercase_path, resolution_mode)
    {
      return Ok(url_from_file_path(&path).unwrap());
    }
@ -448,9 +456,9 @@ impl<TEnv: NodeResolverEnv> NodeResolver<TEnv> {
        path,
        /* sub path */ ".",
        maybe_referrer,
-        referrer_kind,
+        resolution_mode,
-        conditions_from_module_kind(referrer_kind),
+        conditions_from_resolution_mode(resolution_mode),
-        NodeResolutionMode::Types,
+        NodeResolutionKind::Types,
      );
      if let Ok(resolution) = resolution_result {
        return Ok(resolution);
@ -460,7 +468,7 @@ impl<TEnv: NodeResolverEnv> NodeResolver<TEnv> {
        &self.env,
        &index_path,
        &index_path.to_string_lossy().to_lowercase(),
-        referrer_kind,
+        resolution_mode,
      ) {
        return Ok(url_from_file_path(&path).unwrap());
      }
@ -480,10 +488,10 @@ impl<TEnv: NodeResolverEnv> NodeResolver<TEnv> {
    &self,
    name: &str,
    maybe_referrer: Option<&Url>,
-    referrer_kind: NodeModuleKind,
+    resolution_mode: ResolutionMode,
    referrer_pkg_json: Option<&PackageJson>,
    conditions: &[&str],
-    mode: NodeResolutionMode,
+    resolution_kind: NodeResolutionKind,
  ) -> Result<Url, PackageImportsResolveError> {
    if name == "#" || name.starts_with("#/") || name.ends_with('/') {
      let reason = "is not a valid internal imports specifier name";
@ -509,11 +517,11 @@ impl<TEnv: NodeResolverEnv> NodeResolver<TEnv> {
            "",
            name,
            maybe_referrer,
-            referrer_kind,
+            resolution_mode,
            false,
            true,
            conditions,
-            mode,
+            resolution_kind,
          )?;
          if let Some(resolved) = maybe_resolved {
            return Ok(resolved);
@ -549,11 +557,11 @@ impl<TEnv: NodeResolverEnv> NodeResolver<TEnv> {
              best_match_subpath.unwrap(),
              best_match,
              maybe_referrer,
-              referrer_kind,
+              resolution_mode,
              true,
              true,
              conditions,
-              mode,
+              resolution_kind,
            )?;
            if let Some(resolved) = maybe_resolved {
              return Ok(resolved);
@ -581,11 +589,11 @@ impl<TEnv: NodeResolverEnv> NodeResolver<TEnv> {
    match_: &str,
    package_json_path: &Path,
    maybe_referrer: Option<&Url>,
-    referrer_kind: NodeModuleKind,
+    resolution_mode: ResolutionMode,
    pattern: bool,
    internal: bool,
    conditions: &[&str],
-    mode: NodeResolutionMode,
+    resolution_kind: NodeResolutionKind,
  ) -> Result<Url, PackageTargetResolveError> {
    if !subpath.is_empty() && !pattern && !target.ends_with('/') {
      return Err(
@ -626,9 +634,9 @@ impl<TEnv: NodeResolverEnv> NodeResolver<TEnv> {
            let result = match self.package_resolve(
              &export_target,
              &package_json_url,
-              referrer_kind,
+              resolution_mode,
              conditions,
-              mode,
+              resolution_kind,
            ) {
              Ok(url) => Ok(url),
              Err(err) => match err.code() {
@ -649,8 +657,8 @@ impl<TEnv: NodeResolverEnv> NodeResolver<TEnv> {
                      pkg_json_path: package_json_path.to_path_buf(),
                      target: export_target.to_string(),
                      maybe_referrer: maybe_referrer.map(ToOwned::to_owned),
-                      referrer_kind,
+                      resolution_mode,
-                      mode,
+                      resolution_kind,
                    },
                  )
                  .into(),
@ -746,11 +754,11 @@ impl<TEnv: NodeResolverEnv> NodeResolver<TEnv> {
    subpath: &str,
    package_subpath: &str,
    maybe_referrer: Option<&Url>,
-    referrer_kind: NodeModuleKind,
+    resolution_mode: ResolutionMode,
    pattern: bool,
    internal: bool,
    conditions: &[&str],
-    mode: NodeResolutionMode,
+    resolution_kind: NodeResolutionKind,
  ) -> Result<Option<Url>, PackageTargetResolveError> {
    let result = self.resolve_package_target_inner(
      package_json_path,
@ -758,16 +766,16 @@ impl<TEnv: NodeResolverEnv> NodeResolver<TEnv> {
      subpath,
      package_subpath,
      maybe_referrer,
-      referrer_kind,
+      resolution_mode,
      pattern,
      internal,
      conditions,
-      mode,
+      resolution_kind,
    );
    match result {
      Ok(maybe_resolved) => Ok(maybe_resolved),
      Err(err) => {
-        if mode.is_types()
+        if resolution_kind.is_types()
          && err.code() == NodeJsErrorCode::ERR_TYPES_NOT_FOUND
          && conditions != TYPES_ONLY_CONDITIONS
        {
@ -779,11 +787,11 @@ impl<TEnv: NodeResolverEnv> NodeResolver<TEnv> {
            subpath,
            package_subpath,
            maybe_referrer,
-            referrer_kind,
+            resolution_mode,
            pattern,
            internal,
            TYPES_ONLY_CONDITIONS,
-            mode,
+            resolution_kind,
          ) {
            return Ok(Some(resolved));
          }
@ -802,11 +810,11 @@ impl<TEnv: NodeResolverEnv> NodeResolver<TEnv> {
    subpath: &str,
    package_subpath: &str,
    maybe_referrer: Option<&Url>,
-    referrer_kind: NodeModuleKind,
+    resolution_mode: ResolutionMode,
    pattern: bool,
    internal: bool,
    conditions: &[&str],
-    mode: NodeResolutionMode,
+    resolution_kind: NodeResolutionKind,
  ) -> Result<Option<Url>, PackageTargetResolveError> {
    if let Some(target) = target.as_str() {
      let url = self.resolve_package_target_string(
@ -815,18 +823,18 @@ impl<TEnv: NodeResolverEnv> NodeResolver<TEnv> {
        package_subpath,
        package_json_path,
        maybe_referrer,
-        referrer_kind,
+        resolution_mode,
        pattern,
        internal,
        conditions,
-        mode,
+        resolution_kind,
      )?;
-      if mode.is_types() && url.scheme() == "file" {
+      if resolution_kind.is_types() && url.scheme() == "file" {
        let path = deno_path_util::url_to_file_path(&url).unwrap();
        return Ok(Some(self.path_to_declaration_url(
          &path,
          maybe_referrer,
-          referrer_kind,
+          resolution_mode,
        )?));
      } else {
        return Ok(Some(url));
@ -844,11 +852,11 @@ impl<TEnv: NodeResolverEnv> NodeResolver<TEnv> {
          subpath,
          package_subpath,
          maybe_referrer,
-          referrer_kind,
+          resolution_mode,
          pattern,
          internal,
          conditions,
-          mode,
+          resolution_kind,
        );
        match resolved_result {
@ -882,7 +890,7 @@ impl<TEnv: NodeResolverEnv> NodeResolver<TEnv> {
        if key == "default"
          || conditions.contains(&key.as_str())
-          || mode.is_types() && key.as_str() == "types"
+          || resolution_kind.is_types() && key.as_str() == "types"
        {
          let condition_target = target_obj.get(key).unwrap();
@ -892,11 +900,11 @@ impl<TEnv: NodeResolverEnv> NodeResolver<TEnv> {
            subpath,
            package_subpath,
            maybe_referrer,
-            referrer_kind,
+            resolution_mode,
            pattern,
            internal,
            conditions,
-            mode,
+            resolution_kind,
          )?;
          match resolved {
            Some(resolved) => return Ok(Some(resolved)),
@ -929,9 +937,9 @@ impl<TEnv: NodeResolverEnv> NodeResolver<TEnv> {
    package_subpath: &str,
    package_exports: &Map<String, Value>,
    maybe_referrer: Option<&Url>,
-    referrer_kind: NodeModuleKind,
+    resolution_mode: ResolutionMode,
    conditions: &[&str],
-    mode: NodeResolutionMode,
+    resolution_kind: NodeResolutionKind,
  ) -> Result<Url, PackageExportsResolveError> {
    if package_exports.contains_key(package_subpath)
      && package_subpath.find('*').is_none()
@ -944,11 +952,11 @@ impl<TEnv: NodeResolverEnv> NodeResolver<TEnv> {
        "",
        package_subpath,
        maybe_referrer,
-        referrer_kind,
+        resolution_mode,
        false,
        false,
        conditions,
-        mode,
+        resolution_kind,
      )?;
      return match resolved {
        Some(resolved) => Ok(resolved),
@ -957,7 +965,7 @@ impl<TEnv: NodeResolverEnv> NodeResolver<TEnv> {
            pkg_json_path: package_json_path.to_path_buf(),
            subpath: package_subpath.to_string(),
            maybe_referrer: maybe_referrer.map(ToOwned::to_owned),
-            mode,
+            resolution_kind,
          }
          .into(),
        ),
@ -1006,11 +1014,11 @@ impl<TEnv: NodeResolverEnv> NodeResolver<TEnv> {
        &best_match_subpath.unwrap(),
        best_match,
        maybe_referrer,
-        referrer_kind,
+        resolution_mode,
        true,
        false,
        conditions,
-        mode,
+        resolution_kind,
      )?;
      if let Some(resolved) = maybe_resolved {
        return Ok(resolved);
@ -1020,7 +1028,7 @@ impl<TEnv: NodeResolverEnv> NodeResolver<TEnv> {
            pkg_json_path: package_json_path.to_path_buf(),
            subpath: package_subpath.to_string(),
            maybe_referrer: maybe_referrer.map(ToOwned::to_owned),
-            mode,
+            resolution_kind,
          }
          .into(),
        );
@ -1032,7 +1040,7 @@ impl<TEnv: NodeResolverEnv> NodeResolver<TEnv> {
        pkg_json_path: package_json_path.to_path_buf(),
        subpath: package_subpath.to_string(),
        maybe_referrer: maybe_referrer.map(ToOwned::to_owned),
-        mode,
+        resolution_kind,
      }
      .into(),
    )
@ -1042,9 +1050,9 @@ impl<TEnv: NodeResolverEnv> NodeResolver<TEnv> {
    &self,
    specifier: &str,
    referrer: &Url,
-    referrer_kind: NodeModuleKind,
+    resolution_mode: ResolutionMode,
    conditions: &[&str],
-    mode: NodeResolutionMode,
+    resolution_kind: NodeResolutionKind,
  ) -> Result<Url, PackageResolveError> {
    let (package_name, package_subpath, _is_scoped) =
      parse_npm_pkg_name(specifier, referrer)?;
@ -1061,9 +1069,9 @@ impl<TEnv: NodeResolverEnv> NodeResolver<TEnv> {
              &package_subpath,
              exports,
              Some(referrer),
-              referrer_kind,
+              resolution_mode,
              conditions,
-              mode,
+              resolution_kind,
            )
            .map_err(|err| err.into());
        }
@ -1074,9 +1082,9 @@ impl<TEnv: NodeResolverEnv> NodeResolver<TEnv> {
      &package_name,
      &package_subpath,
      referrer,
-      referrer_kind,
+      resolution_mode,
      conditions,
-      mode,
+      resolution_kind,
    )
  }
@ -1086,28 +1094,28 @@ impl<TEnv: NodeResolverEnv> NodeResolver<TEnv> {
    package_name: &str,
    package_subpath: &str,
    referrer: &Url,
-    referrer_kind: NodeModuleKind,
+    resolution_mode: ResolutionMode,
    conditions: &[&str],
-    mode: NodeResolutionMode,
+    resolution_kind: NodeResolutionKind,
  ) -> Result<Url, PackageResolveError> {
    let result = self.resolve_package_subpath_for_package_inner(
      package_name,
      package_subpath,
      referrer,
-      referrer_kind,
+      resolution_mode,
      conditions,
-      mode,
+      resolution_kind,
    );
-    if mode.is_types() && !matches!(result, Ok(Url { .. })) {
+    if resolution_kind.is_types() && !matches!(result, Ok(Url { .. })) {
      // try to resolve with the @types package
      let package_name = types_package_name(package_name);
      if let Ok(result) = self.resolve_package_subpath_for_package_inner(
        &package_name,
        package_subpath,
        referrer,
-        referrer_kind,
+        resolution_mode,
        conditions,
-        mode,
+        resolution_kind,
      ) {
        return Ok(result);
      }
@ -1121,9 +1129,9 @@ impl<TEnv: NodeResolverEnv> NodeResolver<TEnv> {
    package_name: &str,
    package_subpath: &str,
    referrer: &Url,
-    referrer_kind: NodeModuleKind,
+    resolution_mode: ResolutionMode,
    conditions: &[&str],
-    mode: NodeResolutionMode,
+    resolution_kind: NodeResolutionKind,
  ) -> Result<Url, PackageResolveError> {
    let package_dir_path = self
      .npm_pkg_folder_resolver
@ -1148,9 +1156,9 @@ impl<TEnv: NodeResolverEnv> NodeResolver<TEnv> {
        &package_dir_path,
        package_subpath,
        Some(referrer),
-        referrer_kind,
+        resolution_mode,
        conditions,
-        mode,
+        resolution_kind,
      )
      .map_err(|err| err.into())
  }
@ -1161,9 +1169,9 @@ impl<TEnv: NodeResolverEnv> NodeResolver<TEnv> {
    package_dir_path: &Path,
    package_subpath: &str,
    maybe_referrer: Option<&Url>,
-    referrer_kind: NodeModuleKind,
+    resolution_mode: ResolutionMode,
    conditions: &[&str],
-    mode: NodeResolutionMode,
+    resolution_kind: NodeResolutionKind,
  ) -> Result<Url, PackageSubpathResolveError> {
    let package_json_path = package_dir_path.join("package.json");
    match self
@ -1174,17 +1182,17 @@ impl<TEnv: NodeResolverEnv> NodeResolver<TEnv> {
        &pkg_json,
        package_subpath,
        maybe_referrer,
-        referrer_kind,
+        resolution_mode,
        conditions,
-        mode,
+        resolution_kind,
      ),
      None => self
        .resolve_package_subpath_no_pkg_json(
          package_dir_path,
          package_subpath,
          maybe_referrer,
-          referrer_kind,
+          resolution_mode,
-          mode,
+          resolution_kind,
        )
        .map_err(|err| {
          PackageSubpathResolveErrorKind::LegacyResolve(err).into()
@ -1198,9 +1206,9 @@ impl<TEnv: NodeResolverEnv> NodeResolver<TEnv> {
    package_json: &PackageJson,
    package_subpath: &str,
    referrer: Option<&Url>,
-    referrer_kind: NodeModuleKind,
+    resolution_mode: ResolutionMode,
    conditions: &[&str],
-    mode: NodeResolutionMode,
+    resolution_kind: NodeResolutionKind,
  ) -> Result<Url, PackageSubpathResolveError> {
    if let Some(exports) = &package_json.exports {
      let result = self.package_exports_resolve(
@ -1208,16 +1216,21 @@ impl<TEnv: NodeResolverEnv> NodeResolver<TEnv> {
        package_subpath,
        exports,
        referrer,
-        referrer_kind,
+        resolution_mode,
        conditions,
-        mode,
+        resolution_kind,
      );
      match result {
        Ok(found) => return Ok(found),
        Err(exports_err) => {
-          if mode.is_types() && package_subpath == "." {
+          if resolution_kind.is_types() && package_subpath == "." {
            return self
-              .legacy_main_resolve(package_json, referrer, referrer_kind, mode)
+              .legacy_main_resolve(
                package_json,
                referrer,
                resolution_mode,
                resolution_kind,
              )
              .map_err(|err| {
                PackageSubpathResolveErrorKind::LegacyResolve(err).into()
              });
@ -1231,7 +1244,12 @@ impl<TEnv: NodeResolverEnv> NodeResolver<TEnv> {
    if package_subpath == "." {
      return self
-        .legacy_main_resolve(package_json, referrer, referrer_kind, mode)
+        .legacy_main_resolve(
          package_json,
          referrer,
          resolution_mode,
          resolution_kind,
        )
        .map_err(|err| {
          PackageSubpathResolveErrorKind::LegacyResolve(err).into()
        });
@ -1242,8 +1260,8 @@ impl<TEnv: NodeResolverEnv> NodeResolver<TEnv> {
        package_json.path.parent().unwrap(),
        package_subpath,
        referrer,
-        referrer_kind,
+        resolution_mode,
-        mode,
+        resolution_kind,
      )
      .map_err(|err| {
        PackageSubpathResolveErrorKind::LegacyResolve(err.into()).into()
@ -1255,13 +1273,13 @@ impl<TEnv: NodeResolverEnv> NodeResolver<TEnv> {
    directory: &Path,
    package_subpath: &str,
    referrer: Option<&Url>,
-    referrer_kind: NodeModuleKind,
+    resolution_mode: ResolutionMode,
-    mode: NodeResolutionMode,
+    resolution_kind: NodeResolutionKind,
  ) -> Result<Url, TypesNotFoundError> {
    assert_ne!(package_subpath, ".");
    let file_path = directory.join(package_subpath);
-    if mode.is_types() {
+    if resolution_kind.is_types() {
-      Ok(self.path_to_declaration_url(&file_path, referrer, referrer_kind)?)
+      Ok(self.path_to_declaration_url(&file_path, referrer, resolution_mode)?)
    } else {
      Ok(url_from_file_path(&file_path).unwrap())
    }
@ -1272,19 +1290,24 @@ impl<TEnv: NodeResolverEnv> NodeResolver<TEnv> {
    directory: &Path,
    package_subpath: &str,
    maybe_referrer: Option<&Url>,
-    referrer_kind: NodeModuleKind,
+    resolution_mode: ResolutionMode,
-    mode: NodeResolutionMode,
+    resolution_kind: NodeResolutionKind,
  ) -> Result<Url, LegacyResolveError> {
    if package_subpath == "." {
-      self.legacy_index_resolve(directory, maybe_referrer, referrer_kind, mode)
+      self.legacy_index_resolve(
        directory,
        maybe_referrer,
        resolution_mode,
        resolution_kind,
      )
    } else {
      self
        .resolve_subpath_exact(
          directory,
          package_subpath,
          maybe_referrer,
-          referrer_kind,
+          resolution_mode,
-          mode,
+          resolution_kind,
        )
        .map_err(|err| err.into())
    }
@ -1294,21 +1317,25 @@ impl<TEnv: NodeResolverEnv> NodeResolver<TEnv> {
    &self,
    package_json: &PackageJson,
    maybe_referrer: Option<&Url>,
-    referrer_kind: NodeModuleKind,
+    resolution_mode: ResolutionMode,
-    mode: NodeResolutionMode,
+    resolution_kind: NodeResolutionKind,
  ) -> Result<Url, LegacyResolveError> {
-    let maybe_main = if mode.is_types() {
+    let pkg_json_kind = match resolution_mode {
      ResolutionMode::Require => deno_package_json::NodeModuleKind::Cjs,
      ResolutionMode::Import => deno_package_json::NodeModuleKind::Esm,
    };
    let maybe_main = if resolution_kind.is_types() {
      match package_json.types.as_ref() {
        Some(types) => Some(types.as_str()),
        None => {
          // fallback to checking the main entrypoint for
          // a corresponding declaration file
-          if let Some(main) = package_json.main(referrer_kind) {
+          if let Some(main) = package_json.main(pkg_json_kind) {
            let main = package_json.path.parent().unwrap().join(main).clean();
            let decl_url_result = self.path_to_declaration_url(
              &main,
              maybe_referrer,
-              referrer_kind,
+              resolution_mode,
            );
            // don't surface errors, fallback to checking the index now
            if let Ok(url) = decl_url_result {
@ -1319,7 +1346,7 @@ impl<TEnv: NodeResolverEnv> NodeResolver<TEnv> {
        }
      }
    } else {
-      package_json.main(referrer_kind)
+      package_json.main(pkg_json_kind)
    };
    if let Some(main) = maybe_main {
@ -1329,12 +1356,12 @@ impl<TEnv: NodeResolverEnv> NodeResolver<TEnv> {
      }
      // todo(dsherret): investigate exactly how node and typescript handles this
-      let endings = if mode.is_types() {
+      let endings = if resolution_kind.is_types() {
-        match referrer_kind {
+        match resolution_mode {
-          NodeModuleKind::Cjs => {
+          ResolutionMode::Require => {
            vec![".d.ts", ".d.cts", "/index.d.ts", "/index.d.cts"]
          }
-          NodeModuleKind::Esm => vec![
+          ResolutionMode::Import => vec![
            ".d.ts",
            ".d.mts",
            "/index.d.ts",
@ -1363,8 +1390,8 @@ impl<TEnv: NodeResolverEnv> NodeResolver<TEnv> {
    self.legacy_index_resolve(
      package_json.path.parent().unwrap(),
      maybe_referrer,
-      referrer_kind,
+      resolution_mode,
-      mode,
+      resolution_kind,
    )
  }
@ -1372,14 +1399,16 @@ impl<TEnv: NodeResolverEnv> NodeResolver<TEnv> {
    &self,
    directory: &Path,
    maybe_referrer: Option<&Url>,
-    referrer_kind: NodeModuleKind,
+    resolution_mode: ResolutionMode,
-    mode: NodeResolutionMode,
+    resolution_kind: NodeResolutionKind,
  ) -> Result<Url, LegacyResolveError> {
-    let index_file_names = if mode.is_types() {
+    let index_file_names = if resolution_kind.is_types() {
      // todo(dsherret): investigate exactly how typescript does this
-      match referrer_kind {
+      match resolution_mode {
-        NodeModuleKind::Cjs => vec!["index.d.ts", "index.d.cts"],
+        ResolutionMode::Require => vec!["index.d.ts", "index.d.cts"],
-        NodeModuleKind::Esm => vec!["index.d.ts", "index.d.mts", "index.d.cts"],
+        ResolutionMode::Import => {
          vec!["index.d.ts", "index.d.mts", "index.d.cts"]
        }
      }
    } else {
      vec!["index.js"]
@ -1392,7 +1421,7 @@ impl<TEnv: NodeResolverEnv> NodeResolver<TEnv> {
      }
    }
-    if mode.is_types() {
+    if resolution_kind.is_types() {
      Err(
        TypesNotFoundError(Box::new(TypesNotFoundErrorData {
          code_specifier: url_from_file_path(&directory.join("index.js"))
--- a/runtime/Cargo.toml
+++ b/runtime/Cargo.toml
@ -90,6 +90,7 @@ deno_net.workspace = true
 deno_node.workspace = true
 deno_path_util.workspace = true
 deno_permissions.workspace = true
 deno_telemetry.workspace = true
 deno_terminal.workspace = true
 deno_tls.workspace = true
 deno_url.workspace = true
@ -100,7 +101,6 @@ deno_websocket.workspace = true
 deno_webstorage.workspace = true
 node_resolver = { workspace = true, features = ["sync"] }
 async-trait.workspace = true
 color-print.workspace = true
 dlopen2.workspace = true
 encoding_rs.workspace = true
@ -115,13 +115,7 @@ log.workspace = true
 netif = "0.1.6"
 notify.workspace = true
 once_cell.workspace = true
 opentelemetry.workspace = true
 opentelemetry-http.workspace = true
 opentelemetry-otlp.workspace = true
 opentelemetry-semantic-conventions.workspace = true
 opentelemetry_sdk.workspace = true
 percent-encoding.workspace = true
 pin-project.workspace = true
 regex.workspace = true
 rustyline = { workspace = true, features = ["custom-bindings"] }
 same-file = "1.0.6"
--- a/runtime/js/90_deno_ns.js
+++ b/runtime/js/90_deno_ns.js
@ -29,7 +29,7 @@ import * as tty from "ext:runtime/40_tty.js";
 import * as kv from "ext:deno_kv/01_db.ts";
 import * as cron from "ext:deno_cron/01_cron.ts";
 import * as webgpuSurface from "ext:deno_webgpu/02_surface.js";
-import * as telemetry from "ext:runtime/telemetry.ts";
+import * as telemetry from "ext:deno_telemetry/telemetry.ts";
 const denoNs = {
  Process: process.Process,
--- a/runtime/js/99_main.js
+++ b/runtime/js/99_main.js
@ -86,7 +86,7 @@ import {
  workerRuntimeGlobalProperties,
 } from "ext:runtime/98_global_scope_worker.js";
 import { SymbolDispose, SymbolMetadata } from "ext:deno_web/00_infra.js";
-import { bootstrap as bootstrapOtel } from "ext:runtime/telemetry.ts";
+import { bootstrap as bootstrapOtel } from "ext:deno_telemetry/telemetry.ts";
 // deno-lint-ignore prefer-primordials
 if (Symbol.metadata) {
--- a/runtime/lib.rs
+++ b/runtime/lib.rs
@ -148,7 +148,7 @@ pub static UNSTABLE_GRANULAR_FLAGS: &[UnstableGranularFlag] = &[
 ];
 pub fn exit(code: i32) -> ! {
-  crate::ops::otel::flush();
+  deno_telemetry::flush();
  #[allow(clippy::disallowed_methods)]
  std::process::exit(code);
 }
--- a/runtime/ops/fs_events.rs
+++ b/runtime/ops/fs_events.rs
@ -109,6 +109,14 @@ fn starts_with_canonicalized(path: &Path, prefix: &str) -> bool {
  }
 }
 fn is_file_removed(event_path: &PathBuf) -> bool {
  let exists_path = std::fs::exists(event_path);
  match exists_path {
    Ok(res) => !res,
    Err(_) => false,
  }
 }
 #[derive(Debug, thiserror::Error)]
 pub enum FsEventsError {
  #[error(transparent)]
@ -150,6 +158,13 @@ fn start_watcher(
            })
          }) {
            let _ = sender.try_send(Ok(event.clone()));
          } else if event.paths.iter().any(is_file_removed) {
            let remove_event = FsEvent {
              kind: "remove",
              paths: event.paths.clone(),
              flag: None,
            };
            let _ = sender.try_send(Ok(remove_event));
          }
        }
      }
--- a/runtime/ops/mod.rs
+++ b/runtime/ops/mod.rs
@ -4,7 +4,6 @@ pub mod bootstrap;
 pub mod fs_events;
 pub mod http;
 pub mod os;
 pub mod otel;
 pub mod permissions;
 pub mod process;
 pub mod runtime;
--- a/runtime/shared.rs
+++ b/runtime/shared.rs
@ -47,7 +47,6 @@ extension!(runtime,
    "40_signals.js",
    "40_tty.js",
    "41_prompt.js",
    "telemetry.ts",
    "90_deno_ns.js",
    "98_global_scope_shared.js",
    "98_global_scope_window.js",
--- a/runtime/snapshot.rs
+++ b/runtime/snapshot.rs
@ -268,6 +268,7 @@ pub fn create_runtime_snapshot(
  // `runtime/worker.rs`, `runtime/web_worker.rs` and `runtime/snapshot.rs`!
  let fs = std::sync::Arc::new(deno_fs::RealFs);
  let mut extensions: Vec<Extension> = vec![
    deno_telemetry::deno_telemetry::init_ops_and_esm(),
    deno_webidl::deno_webidl::init_ops_and_esm(),
    deno_console::deno_console::init_ops_and_esm(),
    deno_url::deno_url::init_ops_and_esm(),
@ -314,7 +315,6 @@ pub fn create_runtime_snapshot(
    ),
    ops::fs_events::deno_fs_events::init_ops(),
    ops::os::deno_os::init_ops(Default::default()),
    ops::otel::deno_otel::init_ops(),
    ops::permissions::deno_permissions::init_ops(),
    ops::process::deno_process::init_ops(None),
    ops::signal::deno_signal::init_ops(),
--- a/runtime/web_worker.rs
+++ b/runtime/web_worker.rs
@ -440,6 +440,7 @@ impl WebWorker {
    // `runtime/worker.rs` and `runtime/snapshot.rs`!
    let mut extensions = vec![
      deno_telemetry::deno_telemetry::init_ops_and_esm(),
      // Web APIs
      deno_webidl::deno_webidl::init_ops_and_esm(),
      deno_console::deno_console::init_ops_and_esm(),
@ -517,7 +518,6 @@ impl WebWorker {
      ),
      ops::fs_events::deno_fs_events::init_ops_and_esm(),
      ops::os::deno_os_worker::init_ops_and_esm(),
      ops::otel::deno_otel::init_ops_and_esm(),
      ops::permissions::deno_permissions::init_ops_and_esm(),
      ops::process::deno_process::init_ops_and_esm(
        services.npm_process_state_provider,
--- a/runtime/worker.rs
+++ b/runtime/worker.rs
@ -348,6 +348,7 @@ impl MainWorker {
    // NOTE(bartlomieju): ordering is important here, keep it in sync with
    // `runtime/web_worker.rs` and `runtime/snapshot.rs`!
    let mut extensions = vec![
      deno_telemetry::deno_telemetry::init_ops_and_esm(),
      // Web APIs
      deno_webidl::deno_webidl::init_ops_and_esm(),
      deno_console::deno_console::init_ops_and_esm(),
@ -428,7 +429,6 @@ impl MainWorker {
      ),
      ops::fs_events::deno_fs_events::init_ops_and_esm(),
      ops::os::deno_os::init_ops_and_esm(exit_code.clone()),
      ops::otel::deno_otel::init_ops_and_esm(),
      ops::permissions::deno_permissions::init_ops_and_esm(),
      ops::process::deno_process::init_ops_and_esm(
        services.npm_process_state_provider,
--- a/runtime/worker_bootstrap.rs
+++ b/runtime/worker_bootstrap.rs
@ -1,8 +1,8 @@
 // Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
 use crate::ops::otel::OtelConfig;
 use deno_core::v8;
 use deno_core::ModuleSpecifier;
 use deno_telemetry::OtelConfig;
 use serde::Serialize;
 use std::cell::RefCell;
 use std::thread;
--- a/tests/integration/lsp_tests.rs
+++ b/tests/integration/lsp_tests.rs
@ -1360,26 +1360,31 @@ fn lsp_deno_task() {
  let temp_dir = context.temp_dir();
  temp_dir.write(
    "deno.jsonc",
-    r#"{
+    json!({
-    "tasks": {
+      "tasks": {
-      "build": "deno test"
+        "build": "deno test",
-    }
+        "serve": {
-  }"#,
+          "description": "Start the dev server",
          "command": "deno run -RN server.ts",
        },
      },
    })
    .to_string(),
  );
  let mut client = context.new_lsp_command().build();
-  client.initialize(|builder| {
+  client.initialize_default();
-    builder.set_config("./deno.jsonc");
+  let res = client.write_request("deno/taskDefinitions", json!(null));
  });
  let res = client.write_request("deno/task", json!(null));
  assert_eq!(
    res,
    json!([
      {
        "name": "build",
-        "detail": "deno test",
+        "command": "deno test",
        "sourceUri": temp_dir.url().join("deno.jsonc").unwrap(),
      },
      {
        "name": "serve",
        "command": "deno run -RN server.ts",
        "sourceUri": temp_dir.url().join("deno.jsonc").unwrap(),
      }
    ])
--- a/tests/node_compat/common.ts
+++ b/tests/node_compat/common.ts
@ -12,7 +12,6 @@ import * as JSONC from "@std/jsonc";
 type TestSuites = Record<string, string[]>;
 interface Config {
  nodeVersion: string;
  /** Ignored files won't regenerated by the update script */
  ignore: TestSuites;
  /**
--- a/tests/node_compat/config.jsonc
+++ b/tests/node_compat/config.jsonc
@ -1,5 +1,4 @@
 {
  "nodeVersion": "18.12.1",
  "ignore": {
    "common": ["index.js", "internet.js"],
    "fixtures": [
--- a/tests/node_compat/runner/TODO.md
+++ b/tests/node_compat/runner/TODO.md
--- a/tests/node_compat/runner/setup.ts
+++ b/tests/node_compat/runner/setup.ts
@ -11,12 +11,13 @@ import { ensureFile } from "@std/fs/ensure-file";
 import { writeAll } from "@std/io/write-all";
 import { withoutAll } from "@std/collections/without-all";
 import { relative } from "@std/path/posix/relative";
 import { version } from "./suite/node_version.ts";
 import { config, ignoreList } from "../common.ts";
 const encoder = new TextEncoder();
-const NODE_VERSION = config.nodeVersion;
+const NODE_VERSION = version;
 const NODE_IGNORED_TEST_DIRS = [
  "addons",
@ -73,15 +74,24 @@ async function updateToDo() {
    truncate: true,
  });
-  const missingTests = withoutAll(await getNodeTests(), await getDenoTests());
+  const nodeTests = await getNodeTests();
  const portedTests = getDenoTests();
  const remainingTests = withoutAll(nodeTests, portedTests);
  const numPorted = portedTests.length;
  const numMissing = remainingTests.length;
  const numTotal = nodeTests.length;
  const portedPercentage = (numPorted / numTotal * 100).toFixed(2);
  const remainingPercentage = (numMissing / numTotal * 100).toFixed(2);
  await file.write(encoder.encode(`<!-- deno-fmt-ignore-file -->
 # Remaining Node Tests
 ${numPorted} tests out of ${numTotal} have been ported from Node ${NODE_VERSION} (${portedPercentage}% ported, ${remainingPercentage}% remaining).
 NOTE: This file should not be manually edited. Please edit \`tests/node_compat/config.json\` and run \`deno task setup\` in \`tests/node_compat/runner\` dir instead.
 `));
-  for (const test of missingTests) {
+  for (const test of remainingTests) {
    await file.write(
      encoder.encode(
        `- [${test}](https://github.com/nodejs/node/tree/v${NODE_VERSION}/test/${test})\n`,
--- a/tests/node_compat/runner/suite
+++ b/tests/node_compat/runner/suite
@ -1 +1 @@
-Subproject commit d12a68fc4930062c0bed26447a6b5245697e77c1
+Subproject commit 1c9511e584eb9d465bcd4b1e6c05ecedf7f15549
--- a/tests/node_compat/test/common/child_process.js
+++ b/tests/node_compat/test/common/child_process.js
@ -2,7 +2,7 @@
 // deno-lint-ignore-file
 // Copyright Joyent and Node contributors. All rights reserved. MIT license.
-// Taken from Node 18.12.1
+// Taken from Node 20.11.1
 // This file is automatically generated by `tests/node_compat/runner/setup.ts`. Do not modify this file manually.
 'use strict';
--- a/tests/node_compat/test/common/countdown.js
+++ b/tests/node_compat/test/common/countdown.js
@ -2,7 +2,7 @@
 // deno-lint-ignore-file
 // Copyright Joyent and Node contributors. All rights reserved. MIT license.
-// Taken from Node 18.12.1
+// Taken from Node 20.11.1
 // This file is automatically generated by `tests/node_compat/runner/setup.ts`. Do not modify this file manually.
 'use strict';
--- a/tests/node_compat/test/common/dns.js
+++ b/tests/node_compat/test/common/dns.js
@ -2,7 +2,7 @@
 // deno-lint-ignore-file
 // Copyright Joyent and Node contributors. All rights reserved. MIT license.
-// Taken from Node 18.12.1
+// Taken from Node 20.11.1
 // This file is automatically generated by `tests/node_compat/runner/setup.ts`. Do not modify this file manually.
 'use strict';
--- a/tests/node_compat/test/common/duplexpair.js
+++ b/tests/node_compat/test/common/duplexpair.js
@ -2,7 +2,7 @@
 // deno-lint-ignore-file
 // Copyright Joyent and Node contributors. All rights reserved. MIT license.
-// Taken from Node 18.12.1
+// Taken from Node 20.11.1
 // This file is automatically generated by `tests/node_compat/runner/setup.ts`. Do not modify this file manually.
 'use strict';
--- a/tests/node_compat/test/common/fixtures.js
+++ b/tests/node_compat/test/common/fixtures.js
@ -2,7 +2,7 @@
 // deno-lint-ignore-file
 // Copyright Joyent and Node contributors. All rights reserved. MIT license.
-// Taken from Node 18.12.1
+// Taken from Node 20.11.1
 // This file is automatically generated by `tests/node_compat/runner/setup.ts`. Do not modify this file manually.
 'use strict';
--- a/tests/node_compat/test/common/hijackstdio.js
+++ b/tests/node_compat/test/common/hijackstdio.js
@ -2,7 +2,7 @@
 // deno-lint-ignore-file
 // Copyright Joyent and Node contributors. All rights reserved. MIT license.
-// Taken from Node 18.12.1
+// Taken from Node 20.11.1
 // This file is automatically generated by `tests/node_compat/runner/setup.ts`. Do not modify this file manually.
 'use strict';
--- a/tests/node_compat/test/common/index.mjs
+++ b/tests/node_compat/test/common/index.mjs
@ -2,7 +2,7 @@
 // deno-lint-ignore-file
 // Copyright Joyent and Node contributors. All rights reserved. MIT license.
-// Taken from Node 18.12.1
+// Taken from Node 20.11.1
 // This file is automatically generated by `tests/node_compat/runner/setup.ts`. Do not modify this file manually.
 import { createRequire } from 'module';
--- a/tests/node_compat/test/common/tmpdir.js
+++ b/tests/node_compat/test/common/tmpdir.js
@ -2,7 +2,7 @@
 // deno-lint-ignore-file
 // Copyright Joyent and Node contributors. All rights reserved. MIT license.
-// Taken from Node 18.12.1
+// Taken from Node 20.11.1
 // This file is automatically generated by `tests/node_compat/runner/setup.ts`. Do not modify this file manually.
 'use strict';
--- a/tests/node_compat/test/fixtures/GH-1899-output.js
+++ b/tests/node_compat/test/fixtures/GH-1899-output.js
@ -2,7 +2,7 @@
 // deno-lint-ignore-file
 // Copyright Joyent and Node contributors. All rights reserved. MIT license.
-// Taken from Node 18.12.1
+// Taken from Node 20.11.1
 // This file is automatically generated by `tests/node_compat/runner/setup.ts`. Do not modify this file manually.
 // Copyright Joyent, Inc. and other Node contributors.
--- a/tests/node_compat/test/fixtures/a.js
+++ b/tests/node_compat/test/fixtures/a.js
@ -2,7 +2,7 @@
 // deno-lint-ignore-file
 // Copyright Joyent and Node contributors. All rights reserved. MIT license.
-// Taken from Node 18.12.1
+// Taken from Node 20.11.1
 // This file is automatically generated by `tests/node_compat/runner/setup.ts`. Do not modify this file manually.
 // Copyright Joyent, Inc. and other Node contributors.
--- a/tests/node_compat/test/fixtures/child-process-persistent.js
+++ b/tests/node_compat/test/fixtures/child-process-persistent.js
@ -2,7 +2,7 @@
 // deno-lint-ignore-file
 // Copyright Joyent and Node contributors. All rights reserved. MIT license.
-// Taken from Node 18.12.1
+// Taken from Node 20.11.1
 // This file is automatically generated by `tests/node_compat/runner/setup.ts`. Do not modify this file manually.
 setInterval(function() {}, 9999);
--- a/tests/node_compat/test/fixtures/child_process_should_emit_error.js
+++ b/tests/node_compat/test/fixtures/child_process_should_emit_error.js
@ -2,7 +2,7 @@
 // deno-lint-ignore-file
 // Copyright Joyent and Node contributors. All rights reserved. MIT license.
-// Taken from Node 18.12.1
+// Taken from Node 20.11.1
 // This file is automatically generated by `tests/node_compat/runner/setup.ts`. Do not modify this file manually.
 // Copyright Joyent, Inc. and other Node contributors.
--- a/tests/node_compat/test/fixtures/loop.js
+++ b/tests/node_compat/test/fixtures/loop.js
@ -2,7 +2,7 @@
 // deno-lint-ignore-file
 // Copyright Joyent and Node contributors. All rights reserved. MIT license.
-// Taken from Node 18.12.1
+// Taken from Node 20.11.1
 // This file is automatically generated by `tests/node_compat/runner/setup.ts`. Do not modify this file manually.
 var t = 1;
--- a/tests/node_compat/test/internet/test-dns-idna2008.js
+++ b/tests/node_compat/test/internet/test-dns-idna2008.js
@ -2,7 +2,7 @@
 // deno-lint-ignore-file
 // Copyright Joyent and Node contributors. All rights reserved. MIT license.
-// Taken from Node 18.12.1
+// Taken from Node 20.11.1
 // This file is automatically generated by `tests/node_compat/runner/setup.ts`. Do not modify this file manually.
 'use strict';
--- a/tests/node_compat/test/internet/test-dns-lookup.js
+++ b/tests/node_compat/test/internet/test-dns-lookup.js
@ -2,7 +2,7 @@
 // deno-lint-ignore-file
 // Copyright Joyent and Node contributors. All rights reserved. MIT license.
-// Taken from Node 18.12.1
+// Taken from Node 20.11.1
 // This file is automatically generated by `tests/node_compat/runner/setup.ts`. Do not modify this file manually.
 'use strict';
--- a/tests/node_compat/test/internet/test-dns-promises-resolve.js
+++ b/tests/node_compat/test/internet/test-dns-promises-resolve.js
@ -2,7 +2,7 @@
 // deno-lint-ignore-file
 // Copyright Joyent and Node contributors. All rights reserved. MIT license.
-// Taken from Node 18.12.1
+// Taken from Node 20.11.1
 // This file is automatically generated by `tests/node_compat/runner/setup.ts`. Do not modify this file manually.
 'use strict';
--- a/tests/node_compat/test/internet/test-dns-regress-6244.js
+++ b/tests/node_compat/test/internet/test-dns-regress-6244.js
@ -2,7 +2,7 @@
 // deno-lint-ignore-file
 // Copyright Joyent and Node contributors. All rights reserved. MIT license.
-// Taken from Node 18.12.1
+// Taken from Node 20.11.1
 // This file is automatically generated by `tests/node_compat/runner/setup.ts`. Do not modify this file manually.
 // Copyright Joyent, Inc. and other Node contributors.
--- a/tests/node_compat/test/internet/test-dns-setserver-in-callback-of-resolve4.js
+++ b/tests/node_compat/test/internet/test-dns-setserver-in-callback-of-resolve4.js
@ -2,7 +2,7 @@
 // deno-lint-ignore-file
 // Copyright Joyent and Node contributors. All rights reserved. MIT license.
-// Taken from Node 18.12.1
+// Taken from Node 20.11.1
 // This file is automatically generated by `tests/node_compat/runner/setup.ts`. Do not modify this file manually.
 'use strict';
--- a/tests/node_compat/test/internet/test-http-https-default-ports.js
+++ b/tests/node_compat/test/internet/test-http-https-default-ports.js
@ -2,7 +2,7 @@
 // deno-lint-ignore-file
 // Copyright Joyent and Node contributors. All rights reserved. MIT license.
-// Taken from Node 18.12.1
+// Taken from Node 20.11.1
 // This file is automatically generated by `tests/node_compat/runner/setup.ts`. Do not modify this file manually.
 // Copyright Joyent, Inc. and other Node contributors.
--- a/tests/node_compat/test/parallel/test-assert-async.js
+++ b/tests/node_compat/test/parallel/test-assert-async.js
@ -2,7 +2,7 @@
 // deno-lint-ignore-file
 // Copyright Joyent and Node contributors. All rights reserved. MIT license.
-// Taken from Node 18.12.1
+// Taken from Node 20.11.1
 // This file is automatically generated by `tests/node_compat/runner/setup.ts`. Do not modify this file manually.
 'use strict';
--- a/Show more
+++ b/Show more
		`@ -0,0 +1,3 @@`
							# `deno_telemetry`

							`This crate implements telemetry for Deno using OpenTelemetry.`
		`@ -1 +1 @@`
			`Subproject commit d12a68fc4930062c0bed26447a6b5245697e77c1`				`Subproject commit 1c9511e584eb9d465bcd4b1e6c05ecedf7f15549`