Merge remote-tracking branch 'origin/main' into err-msg-ext-fs

fix(publish): error on missing name field (#27131 )
This PR improves the error output on publish when the `name` filed is missing: ```json { "exports": "./mod.ts", "version": "0.0.1" } ``` Before: ```sh deno publish --dry-run error: You did not specify an entrypoint in file:///Users/marvinh/dev/test/deno-pkg-timers/deno.json. Add `exports` mapping in the configuration file, eg: { "name": "@scope/name", "version": "0.0.0", "exports": "<path_to_entrypoint>" } ``` After: ```sh deno publish --dry-run error: Missing 'name' field in 'file:///Users/marvinh/dev/test/deno-pkg-timers/deno.json'. ``` Fixes https://github.com/denoland/deno/issues/27116
2025-02-01 12:16:11 -05:00 · 2024-11-28 10:10:47 -08:00 · 2024-11-28 18:11:36 +01:00 · 2024-11-28 17:00:24 +00:00 · 2024-11-28 08:38:46 -08:00 · 2024-11-28 15:11:51 +01:00
2035 changed files with 18786 additions and 14670 deletions
--- a/.dprint.json
+++ b/.dprint.json
@ -31,6 +31,8 @@
    "cli/tsc/dts/lib.scripthost.d.ts",
    "cli/tsc/dts/lib.webworker*.d.ts",
    "cli/tsc/dts/typescript.d.ts",
+    "cli/tools/doc/prism.css",
+    "cli/tools/doc/prism.js",
    "ext/websocket/autobahn/reports",
    "gh-pages",
    "target",
--- a/.github/workflows/ci.generate.ts
+++ b/.github/workflows/ci.generate.ts
@ -5,7 +5,7 @@ import { stringify } from "jsr:@std/yaml@^0.221/stringify";
 // Bump this number when you want to purge the cache.
 // Note: the tools/release/01_bump_crate_versions.ts script will update this version
 // automatically via regex, so ensure that this line maintains this format.
-const cacheVersion = 25;
+const cacheVersion = 28;

 const ubuntuX86Runner = "ubuntu-24.04";
 const ubuntuX86XlRunner = "ubuntu-24.04-xl";
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@ -361,8 +361,8 @@ jobs:
          path: |-
            ~/.cargo/registry/index
            ~/.cargo/registry/cache
-          key: '25-cargo-home-${{ matrix.os }}-${{ matrix.arch }}-${{ hashFiles(''Cargo.lock'') }}'
-          restore-keys: '25-cargo-home-${{ matrix.os }}-${{ matrix.arch }}'
+          key: '28-cargo-home-${{ matrix.os }}-${{ matrix.arch }}-${{ hashFiles(''Cargo.lock'') }}'
+          restore-keys: '28-cargo-home-${{ matrix.os }}-${{ matrix.arch }}'
        if: '!(matrix.skip)'
      - name: Restore cache build output (PR)
        uses: actions/cache/restore@v4
@ -375,7 +375,7 @@ jobs:
            !./target/*/*.zip
            !./target/*/*.tar.gz
          key: never_saved
-          restore-keys: '25-cargo-target-${{ matrix.os }}-${{ matrix.arch }}-${{ matrix.profile }}-${{ matrix.job }}-'
+          restore-keys: '28-cargo-target-${{ matrix.os }}-${{ matrix.arch }}-${{ matrix.profile }}-${{ matrix.job }}-'
      - name: Apply and update mtime cache
        if: '!(matrix.skip) && (!startsWith(github.ref, ''refs/tags/''))'
        uses: ./.github/mtime_cache
@ -685,7 +685,7 @@ jobs:
            !./target/*/*.zip
            !./target/*/*.sha256sum
            !./target/*/*.tar.gz
-          key: '25-cargo-target-${{ matrix.os }}-${{ matrix.arch }}-${{ matrix.profile }}-${{ matrix.job }}-${{ github.sha }}'
+          key: '28-cargo-target-${{ matrix.os }}-${{ matrix.arch }}-${{ matrix.profile }}-${{ matrix.job }}-${{ github.sha }}'
  publish-canary:
    name: publish canary
    runs-on: ubuntu-24.04
--- a/Cargo.lock
+++ b/Cargo.lock
--- 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",
@ -46,19 +47,19 @@ repository = "https://github.com/denoland/deno"

 [workspace.dependencies]
 deno_ast = { version = "=0.43.3", features = ["transpiling"] }
-deno_core = { version = "0.319.0" }
+deno_core = { version = "0.323.0" }

-deno_bench_util = { version = "0.171.0", path = "./bench_util" }
-deno_config = { version = "=0.38.2", features = ["workspace", "sync"] }
+deno_bench_util = { version = "0.174.0", path = "./bench_util" }
+deno_config = { version = "=0.39.2", features = ["workspace", "sync"] }
 deno_lockfile = "=0.23.1"
 deno_media_type = { version = "0.2.0", features = ["module_specifier"] }
 deno_npm = "=0.25.4"
 deno_path_util = "=0.2.1"
-deno_permissions = { version = "0.37.0", path = "./runtime/permissions" }
-deno_runtime = { version = "0.186.0", path = "./runtime" }
+deno_permissions = { version = "0.40.0", path = "./runtime/permissions" }
+deno_runtime = { version = "0.189.0", path = "./runtime" }
 deno_semver = "=0.5.16"
 deno_terminal = "0.2.0"
-napi_sym = { version = "0.107.0", path = "./ext/napi/sym" }
+napi_sym = { version = "0.110.0", path = "./ext/napi/sym" }
 test_util = { package = "test_server", path = "./tests/util/server" }

 denokv_proto = "0.8.4"
@ -67,32 +68,33 @@ denokv_remote = "0.8.4"
 denokv_sqlite = { default-features = false, version = "0.8.4" }

 # exts
-deno_broadcast_channel = { version = "0.171.0", path = "./ext/broadcast_channel" }
-deno_cache = { version = "0.109.0", path = "./ext/cache" }
-deno_canvas = { version = "0.46.0", path = "./ext/canvas" }
-deno_console = { version = "0.177.0", path = "./ext/console" }
-deno_cron = { version = "0.57.0", path = "./ext/cron" }
-deno_crypto = { version = "0.191.0", path = "./ext/crypto" }
-deno_fetch = { version = "0.201.0", path = "./ext/fetch" }
-deno_ffi = { version = "0.164.0", path = "./ext/ffi" }
-deno_fs = { version = "0.87.0", path = "./ext/fs" }
-deno_http = { version = "0.175.0", path = "./ext/http" }
-deno_io = { version = "0.87.0", path = "./ext/io" }
-deno_kv = { version = "0.85.0", path = "./ext/kv" }
-deno_napi = { version = "0.108.0", path = "./ext/napi" }
-deno_net = { version = "0.169.0", path = "./ext/net" }
-deno_node = { version = "0.114.0", path = "./ext/node" }
-deno_tls = { version = "0.164.0", path = "./ext/tls" }
-deno_url = { version = "0.177.0", path = "./ext/url" }
-deno_web = { version = "0.208.0", path = "./ext/web" }
-deno_webgpu = { version = "0.144.0", path = "./ext/webgpu" }
-deno_webidl = { version = "0.177.0", path = "./ext/webidl" }
-deno_websocket = { version = "0.182.0", path = "./ext/websocket" }
-deno_webstorage = { version = "0.172.0", path = "./ext/webstorage" }
+deno_broadcast_channel = { version = "0.174.0", path = "./ext/broadcast_channel" }
+deno_cache = { version = "0.112.0", path = "./ext/cache" }
+deno_canvas = { version = "0.49.0", path = "./ext/canvas" }
+deno_console = { version = "0.180.0", path = "./ext/console" }
+deno_cron = { version = "0.60.0", path = "./ext/cron" }
+deno_crypto = { version = "0.194.0", path = "./ext/crypto" }
+deno_fetch = { version = "0.204.0", path = "./ext/fetch" }
+deno_ffi = { version = "0.167.0", path = "./ext/ffi" }
+deno_fs = { version = "0.90.0", path = "./ext/fs" }
+deno_http = { version = "0.178.0", path = "./ext/http" }
+deno_io = { version = "0.90.0", path = "./ext/io" }
+deno_kv = { version = "0.88.0", path = "./ext/kv" }
+deno_napi = { version = "0.111.0", path = "./ext/napi" }
+deno_net = { version = "0.172.0", path = "./ext/net" }
+deno_node = { version = "0.117.0", path = "./ext/node" }
+deno_telemetry = { version = "0.2.0", path = "./ext/telemetry" }
+deno_tls = { version = "0.167.0", path = "./ext/tls" }
+deno_url = { version = "0.180.0", path = "./ext/url" }
+deno_web = { version = "0.211.0", path = "./ext/web" }
+deno_webgpu = { version = "0.147.0", path = "./ext/webgpu" }
+deno_webidl = { version = "0.180.0", path = "./ext/webidl" }
+deno_websocket = { version = "0.185.0", path = "./ext/websocket" }
+deno_webstorage = { version = "0.175.0", path = "./ext/webstorage" }

 # resolvers
-deno_resolver = { version = "0.9.0", path = "./resolvers/deno" }
-node_resolver = { version = "0.16.0", path = "./resolvers/node" }
+deno_resolver = { version = "0.12.0", path = "./resolvers/deno" }
+node_resolver = { version = "0.19.0", path = "./resolvers/node" }

 aes = "=0.8.3"
 anyhow = "1.0.57"
@ -100,6 +102,7 @@ async-trait = "0.1.73"
 base32 = "=0.5.1"
 base64 = "0.21.7"
 bencher = "0.1"
+boxed_error = "0.2.2"
 brotli = "6.0.0"
 bytes = "1.4.0"
 cache_control = "=0.2.0"
@ -127,6 +130,7 @@ fs3 = "0.5.0"
 futures = "0.3.21"
 glob = "0.3.1"
 h2 = "0.4.4"
+hickory-resolver = { version = "0.24", features = ["tokio-runtime", "serde-config"] }
 http = "1.0"
 http-body = "1.0"
 http-body-util = "0.1.2"
@ -198,8 +202,7 @@ tower-http = { version = "0.6.1", features = ["decompression-br", "decompression
 tower-lsp = { package = "deno_tower_lsp", version = "0.1.0", features = ["proposed"] }
 tower-service = "0.3.2"
 twox-hash = "=1.6.3"
-# Upgrading past 2.4.1 may cause WPT failures
-url = { version = "< 2.5.0", features = ["serde", "expose_internals"] }
+url = { version = "2.5", features = ["serde", "expose_internals"] }
 uuid = { version = "1.3.0", features = ["v4"] }
 webpki-root-certs = "0.26.5"
 webpki-roots = "0.26"
--- a/Releases.md
+++ b/Releases.md
@ -6,6 +6,130 @@ https://github.com/denoland/deno/releases
 We also have one-line install commands at:
 https://github.com/denoland/deno_install

+### 2.1.2 / 2024.11.28
+
+- feat(unstable): Instrument Deno.serve (#26964)
+- feat(unstable): Instrument fetch (#27057)
+- feat(unstable): repurpose `--unstable-detect-cjs` to attempt loading more
+  modules as cjs (#27094)
+- fix(check): support jsdoc `@import` tag (#26991)
+- fix(compile): correct buffered reading of assets and files (#27008)
+- fix(compile): do not error embedding same symlink via multiple methods
+  (#27015)
+- fix(compile): handle TypeScript file included as asset (#27032)
+- fix(ext/fetch): don't throw when `bodyUsed` inspect after upgrade (#27088)
+- fix(ext/node): `tls.connect` socket upgrades (#27125)
+- fix(ext/node): add `fs.promises.fstat` and `FileHandle#stat` (#26719)
+- fix(ext/webgpu): normalize limits to number (#27072)
+- fix(ext/webgpu): use correct variable name (#27108)
+- fix(ext/websocket): don't throw exception when sending to closed socket
+  (#26932)
+- fix(fmt): return `None` if sql fmt result is the same (#27014)
+- fix(info): resolve bare specifier pointing to workspace member (#27020)
+- fix(init): always force managed node modules (#27047)
+- fix(init): support scoped npm packages (#27128)
+- fix(install): don't re-set up node_modules if running lifecycle script
+  (#26984)
+- fix(lsp): remove stray debug output (#27010)
+- fix(lsp): support task object notation for tasks request (#27076)
+- fix(lsp): wasm file import completions (#27018)
+- fix(node): correct resolution of dynamic import of esm from cjs (#27071)
+- fix(node/fs): add missing stat path argument validation (#27086)
+- fix(node/fs): missing uv error context for readFile (#27011)
+- fix(node/http): casing ignored in ServerResponse.hasHeader() (#27105)
+- fix(node/timers): error when passing id to clearTimeout/clearInterval (#27130)
+- fix(runtime/ops): Fix watchfs remove event (#27041)
+- fix(streams): reject `string` in `ReadableStream.from` type (#25116)
+- fix(task): handle carriage return in task description (#27099)
+- fix(task): handle multiline descriptions properly (#27069)
+- fix(task): strip ansi codes and control chars when printing tasks (#27100)
+- fix(tools/doc): HTML resolve main entrypoint from config file (#27103)
+- fix: support bun specifiers in JSR publish (#24588)
+- fix: support non-function exports in Wasm modules (#26992)
+- perf(compile): read embedded files as static references when UTF-8 and reading
+  as strings (#27033)
+- perf(ext/webstorage): use object wrap for `Storage` (#26931)
+
+### 2.1.1 / 2024.11.21
+
+- docs(add): clarification to add command (#26968)
+- docs(doc): fix typo in doc subcommand help output (#26321)
+- fix(node): regression where ts files were sometimes resolved instead of js
+  (#26971)
+- fix(task): ensure root config always looks up dependencies in root (#26959)
+- fix(watch): don't panic if there's no path provided (#26972)
+- fix: Buffer global in --unstable-node-globals (#26973)
+
+### 2.1.0 / 2024.11.21
+
+- feat(cli): add `--unstable-node-globals` flag (#26617)
+- feat(cli): support multiple env file argument (#26527)
+- feat(compile): ability to embed directory in executable (#26939)
+- feat(compile): ability to embed local data files (#26934)
+- feat(ext/fetch): Make fetch client parameters configurable (#26909)
+- feat(ext/fetch): allow embedders to use `hickory_dns_resolver` instead of
+  default `GaiResolver` (#26740)
+- feat(ext/fs): add ctime to Deno.stats and use it in node compat layer (#24801)
+- feat(ext/http): Make http server parameters configurable (#26785)
+- feat(ext/node): perf_hooks.monitorEventLoopDelay() (#26905)
+- feat(fetch): accept async iterables for body (#26882)
+- feat(fmt): support SQL (#26750)
+- feat(info): show location for Web Cache (#26205)
+- feat(init): add --npm flag to initialize npm projects (#26896)
+- feat(jupyter): Add `Deno.jupyter.image` API (#26284)
+- feat(lint): Add checked files list to the JSON output(#26936)
+- feat(lsp): auto-imports with @deno-types directives (#26821)
+- feat(node): stabilize detecting if CJS via `"type": "commonjs"` in a
+  package.json (#26439)
+- feat(permission): support suffix wildcards in `--allow-env` flag (#25255)
+- feat(publish): add `--set-version <version>` flag (#26141)
+- feat(runtime): remove public OTEL trace API (#26854)
+- feat(task): add --eval flag (#26943)
+- feat(task): dependencies (#26467)
+- feat(task): support object notation, remove support for JSDocs (#26886)
+- feat(task): workspace support with --filter and --recursive (#26949)
+- feat(watch): log which file changed on HMR or watch change (#25801)
+- feat: OpenTelemetry Tracing API and Exporting (#26710)
+- feat: Wasm module support (#26668)
+- feat: fmt and lint respect .gitignore file (#26897)
+- feat: permission stack traces in ops (#26938)
+- feat: subcommand to view and update outdated dependencies (#26942)
+- feat: upgrade V8 to 13.0 (#26851)
+- fix(cli): preserve comments in doc tests (#26828)
+- fix(cli): show prefix hint when installing a package globally (#26629)
+- fix(ext/cache): gracefully error when cache creation failed (#26895)
+- fix(ext/http): prefer brotli for `accept-encoding: gzip, deflate, br, zstd`
+  (#26814)
+- fix(ext/node): New async setInterval function to improve the nodejs
+  compatibility (#26703)
+- fix(ext/node): add autoSelectFamily option to net.createConnection (#26661)
+- fix(ext/node): handle `--allow-sys=inspector` (#26836)
+- fix(ext/node): increase tolerance for interval test (#26899)
+- fix(ext/node): process.getBuiltinModule (#26833)
+- fix(ext/node): use ERR_NOT_IMPLEMENTED for notImplemented (#26853)
+- fix(ext/node): zlib.crc32() (#26856)
+- fix(ext/webgpu): Create GPUQuerySet converter before usage (#26883)
+- fix(ext/websocket): initialize `error` attribute of WebSocket ErrorEvent
+  (#26796)
+- fix(ext/webstorage): use error class for sqlite error case (#26806)
+- fix(fmt): error instead of panic on unstable format (#26859)
+- fix(fmt): formatting of .svelte files (#26948)
+- fix(install): percent encodings in interactive progress bar (#26600)
+- fix(install): re-setup bin entries after running lifecycle scripts (#26752)
+- fix(lockfile): track dependencies specified in TypeScript compiler options
+  (#26551)
+- fix(lsp): ignore editor indent settings if deno.json is present (#26912)
+- fix(lsp): skip code action edits that can't be converted (#26831)
+- fix(node): handle resolving ".//<something>" in npm packages (#26920)
+- fix(node/crypto): support promisify on generateKeyPair (#26913)
+- fix(permissions): say to use --allow-run instead of --allow-all (#26842)
+- fix(publish): improve error message when missing exports (#26945)
+- fix: otel resiliency (#26857)
+- fix: update message for unsupported schemes with npm and jsr (#26884)
+- perf(compile): code cache (#26528)
+- perf(windows): delay load webgpu and some other dlls (#26917)
+- perf: use available system memory for v8 isolate memory limit (#26868)
+
 ### 2.0.6 / 2024.11.10

 - feat(ext/http): abort event when request is cancelled (#26781)
--- a/bench_util/Cargo.toml
+++ b/bench_util/Cargo.toml
@ -2,7 +2,7 @@

 [package]
 name = "deno_bench_util"
-version = "0.171.0"
+version = "0.174.0"
 authors.workspace = true
 edition.workspace = true
 license.workspace = true
--- a/cli/Cargo.toml
+++ b/cli/Cargo.toml
@ -2,7 +2,7 @@

 [package]
 name = "deno"
-version = "2.0.6"
+version = "2.1.2"
 authors.workspace = true
 default-run = "deno"
 edition.workspace = true
@ -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.156.0", default-features = false, features = ["rust", "html", "syntect"] }
-deno_graph = { version = "=0.84.1" }
+deno_doc = { version = "=0.161.1", features = ["rust", "comrak"] }
+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
@ -129,7 +130,7 @@ libz-sys.workspace = true
 log = { workspace = true, features = ["serde"] }
 lsp-types.workspace = true
 malva = "=0.11.0"
-markup_fmt = "=0.15.0"
+markup_fmt = "=0.16.0"
 memmem.workspace = true
 monch.workspace = true
 notify.workspace = true
@ -151,6 +152,7 @@ serde_repr.workspace = true
 sha2.workspace = true
 shell-escape = "=0.1.5"
 spki = { version = "0.7", features = ["pem"] }
+sqlformat = "=0.3.2"
 strsim = "0.11.1"
 tar.workspace = true
 tempfile.workspace = true
--- a/cli/args/deno_json.rs
+++ b/cli/args/deno_json.rs
@ -22,6 +22,8 @@ impl<'a> deno_config::fs::DenoConfigFs for DenoConfigFsAdapter<'a> {
    self
      .0
      .read_text_file_lossy_sync(path, None)
+      // todo(https://github.com/denoland/deno_config/pull/140): avoid clone
+      .map(|s| s.into_owned())
      .map_err(|err| err.into_io_error())
  }

@ -70,7 +72,41 @@ pub fn deno_json_deps(
  let values = imports_values(config.json.imports.as_ref())
    .into_iter()
    .chain(scope_values(config.json.scopes.as_ref()));
-  values_to_set(values)
+  let mut set = values_to_set(values);
+
+  if let Some(serde_json::Value::Object(compiler_options)) =
+    &config.json.compiler_options
+  {
+    // add jsxImportSource
+    if let Some(serde_json::Value::String(value)) =
+      compiler_options.get("jsxImportSource")
+    {
+      if let Some(dep_req) = value_to_dep_req(value) {
+        set.insert(dep_req);
+      }
+    }
+    // add jsxImportSourceTypes
+    if let Some(serde_json::Value::String(value)) =
+      compiler_options.get("jsxImportSourceTypes")
+    {
+      if let Some(dep_req) = value_to_dep_req(value) {
+        set.insert(dep_req);
+      }
+    }
+    // add the dependencies in the types array
+    if let Some(serde_json::Value::Array(types)) = compiler_options.get("types")
+    {
+      for value in types {
+        if let serde_json::Value::String(value) = value {
+          if let Some(dep_req) = value_to_dep_req(value) {
+            set.insert(dep_req);
+          }
+        }
+      }
+    }
+  }
+
+  set
 }

 fn imports_values(value: Option<&serde_json::Value>) -> Vec<&String> {
@ -98,15 +134,23 @@ fn values_to_set<'a>(
 ) -> HashSet<JsrDepPackageReq> {
  let mut entries = HashSet::new();
  for value in values {
-    if let Ok(req_ref) = JsrPackageReqReference::from_str(value) {
-      entries.insert(JsrDepPackageReq::jsr(req_ref.into_inner().req));
-    } else if let Ok(req_ref) = NpmPackageReqReference::from_str(value) {
-      entries.insert(JsrDepPackageReq::npm(req_ref.into_inner().req));
+    if let Some(dep_req) = value_to_dep_req(value) {
+      entries.insert(dep_req);
    }
  }
  entries
 }

+fn value_to_dep_req(value: &str) -> Option<JsrDepPackageReq> {
+  if let Ok(req_ref) = JsrPackageReqReference::from_str(value) {
+    Some(JsrDepPackageReq::jsr(req_ref.into_inner().req))
+  } else if let Ok(req_ref) = NpmPackageReqReference::from_str(value) {
+    Some(JsrDepPackageReq::npm(req_ref.into_inner().req))
+  } else {
+    None
+  }
+}
+
 pub fn check_warn_tsconfig(ts_config: &TsConfigForEmit) {
  if let Some(ignored_options) = &ts_config.maybe_ignored_options {
    log::warn!("{}", ignored_options);
--- a/cli/args/flags.rs
+++ b/cli/args/flags.rs
--- a/cli/args/lockfile.rs
+++ b/cli/args/lockfile.rs
@ -126,11 +126,7 @@ impl CliLockfile {
      maybe_deno_json: Option<&ConfigFile>,
    ) -> HashSet<JsrDepPackageReq> {
      maybe_deno_json
-        .map(|c| {
-          crate::args::deno_json::deno_json_deps(c)
-            .into_iter()
-            .collect()
-        })
+        .map(crate::args::deno_json::deno_json_deps)
        .unwrap_or_default()
    }

--- 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;
@ -289,6 +289,7 @@ impl BenchOptions {
 #[derive(Clone, Debug, Default, PartialEq, Eq, Hash)]
 pub struct UnstableFmtOptions {
  pub component: bool,
+  pub sql: bool,
 }

 #[derive(Clone, Debug)]
@ -322,6 +323,7 @@ impl FmtOptions {
      options: resolve_fmt_options(fmt_flags, fmt_config.options),
      unstable: UnstableFmtOptions {
        component: unstable.component || fmt_flags.unstable_component,
+        sql: unstable.sql || fmt_flags.unstable_sql,
      },
      files: fmt_config.files,
    }
@ -868,12 +870,8 @@ impl CliOptions {
        } else {
          &[]
        };
-      let config_parse_options = deno_config::deno_json::ConfigParseOptions {
-        include_task_comments: matches!(
-          flags.subcommand,
-          DenoSubcommand::Task(..)
-        ),
-      };
+      let config_parse_options =
+        deno_config::deno_json::ConfigParseOptions::default();
      let discover_pkg_json = flags.config_flag != ConfigFlag::Disabled
        && !flags.no_npm
        && !has_flag_env_var("DENO_NO_PACKAGE_JSON");
@ -1132,7 +1130,7 @@ impl CliOptions {
    self.flags.otel_config()
  }

-  pub fn env_file_name(&self) -> Option<&String> {
+  pub fn env_file_name(&self) -> Option<&Vec<String>> {
    self.flags.env_file.as_ref()
  }

@ -1323,6 +1321,7 @@ impl CliOptions {
    let workspace = self.workspace();
    UnstableFmtOptions {
      component: workspace.has_unstable("fmt-component"),
+      sql: workspace.has_unstable("fmt-sql"),
    }
  }

@ -1549,6 +1548,10 @@ impl CliOptions {
        }) => Url::parse(&flags.module_url)
          .ok()
          .map(|url| vec![Cow::Owned(url)]),
+        DenoSubcommand::Doc(DocFlags {
+          source_files: DocSourceFileFlag::Paths(paths),
+          ..
+        }) => Some(files_to_urls(paths)),
        _ => None,
      })
      .unwrap_or_default();
@ -1603,6 +1606,11 @@ impl CliOptions {
      || self.workspace().has_unstable("bare-node-builtins")
  }

+  pub fn unstable_detect_cjs(&self) -> bool {
+    self.flags.unstable_config.detect_cjs
+      || self.workspace().has_unstable("detect-cjs")
+  }
+
  pub fn detect_cjs(&self) -> bool {
    // only enabled when there's a package.json in order to not have a
    // perf penalty for non-npm Deno projects of searching for the closest
@ -1625,8 +1633,10 @@ impl CliOptions {
      DenoSubcommand::Install(_)
        | DenoSubcommand::Add(_)
        | DenoSubcommand::Remove(_)
+        | DenoSubcommand::Init(_)
+        | DenoSubcommand::Outdated(_)
    ) {
-      // For `deno install/add/remove` we want to force the managed resolver so it can set up `node_modules/` directory.
+      // For `deno install/add/remove/init` we want to force the managed resolver so it can set up `node_modules/` directory.
      return false;
    }
    if self.node_modules_dir().ok().flatten().is_none()
@ -1670,7 +1680,9 @@ impl CliOptions {
          "sloppy-imports",
          "byonm",
          "bare-node-builtins",
+          "detect-cjs",
          "fmt-component",
+          "fmt-sql",
        ])
        .collect();

@ -1908,6 +1920,10 @@ pub fn resolve_no_prompt(flags: &PermissionFlags) -> bool {
  flags.no_prompt || has_flag_env_var("DENO_NO_PROMPT")
 }

+pub fn has_trace_permissions_enabled() -> bool {
+  has_flag_env_var("DENO_TRACE_PERMISSIONS")
+}
+
 pub fn has_flag_env_var(name: &str) -> bool {
  let value = env::var(name);
  matches!(value.as_ref().map(|s| s.as_str()), Ok("1"))
@ -1939,19 +1955,22 @@ pub fn config_to_deno_graph_workspace_member(
  })
 }

-fn load_env_variables_from_env_file(filename: Option<&String>) {
-  let Some(env_file_name) = filename else {
+fn load_env_variables_from_env_file(filename: Option<&Vec<String>>) {
+  let Some(env_file_names) = filename else {
    return;
  };
-  match from_filename(env_file_name) {
-    Ok(_) => (),
-    Err(error) => {
-      match error {
+
+  for env_file_name in env_file_names.iter().rev() {
+    match from_filename(env_file_name) {
+      Ok(_) => (),
+      Err(error) => {
+        match error {
          dotenvy::Error::LineParse(line, index)=> log::info!("{} Parsing failed within the specified environment file: {} at index: {} of the value: {}",colors::yellow("Warning"), env_file_name, index, line),
          dotenvy::Error::Io(_)=> log::info!("{} The `--env-file` flag was used, but the environment file specified '{}' was not found.",colors::yellow("Warning"),env_file_name),
          dotenvy::Error::EnvVar(_)=> log::info!("{} One or more of the environment variables isn't present or not unicode within the specified environment file: {}",colors::yellow("Warning"),env_file_name),
          _ => log::info!("{} Unknown failure occurred with the specified environment file: {}", colors::yellow("Warning"), env_file_name),
        }
+      }
    }
  }
 }
--- a/cli/build.rs
+++ b/cli/build.rs
@ -400,6 +400,24 @@ fn main() {
  println!("cargo:rustc-env=TARGET={}", env::var("TARGET").unwrap());
  println!("cargo:rustc-env=PROFILE={}", env::var("PROFILE").unwrap());

+  if cfg!(windows) {
+    // these dls load slowly, so delay loading them
+    let dlls = [
+      // webgpu
+      "d3dcompiler_47",
+      "OPENGL32",
+      // network related functions
+      "iphlpapi",
+    ];
+    for dll in dlls {
+      println!("cargo:rustc-link-arg-bin=deno=/delayload:{dll}.dll");
+      println!("cargo:rustc-link-arg-bin=denort=/delayload:{dll}.dll");
+    }
+    // enable delay loading
+    println!("cargo:rustc-link-arg-bin=deno=delayimp.lib");
+    println!("cargo:rustc-link-arg-bin=denort=delayimp.lib");
+  }
+
  let c = PathBuf::from(env::var_os("CARGO_MANIFEST_DIR").unwrap());
  let o = PathBuf::from(env::var_os("OUT_DIR").unwrap());

--- a/cli/cache/code_cache.rs
+++ b/cli/cache/code_cache.rs
@ -1,10 +1,14 @@
 // Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.

+use std::sync::Arc;
+
 use deno_ast::ModuleSpecifier;
 use deno_core::error::AnyError;
 use deno_runtime::code_cache;
 use deno_runtime::deno_webstorage::rusqlite::params;

+use crate::worker::CliCodeCache;
+
 use super::cache_db::CacheDB;
 use super::cache_db::CacheDBConfiguration;
 use super::cache_db::CacheDBHash;
@ -82,6 +86,12 @@ impl CodeCache {
  }
 }

+impl CliCodeCache for CodeCache {
+  fn as_code_cache(self: Arc<Self>) -> Arc<dyn code_cache::CodeCache> {
+    self
+  }
+}
+
 impl code_cache::CodeCache for CodeCache {
  fn get_sync(
    &self,
--- a/cli/cache/mod.rs
+++ b/cli/cache/mod.rs
@ -116,6 +116,8 @@ impl<'a> deno_cache_dir::DenoCacheEnv for DenoCacheEnvFsAdapter<'a> {
    self
      .0
      .read_file_sync(path, None)
+      // todo(https://github.com/denoland/deno_cache_dir/pull/66): avoid clone
+      .map(|bytes| bytes.into_owned())
      .map_err(|err| err.into_io_error())
  }

--- 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 {
-      range: PositionRange {
-        start: deno_graph::Position {
-          line: 0,
-          character: 3,
-        },
-        end: deno_graph::Position {
-          line: 1,
-          character: 2,
+    module_info.jsdoc_imports.push(JsDocImportInfo {
+      specifier: SpecifierWithRange {
+        range: PositionRange {
+          start: deno_graph::Position {
+            line: 0,
+            character: 3,
+          },
+          end: deno_graph::Position {
+            line: 1,
+            character: 2,
+          },
        },
+        text: "test".to_string(),
      },
-      text: "test".to_string(),
+      resolution_mode: None,
    });
    cache
      .set_module_info(
--- a/cli/errors.rs
+++ b/cli/errors.rs
@ -38,6 +38,7 @@ fn get_module_graph_error_class(err: &ModuleGraphError) -> &'static str {
    ModuleGraphError::ModuleError(err) => match err {
      ModuleError::InvalidTypeAssertion { .. } => "SyntaxError",
      ModuleError::ParseErr(_, diagnostic) => get_diagnostic_class(diagnostic),
+      ModuleError::WasmParseErr(..) => "SyntaxError",
      ModuleError::UnsupportedMediaType { .. }
      | ModuleError::UnsupportedImportAttributeType { .. } => "TypeError",
      ModuleError::Missing(_, _) | ModuleError::MissingDynamic(_, _) => {
--- a/cli/factory.rs
+++ b/cli/factory.rs
@ -48,7 +48,6 @@ use crate::resolver::CliNpmReqResolver;
 use crate::resolver::CliResolver;
 use crate::resolver::CliResolverOptions;
 use crate::resolver::CliSloppyImportsResolver;
-use crate::resolver::IsCjsResolverOptions;
 use crate::resolver::NpmModuleLoader;
 use crate::resolver::SloppyImportsCachedFs;
 use crate::standalone::DenoCompileBinaryWriter;
@ -72,6 +71,7 @@ use deno_core::error::AnyError;
 use deno_core::futures::FutureExt;
 use deno_core::FeatureChecker;

+use deno_resolver::cjs::IsCjsResolutionMode;
 use deno_resolver::npm::NpmReqResolverOptions;
 use deno_resolver::DenoResolverOptions;
 use deno_resolver::NodeAndNpmReqResolver;
@ -845,9 +845,12 @@ impl CliFactory {
      Ok(Arc::new(CjsTracker::new(
        self.in_npm_pkg_checker()?.clone(),
        self.pkg_json_resolver().clone(),
-        IsCjsResolverOptions {
-          detect_cjs: options.detect_cjs(),
-          is_node_main: options.is_node_main(),
+        if options.is_node_main() || options.unstable_detect_cjs() {
+          IsCjsResolutionMode::ImplicitTypeCommonJs
+        } else if options.detect_cjs() {
+          IsCjsResolutionMode::ExplicitTypeCommonJs
+        } else {
+          IsCjsResolutionMode::Disabled
        },
      )))
    })
@ -884,6 +887,7 @@ impl CliFactory {
    let cli_options = self.cli_options()?;
    Ok(DenoCompileBinaryWriter::new(
      self.cjs_tracker()?,
+      self.cli_options()?,
      self.deno_dir()?,
      self.emitter()?,
      self.file_fetcher()?,
--- a/cli/file_fetcher.rs
+++ b/cli/file_fetcher.rs
@ -164,8 +164,19 @@ fn get_validated_scheme(
 ) -> Result<String, AnyError> {
  let scheme = specifier.scheme();
  if !SUPPORTED_SCHEMES.contains(&scheme) {
+    // NOTE(bartlomieju): this message list additional `npm` and `jsr` schemes, but they should actually be handled
+    // before `file_fetcher.rs` APIs are even hit.
+    let mut all_supported_schemes = SUPPORTED_SCHEMES.to_vec();
+    all_supported_schemes.extend_from_slice(&["npm", "jsr"]);
+    all_supported_schemes.sort();
+    let scheme_list = all_supported_schemes
+      .iter()
+      .map(|scheme| format!(" - \"{}\"", scheme))
+      .collect::<Vec<_>>()
+      .join("\n");
    Err(generic_error(format!(
-      "Unsupported scheme \"{scheme}\" for module \"{specifier}\". Supported schemes: {SUPPORTED_SCHEMES:#?}"
+      "Unsupported scheme \"{scheme}\" for module \"{specifier}\". Supported schemes:\n{}", 
+      scheme_list
    )))
  } else {
    Ok(scheme.to_string())
--- a/cli/graph_util.rs
+++ b/cli/graph_util.rs
@ -6,6 +6,7 @@ use crate::args::CliLockfile;
 use crate::args::CliOptions;
 use crate::args::DENO_DISABLE_PEDANTIC_NODE_WARNINGS;
 use crate::cache;
+use crate::cache::FetchCacher;
 use crate::cache::GlobalHttpCache;
 use crate::cache::ModuleInfoCache;
 use crate::cache::ParsedSourceCache;
@ -25,7 +26,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 +45,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;
@ -254,6 +255,23 @@ impl ModuleGraphCreator {
    package_configs: &[JsrPackageConfig],
    build_fast_check_graph: bool,
  ) -> Result<ModuleGraph, AnyError> {
+    struct PublishLoader(FetchCacher);
+    impl Loader for PublishLoader {
+      fn load(
+        &self,
+        specifier: &deno_ast::ModuleSpecifier,
+        options: deno_graph::source::LoadOptions,
+      ) -> deno_graph::source::LoadFuture {
+        if specifier.scheme() == "bun" {
+          return Box::pin(std::future::ready(Ok(Some(
+            deno_graph::source::LoadResponse::External {
+              specifier: specifier.clone(),
+            },
+          ))));
+        }
+        self.0.load(specifier, options)
+      }
+    }
    fn graph_has_external_remote(graph: &ModuleGraph) -> bool {
      // Earlier on, we marked external non-JSR modules as external.
      // If the graph contains any of those, it would cause type checking
@ -271,12 +289,15 @@ impl ModuleGraphCreator {
    for package_config in package_configs {
      roots.extend(package_config.config_file.resolve_export_value_urls()?);
    }
+
+    let loader = self.module_graph_builder.create_graph_loader();
+    let mut publish_loader = PublishLoader(loader);
    let mut graph = self
      .create_graph_with_options(CreateGraphOptions {
        is_dynamic: false,
        graph_kind: deno_graph::GraphKind::All,
        roots,
-        loader: None,
+        loader: Some(&mut publish_loader),
      })
      .await?;
    self.graph_valid(&graph)?;
@ -795,7 +816,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 +1121,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::yellow(&(range.start.line + 1).to_string()),
-    colors::yellow(&(range.start.character + 1).to_string())
+    colors::cyan(referrer.specifier.as_str()),
+    colors::yellow(&(referrer.range.start.line + 1).to_string()),
+    colors::yellow(&(referrer.range.start.character + 1).to_string())
  )
 }

@ -1195,26 +1216,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,
-      self
-        .cjs_tracker
-        .get_referrer_kind(&referrer_range.specifier),
-      mode,
+      &referrer_range.specifier,
+      referrer_range.range.start,
+      referrer_range
+        .resolution_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 +1284,8 @@ mod test {
        specifier: input.to_string(),
        range: Range {
          specifier,
-          start: Position::zeroed(),
-          end: Position::zeroed(),
+          resolution_mode: None,
+          range: PositionRange::zeroed(),
        },
      };
      assert_eq!(get_resolution_error_bare_node_specifier(&err), output);
@ -1251,8 +1300,8 @@ mod test {
      let err = ResolutionError::InvalidSpecifier {
        range: Range {
          specifier,
-          start: Position::zeroed(),
-          end: Position::zeroed(),
+          resolution_mode: None,
+          range: PositionRange::zeroed(),
        },
        error: SpecifierError::ImportPrefixMissing {
          specifier: input.to_string(),
--- a/cli/js/40_jupyter.js
+++ b/cli/js/40_jupyter.js
@ -177,6 +177,52 @@ function isCanvasLike(obj) {
  return obj !== null && typeof obj === "object" && "toDataURL" in obj;
 }

+function isJpg(obj) {
+  // Check if obj is a Uint8Array
+  if (!(obj instanceof Uint8Array)) {
+    return false;
+  }
+
+  // JPG files start with the magic bytes FF D8
+  if (obj.length < 2 || obj[0] !== 0xFF || obj[1] !== 0xD8) {
+    return false;
+  }
+
+  // JPG files end with the magic bytes FF D9
+  if (
+    obj.length < 2 || obj[obj.length - 2] !== 0xFF ||
+    obj[obj.length - 1] !== 0xD9
+  ) {
+    return false;
+  }
+
+  return true;
+}
+
+function isPng(obj) {
+  // Check if obj is a Uint8Array
+  if (!(obj instanceof Uint8Array)) {
+    return false;
+  }
+
+  // PNG files start with a specific 8-byte signature
+  const pngSignature = [137, 80, 78, 71, 13, 10, 26, 10];
+
+  // Check if the array is at least as long as the signature
+  if (obj.length < pngSignature.length) {
+    return false;
+  }
+
+  // Check each byte of the signature
+  for (let i = 0; i < pngSignature.length; i++) {
+    if (obj[i] !== pngSignature[i]) {
+      return false;
+    }
+  }
+
+  return true;
+}
+
 /** Possible HTML and SVG Elements */
 function isSVGElementLike(obj) {
  return obj !== null && typeof obj === "object" && "outerHTML" in obj &&
@ -233,6 +279,16 @@ async function format(obj) {
  if (isDataFrameLike(obj)) {
    return extractDataFrame(obj);
  }
+  if (isJpg(obj)) {
+    return {
+      "image/jpeg": core.ops.op_base64_encode(obj),
+    };
+  }
+  if (isPng(obj)) {
+    return {
+      "image/png": core.ops.op_base64_encode(obj),
+    };
+  }
  if (isSVGElementLike(obj)) {
    return {
      "image/svg+xml": obj.outerHTML,
@ -314,6 +370,28 @@ const html = createTaggedTemplateDisplayable("text/html");
 */
 const svg = createTaggedTemplateDisplayable("image/svg+xml");

+function image(obj) {
+  if (typeof obj === "string") {
+    try {
+      obj = Deno.readFileSync(obj);
+    } catch {
+      // pass
+    }
+  }
+
+  if (isJpg(obj)) {
+    return makeDisplayable({ "image/jpeg": core.ops.op_base64_encode(obj) });
+  }
+
+  if (isPng(obj)) {
+    return makeDisplayable({ "image/png": core.ops.op_base64_encode(obj) });
+  }
+
+  throw new TypeError(
+    "Object is not a valid image or a path to an image. `Deno.jupyter.image` supports displaying JPG or PNG images.",
+  );
+}
+
 function isMediaBundle(obj) {
  if (obj == null || typeof obj !== "object" || Array.isArray(obj)) {
    return false;
@ -465,6 +543,7 @@ function enableJupyter() {
    md,
    html,
    svg,
+    image,
    $display,
  };
 }
--- 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 {
-            specifier: referrer.clone(),
-            start: deno_graph::Position::zeroed(),
-            end: deno_graph::Position::zeroed(),
-          },
-          referrer_kind,
-          ResolutionMode::Types,
+          referrer,
+          deno_graph::Position::zeroed(),
+          resolution_mode,
+          NodeResolutionKind::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 {
-          specifier: referrer.clone(),
-          start: deno_graph::Position::zeroed(),
-          end: deno_graph::Position::zeroed(),
-        },
-        referrer_kind,
-        deno_graph::source::ResolutionMode::Types,
+        referrer,
+        deno_graph::Position::zeroed(),
+        resolution_mode,
+        NodeResolutionKind::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) =
-    import_mapper.check_unresolved_specifier(specifier, referrer, referrer_kind)
-  {
+  if let Some(new_specifier) = import_mapper.check_unresolved_specifier(
+    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,
-          column_index: import.specifier_range.start.character,
+          line_index: import.specifier_range.range.start.line,
+          column_index: import.specifier_range.range.start.character,
        }),
        text_info.loc_to_source_pos(LineAndColumnIndex {
-          line_index: import.specifier_range.end.line,
-          column_index: import.specifier_range.end.character,
+          line_index: import.specifier_range.range.end.line,
+          column_index: import.specifier_range.range.end.character,
        }),
      );

@ -1277,16 +1274,14 @@ 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;
        }

        import_start_from_specifier(document, i)
      })?;
      let referrer = document.specifier();
-      let referrer_kind = language_server
-        .is_cjs_resolver
-        .get_doc_module_kind(document);
+      let resolution_mode = document.resolution_mode();
      let file_referrer = document.file_referrer();
      let config_data = language_server
        .config
@ -1312,7 +1307,7 @@ impl CodeActionCollection {
        if !language_server.resolver.is_bare_package_json_dep(
          &dep_key,
          referrer,
-          referrer_kind,
+          resolution_mode,
        ) {
          return None;
        }
@ -1332,7 +1327,7 @@ impl CodeActionCollection {
      }
      if language_server
        .resolver
-        .npm_to_file_url(&npm_ref, referrer, referrer_kind, file_referrer)
+        .npm_to_file_url(&npm_ref, referrer, resolution_mode, file_referrer)
        .is_some()
      {
        // The package import has types.
--- a/cli/lsp/completions.rs
+++ b/cli/lsp/completions.rs
@ -9,16 +9,14 @@ use super::jsr::CliJsrSearchApi;
 use super::lsp_custom;
 use super::npm::CliNpmSearchApi;
 use super::registries::ModuleRegistry;
-use super::resolver::LspIsCjsResolver;
 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 +34,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 +112,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 {
@ -161,26 +160,25 @@ pub async fn get_import_completions(
  jsr_search_api: &CliJsrSearchApi,
  npm_search_api: &CliNpmSearchApi,
  documents: &Documents,
-  is_cjs_resolver: &LspIsCjsResolver,
  resolver: &LspResolver,
  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 range = to_narrow_lsp_range(document.text_info(), &range);
+  let (text, _, graph_range) = document.get_maybe_dependency(position)?;
+  let resolution_mode = graph_range
+    .resolution_mode
+    .map(to_node_resolution_mode)
+    .unwrap_or_else(|| document.resolution_mode());
+  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.clone(),
-        start: deno_graph::Position::zeroed(),
-        end: deno_graph::Position::zeroed(),
-      },
-      specifier_kind,
-      ResolutionMode::Execution,
+      specifier,
+      deno_graph::Position::zeroed(),
+      resolution_mode,
+      NodeResolutionKind::Execution,
    )
    .ok();
  if let Some(completion_list) = get_jsr_completions(
@ -206,7 +204,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 +359,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 +372,10 @@ fn get_local_completions(
    .as_cli_resolver(Some(referrer))
    .resolve(
      parent,
-      &Range {
-        specifier: referrer.clone(),
-        start: deno_graph::Position::zeroed(),
-        end: deno_graph::Position::zeroed(),
-      },
-      referrer_kind,
-      ResolutionMode::Execution,
+      referrer,
+      deno_graph::Position::zeroed(),
+      resolution_mode,
+      NodeResolutionKind::Execution,
    )
    .ok()?;
  let resolved_parent_path = url_to_file_path(&resolved_parent).ok()?;
@ -831,7 +826,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 +906,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 +1602,7 @@ mod tests {
    let text_info = SourceTextInfo::from_string(r#""te""#.to_string());
    let range = to_narrow_lsp_range(
      &text_info,
-      &Range {
-        specifier: ModuleSpecifier::parse("https://deno.land").unwrap(),
+      deno_graph::PositionRange {
        start: deno_graph::Position {
          line: 0,
          character: 0,
@ -1632,8 +1625,7 @@ mod tests {
    let text_info = SourceTextInfo::from_string(r#""te"#.to_string());
    let range = to_narrow_lsp_range(
      &text_info,
-      &Range {
-        specifier: ModuleSpecifier::parse("https://deno.land").unwrap(),
+      deno_graph::PositionRange {
        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()
    });

@ -1707,7 +1707,6 @@ mod tests {
        documents: Arc::new(documents),
        assets: Default::default(),
        config: Arc::new(config),
-        is_cjs_resolver: Default::default(),
        resolver,
      },
    )
--- a/cli/lsp/documents.rs
+++ b/cli/lsp/documents.rs
@ -3,8 +3,8 @@
 use super::cache::calculate_fs_version;
 use super::cache::LspCache;
 use super::config::Config;
-use super::resolver::LspIsCjsResolver;
 use super::resolver::LspResolver;
+use super::resolver::ScopeDepInfo;
 use super::resolver::SingleReferrerGraphResolver;
 use super::testing::TestCollector;
 use super::testing::TestModule;
@ -26,7 +26,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;
@ -35,10 +34,10 @@ 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::BTreeSet;
 use std::collections::HashMap;
 use std::collections::HashSet;
 use std::fs;
@ -313,6 +312,7 @@ pub struct Document {
  media_type: MediaType,
  /// Present if and only if this is an open document.
  open_data: Option<DocumentOpenData>,
+  resolution_mode: ResolutionMode,
  resolver: Arc<LspResolver>,
  specifier: ModuleSpecifier,
  text: Arc<str>,
@ -328,7 +328,6 @@ impl Document {
    maybe_lsp_version: Option<i32>,
    maybe_language_id: Option<LanguageId>,
    maybe_headers: Option<HashMap<String, String>>,
-    is_cjs_resolver: &LspIsCjsResolver,
    resolver: Arc<LspResolver>,
    config: Arc<Config>,
    cache: &Arc<LspCache>,
@ -340,7 +339,7 @@ impl Document {
      .or(file_referrer);
    let media_type =
      resolve_media_type(&specifier, maybe_headers.as_ref(), maybe_language_id);
-    let (maybe_parsed_source, maybe_module) =
+    let (maybe_parsed_source, maybe_module, resolution_mode) =
      if media_type_is_diagnosable(media_type) {
        parse_and_analyze_module(
          specifier.clone(),
@ -348,11 +347,10 @@ impl Document {
          maybe_headers.as_ref(),
          media_type,
          file_referrer.as_ref(),
-          is_cjs_resolver,
          &resolver,
        )
      } else {
-        (None, None)
+        (None, None, ResolutionMode::Import)
      };
    let maybe_module = maybe_module.and_then(Result::ok);
    let dependencies = maybe_module
@ -387,6 +385,7 @@ impl Document {
        maybe_parsed_source,
        maybe_semantic_tokens: Default::default(),
      }),
+      resolution_mode,
      resolver,
      specifier,
      text,
@ -396,7 +395,6 @@ impl Document {

  fn with_new_config(
    &self,
-    is_cjs_resolver: &LspIsCjsResolver,
    resolver: Arc<LspResolver>,
    config: Arc<Config>,
  ) -> Arc<Self> {
@ -408,20 +406,20 @@ impl Document {
    let dependencies;
    let maybe_types_dependency;
    let maybe_parsed_source;
+    let found_resolution_mode;
    let is_script;
    let maybe_test_module_fut;
    if media_type != self.media_type {
      let parsed_source_result =
        parse_source(self.specifier.clone(), self.text.clone(), media_type);
-      let maybe_module = analyze_module(
+      let (maybe_module_result, resolution_mode) = analyze_module(
        self.specifier.clone(),
        &parsed_source_result,
        self.maybe_headers.as_ref(),
        self.file_referrer.as_ref(),
-        is_cjs_resolver,
        &resolver,
-      )
-      .ok();
+      );
+      let maybe_module = maybe_module_result.ok();
      dependencies = maybe_module
        .as_ref()
        .map(|m| Arc::new(m.dependencies.clone()))
@ -433,17 +431,21 @@ impl Document {
      maybe_parsed_source = Some(parsed_source_result);
      maybe_test_module_fut =
        get_maybe_test_module_fut(maybe_parsed_source.as_ref(), &config);
+      found_resolution_mode = resolution_mode;
    } else {
      let cli_resolver = resolver.as_cli_resolver(self.file_referrer.as_ref());
+      let is_cjs_resolver =
+        resolver.as_is_cjs_resolver(self.file_referrer.as_ref());
      let npm_resolver =
        resolver.create_graph_npm_resolver(self.file_referrer.as_ref());
      let config_data = resolver.as_config_data(self.file_referrer.as_ref());
      let jsx_import_source_config =
        config_data.and_then(|d| d.maybe_jsx_import_source_config());
+      found_resolution_mode = is_cjs_resolver
+        .get_lsp_resolution_mode(&self.specifier, self.is_script);
      let resolver = SingleReferrerGraphResolver {
        valid_referrer: &self.specifier,
-        referrer_kind: is_cjs_resolver
-          .get_lsp_referrer_kind(&self.specifier, self.is_script),
+        module_resolution_mode: found_resolution_mode,
        cli_resolver,
        jsx_import_source_config: jsx_import_source_config.as_ref(),
      };
@ -493,6 +495,7 @@ impl Document {
      maybe_language_id: self.maybe_language_id,
      maybe_test_module_fut,
      media_type,
+      resolution_mode: found_resolution_mode,
      open_data: self.open_data.as_ref().map(|d| DocumentOpenData {
        lsp_version: d.lsp_version,
        maybe_parsed_source,
@ -508,7 +511,6 @@ impl Document {

  fn with_change(
    &self,
-    is_cjs_resolver: &LspIsCjsResolver,
    version: i32,
    changes: Vec<lsp::TextDocumentContentChangeEvent>,
  ) -> Result<Arc<Self>, AnyError> {
@ -530,7 +532,7 @@ impl Document {
    }
    let text: Arc<str> = content.into();
    let media_type = self.media_type;
-    let (maybe_parsed_source, maybe_module) = if self
+    let (maybe_parsed_source, maybe_module, resolution_mode) = if self
      .maybe_language_id
      .as_ref()
      .map(|li| li.is_diagnosable())
@ -542,11 +544,10 @@ impl Document {
        self.maybe_headers.as_ref(),
        media_type,
        self.file_referrer.as_ref(),
-        is_cjs_resolver,
        self.resolver.as_ref(),
      )
    } else {
-      (None, None)
+      (None, None, ResolutionMode::Import)
    };
    let maybe_module = maybe_module.and_then(Result::ok);
    let dependencies = maybe_module
@ -580,6 +581,7 @@ impl Document {
      maybe_navigation_tree: Mutex::new(None),
      maybe_test_module_fut,
      media_type,
+      resolution_mode,
      open_data: self.open_data.is_some().then_some(DocumentOpenData {
        lsp_version: version,
        maybe_parsed_source,
@ -613,6 +615,7 @@ impl Document {
      maybe_test_module_fut: self.maybe_test_module_fut.clone(),
      media_type: self.media_type,
      open_data: None,
+      resolution_mode: self.resolution_mode,
      resolver: self.resolver.clone(),
    })
  }
@ -641,6 +644,7 @@ impl Document {
      maybe_test_module_fut: self.maybe_test_module_fut.clone(),
      media_type: self.media_type,
      open_data: self.open_data.clone(),
+      resolution_mode: self.resolution_mode,
      resolver: self.resolver.clone(),
    })
  }
@ -664,6 +668,10 @@ impl Document {
    &self.text
  }

+  pub fn resolution_mode(&self) -> ResolutionMode {
+    self.resolution_mode
+  }
+
  pub fn text_info(&self) -> &SourceTextInfo {
    // try to get the text info from the parsed source and if
    // not then create one in the cell
@ -677,14 +685,6 @@ impl Document {
          .get_or_init(|| SourceTextInfo::new(self.text.clone()))
      })
  }
-
-  /// If this is maybe a CJS script and maybe not an ES module.
-  ///
-  /// Use `LspIsCjsResolver` to determine for sure.
-  pub fn is_script(&self) -> Option<bool> {
-    self.is_script
-  }
-
  pub fn line_index(&self) -> Arc<LineIndex> {
    self.line_index.clone()
  }
@ -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,
-      character: range.start.character as u32,
+      line: referrer.range.start.line as u32,
+      character: referrer.range.start.character as u32,
    },
    end: lsp::Position {
-      line: range.end.line as u32,
-      character: range.end.character as u32,
+      line: referrer.range.end.line as u32,
+      character: referrer.range.end.character as u32,
    },
  }
 }
@ -832,7 +832,6 @@ impl FileSystemDocuments {
  pub fn get(
    &self,
    specifier: &ModuleSpecifier,
-    is_cjs_resolver: &LspIsCjsResolver,
    resolver: &Arc<LspResolver>,
    config: &Arc<Config>,
    cache: &Arc<LspCache>,
@ -856,14 +855,7 @@ impl FileSystemDocuments {
    };
    if dirty {
      // attempt to update the file on the file system
-      self.refresh_document(
-        specifier,
-        is_cjs_resolver,
-        resolver,
-        config,
-        cache,
-        file_referrer,
-      )
+      self.refresh_document(specifier, resolver, config, cache, file_referrer)
    } else {
      old_doc
    }
@ -874,7 +866,6 @@ impl FileSystemDocuments {
  fn refresh_document(
    &self,
    specifier: &ModuleSpecifier,
-    is_cjs_resolver: &LspIsCjsResolver,
    resolver: &Arc<LspResolver>,
    config: &Arc<Config>,
    cache: &Arc<LspCache>,
@ -883,15 +874,19 @@ impl FileSystemDocuments {
    let doc = if specifier.scheme() == "file" {
      let path = url_to_file_path(specifier).ok()?;
      let bytes = fs::read(path).ok()?;
-      let content =
-        deno_graph::source::decode_owned_source(specifier, bytes, None).ok()?;
+      let content = bytes_to_content(
+        specifier,
+        MediaType::from_specifier(specifier),
+        bytes,
+        None,
+      )
+      .ok()?;
      Document::new(
        specifier.clone(),
        content.into(),
        None,
        None,
        None,
-        is_cjs_resolver,
        resolver.clone(),
        config.clone(),
        cache,
@ -908,7 +903,6 @@ impl FileSystemDocuments {
        None,
        None,
        None,
-        is_cjs_resolver,
        resolver.clone(),
        config.clone(),
        cache,
@ -923,20 +917,24 @@ impl FileSystemDocuments {
          specifier,
          Some(&cached_file.metadata.headers),
        );
-      let content = deno_graph::source::decode_owned_source(
+      let media_type = resolve_media_type(
        specifier,
+        Some(&cached_file.metadata.headers),
+        None,
+      );
+      let content = bytes_to_content(
+        specifier,
+        media_type,
        cached_file.content,
        maybe_charset,
      )
      .ok()?;
-      let maybe_headers = Some(cached_file.metadata.headers);
      Document::new(
        specifier.clone(),
        content.into(),
        None,
        None,
-        maybe_headers,
-        is_cjs_resolver,
+        Some(cached_file.metadata.headers),
        resolver.clone(),
        config.clone(),
        cache,
@ -977,8 +975,6 @@ pub struct Documents {
  /// The DENO_DIR that the documents looks for non-file based modules.
  cache: Arc<LspCache>,
  config: Arc<Config>,
-  /// Resolver for detecting if a document is CJS or ESM.
-  is_cjs_resolver: Arc<LspIsCjsResolver>,
  /// A resolver that takes into account currently loaded import map and JSX
  /// settings.
  resolver: Arc<LspResolver>,
@ -989,12 +985,7 @@ pub struct Documents {
  open_docs: HashMap<ModuleSpecifier, Arc<Document>>,
  /// Documents stored on the file system.
  file_system_docs: Arc<FileSystemDocuments>,
-  /// The npm package requirements found in npm specifiers.
-  npm_reqs_by_scope:
-    Arc<BTreeMap<Option<ModuleSpecifier>, BTreeSet<PackageReq>>>,
-  /// Config scopes that contain a node: specifier such that a @types/node
-  /// package should be injected.
-  scopes_with_node_specifier: Arc<HashSet<Option<ModuleSpecifier>>>,
+  dep_info_by_scope: Arc<BTreeMap<Option<ModuleSpecifier>, Arc<ScopeDepInfo>>>,
 }

 impl Documents {
@ -1019,7 +1010,6 @@ impl Documents {
      // the cache for remote modules here in order to get the
      // x-typescript-types?
      None,
-      &self.is_cjs_resolver,
      self.resolver.clone(),
      self.config.clone(),
      &self.cache,
@ -1054,7 +1044,7 @@ impl Documents {
        ))
      })?;
    self.dirty = true;
-    let doc = doc.with_change(&self.is_cjs_resolver, version, changes)?;
+    let doc = doc.with_change(version, changes)?;
    self.open_docs.insert(doc.specifier().clone(), doc.clone());
    Ok(doc)
  }
@ -1157,17 +1147,20 @@ impl Documents {
    false
  }

-  pub fn npm_reqs_by_scope(
+  pub fn dep_info_by_scope(
    &mut self,
-  ) -> Arc<BTreeMap<Option<ModuleSpecifier>, BTreeSet<PackageReq>>> {
-    self.calculate_npm_reqs_if_dirty();
-    self.npm_reqs_by_scope.clone()
+  ) -> Arc<BTreeMap<Option<ModuleSpecifier>, Arc<ScopeDepInfo>>> {
+    self.calculate_dep_info_if_dirty();
+    self.dep_info_by_scope.clone()
  }

-  pub fn scopes_with_node_specifier(
-    &self,
-  ) -> &Arc<HashSet<Option<ModuleSpecifier>>> {
-    &self.scopes_with_node_specifier
+  pub fn scopes_with_node_specifier(&self) -> HashSet<Option<ModuleSpecifier>> {
+    self
+      .dep_info_by_scope
+      .iter()
+      .filter(|(_, i)| i.has_node_specifier)
+      .map(|(s, _)| s.clone())
+      .collect::<HashSet<_>>()
  }

  /// Return a document for the specifier.
@ -1183,7 +1176,6 @@ impl Documents {
      if let Some(old_doc) = old_doc {
        self.file_system_docs.get(
          specifier,
-          &self.is_cjs_resolver,
          &self.resolver,
          &self.config,
          &self.cache,
@ -1208,7 +1200,6 @@ impl Documents {
    } else {
      self.file_system_docs.get(
        &specifier,
-        &self.is_cjs_resolver,
        &self.resolver,
        &self.config,
        &self.cache,
@ -1263,7 +1254,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)>> {
@ -1273,11 +1265,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);
@ -1292,14 +1285,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 {
@ -1308,19 +1301,16 @@ impl Documents {
      } else if let Ok(specifier) =
        self.resolver.as_cli_resolver(file_referrer).resolve(
          raw_specifier,
-          &deno_graph::Range {
-            specifier: referrer.clone(),
-            start: deno_graph::Position::zeroed(),
-            end: deno_graph::Position::zeroed(),
-          },
-          referrer_kind,
-          ResolutionMode::Types,
+          referrer,
+          deno_graph::Position::zeroed(),
+          resolution_mode,
+          NodeResolutionKind::Types,
        )
      {
        results.push(self.resolve_dependency(
          &specifier,
          referrer,
-          referrer_kind,
+          resolution_mode,
          file_referrer,
        ));
      } else {
@ -1339,7 +1329,6 @@ impl Documents {
  ) {
    self.config = Arc::new(config.clone());
    self.cache = Arc::new(cache.clone());
-    self.is_cjs_resolver = Arc::new(LspIsCjsResolver::new(cache));
    self.resolver = resolver.clone();

    node_resolver::PackageJsonThreadLocalCache::clear();
@ -1363,21 +1352,14 @@ impl Documents {
        if !config.specifier_enabled(doc.specifier()) {
          continue;
        }
-        *doc = doc.with_new_config(
-          &self.is_cjs_resolver,
-          self.resolver.clone(),
-          self.config.clone(),
-        );
+        *doc = doc.with_new_config(self.resolver.clone(), self.config.clone());
      }
      for mut doc in self.file_system_docs.docs.iter_mut() {
        if !config.specifier_enabled(doc.specifier()) {
          continue;
        }
-        *doc.value_mut() = doc.with_new_config(
-          &self.is_cjs_resolver,
-          self.resolver.clone(),
-          self.config.clone(),
-        );
+        *doc.value_mut() =
+          doc.with_new_config(self.resolver.clone(), self.config.clone());
      }
      self.open_docs = open_docs;
      let mut preload_count = 0;
@ -1394,7 +1376,6 @@ impl Documents {
        {
          fs_docs.refresh_document(
            specifier,
-            &self.is_cjs_resolver,
            &self.resolver,
            &self.config,
            &self.cache,
@ -1410,34 +1391,46 @@ impl Documents {
  /// Iterate through the documents, building a map where the key is a unique
  /// document and the value is a set of specifiers that depend on that
  /// document.
-  fn calculate_npm_reqs_if_dirty(&mut self) {
-    let mut npm_reqs_by_scope: BTreeMap<_, BTreeSet<_>> = Default::default();
-    let mut scopes_with_specifier = HashSet::new();
+  fn calculate_dep_info_if_dirty(&mut self) {
+    let mut dep_info_by_scope: BTreeMap<_, ScopeDepInfo> = Default::default();
    let is_fs_docs_dirty = self.file_system_docs.set_dirty(false);
    if !is_fs_docs_dirty && !self.dirty {
      return;
    }
    let mut visit_doc = |doc: &Arc<Document>| {
      let scope = doc.scope();
-      let reqs = npm_reqs_by_scope.entry(scope.cloned()).or_default();
+      let dep_info = dep_info_by_scope.entry(scope.cloned()).or_default();
      for dependency in doc.dependencies().values() {
-        if let Some(dep) = dependency.get_code() {
+        let code_specifier = dependency.get_code();
+        let type_specifier = dependency.get_type();
+        if let Some(dep) = code_specifier {
          if dep.scheme() == "node" {
-            scopes_with_specifier.insert(scope.cloned());
+            dep_info.has_node_specifier = true;
          }
          if let Ok(reference) = NpmPackageReqReference::from_specifier(dep) {
-            reqs.insert(reference.into_inner().req);
+            dep_info.npm_reqs.insert(reference.into_inner().req);
          }
        }
-        if let Some(dep) = dependency.get_type() {
+        if let Some(dep) = type_specifier {
          if let Ok(reference) = NpmPackageReqReference::from_specifier(dep) {
-            reqs.insert(reference.into_inner().req);
+            dep_info.npm_reqs.insert(reference.into_inner().req);
+          }
+        }
+        if dependency.maybe_deno_types_specifier.is_some() {
+          if let (Some(code_specifier), Some(type_specifier)) =
+            (code_specifier, type_specifier)
+          {
+            if MediaType::from_specifier(type_specifier).is_declaration() {
+              dep_info
+                .deno_types_to_code_resolutions
+                .insert(type_specifier.clone(), code_specifier.clone());
+            }
          }
        }
      }
      if let Some(dep) = doc.maybe_types_dependency().maybe_specifier() {
        if let Ok(reference) = NpmPackageReqReference::from_specifier(dep) {
-          reqs.insert(reference.into_inner().req);
+          dep_info.npm_reqs.insert(reference.into_inner().req);
        }
      }
    };
@ -1448,14 +1441,46 @@ impl Documents {
      visit_doc(doc);
    }

-    // fill the reqs from the lockfile
    for (scope, config_data) in self.config.tree.data_by_scope().as_ref() {
+      let dep_info = dep_info_by_scope.entry(Some(scope.clone())).or_default();
+      (|| {
+        let config_file = config_data.maybe_deno_json()?;
+        let jsx_config =
+          config_file.to_maybe_jsx_import_source_config().ok()??;
+        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 type_specifier = cli_resolver
+          .resolve(
+            type_specifier,
+            &jsx_config.base_url,
+            deno_graph::Position::zeroed(),
+            // todo(dsherret): this is wrong because it doesn't consider CJS referrers
+            ResolutionMode::Import,
+            NodeResolutionKind::Types,
+          )
+          .ok()?;
+        let code_specifier = cli_resolver
+          .resolve(
+            code_specifier,
+            &jsx_config.base_url,
+            deno_graph::Position::zeroed(),
+            // todo(dsherret): this is wrong because it doesn't consider CJS referrers
+            ResolutionMode::Import,
+            NodeResolutionKind::Execution,
+          )
+          .ok()?;
+        dep_info
+          .deno_types_to_code_resolutions
+          .insert(type_specifier, code_specifier);
+        Some(())
+      })();
+      // fill the reqs from the lockfile
      if let Some(lockfile) = config_data.lockfile.as_ref() {
-        let reqs = npm_reqs_by_scope.entry(Some(scope.clone())).or_default();
        let lockfile = lockfile.lock();
        for dep_req in lockfile.content.packages.specifiers.keys() {
          if dep_req.kind == deno_semver::package::PackageKind::Npm {
-            reqs.insert(dep_req.req.clone());
+            dep_info.npm_reqs.insert(dep_req.req.clone());
          }
        }
      }
@ -1464,15 +1489,22 @@ impl Documents {
    // Ensure a @types/node package exists when any module uses a node: specifier.
    // Unlike on the command line, here we just add @types/node to the npm package
    // requirements since this won't end up in the lockfile.
-    for scope in &scopes_with_specifier {
-      let reqs = npm_reqs_by_scope.entry(scope.clone()).or_default();
-      if !reqs.iter().any(|r| r.name == "@types/node") {
-        reqs.insert(PackageReq::from_str("@types/node").unwrap());
+    for dep_info in dep_info_by_scope.values_mut() {
+      if dep_info.has_node_specifier
+        && !dep_info.npm_reqs.iter().any(|r| r.name == "@types/node")
+      {
+        dep_info
+          .npm_reqs
+          .insert(PackageReq::from_str("@types/node").unwrap());
      }
    }

-    self.npm_reqs_by_scope = Arc::new(npm_reqs_by_scope);
-    self.scopes_with_node_specifier = Arc::new(scopes_with_specifier);
+    self.dep_info_by_scope = Arc::new(
+      dep_info_by_scope
+        .into_iter()
+        .map(|(s, i)| (s, Arc::new(i)))
+        .collect(),
+    );
    self.dirty = false;
  }

@ -1480,7 +1512,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:") {
@ -1497,7 +1529,7 @@ impl Documents {
      let (s, mt) = self.resolver.npm_to_file_url(
        &npm_ref,
        referrer,
-        referrer_kind,
+        resolution_mode,
        file_referrer,
      )?;
      specifier = s;
@ -1509,8 +1541,12 @@ 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);
-      self.resolve_dependency(types, &specifier, specifier_kind, file_referrer)
+      self.resolve_dependency(
+        types,
+        &specifier,
+        doc.resolution_mode(),
+        file_referrer,
+      )
    } else {
      Some((doc.specifier().clone(), doc.media_type()))
    }
@ -1578,19 +1614,25 @@ fn parse_and_analyze_module(
  maybe_headers: Option<&HashMap<String, String>>,
  media_type: MediaType,
  file_referrer: Option<&ModuleSpecifier>,
-  is_cjs_resolver: &LspIsCjsResolver,
  resolver: &LspResolver,
-) -> (Option<ParsedSourceResult>, Option<ModuleResult>) {
+) -> (
+  Option<ParsedSourceResult>,
+  Option<ModuleResult>,
+  ResolutionMode,
+) {
  let parsed_source_result = parse_source(specifier.clone(), text, media_type);
-  let module_result = analyze_module(
+  let (module_result, resolution_mode) = analyze_module(
    specifier,
    &parsed_source_result,
    maybe_headers,
    file_referrer,
-    is_cjs_resolver,
    resolver,
  );
-  (Some(parsed_source_result), Some(module_result))
+  (
+    Some(parsed_source_result),
+    Some(module_result),
+    resolution_mode,
+  )
 }

 fn parse_source(
@ -1613,44 +1655,69 @@ fn analyze_module(
  parsed_source_result: &ParsedSourceResult,
  maybe_headers: Option<&HashMap<String, String>>,
  file_referrer: Option<&ModuleSpecifier>,
-  is_cjs_resolver: &LspIsCjsResolver,
  resolver: &LspResolver,
-) -> ModuleResult {
+) -> (ModuleResult, ResolutionMode) {
  match parsed_source_result {
    Ok(parsed_source) => {
      let npm_resolver = resolver.create_graph_npm_resolver(file_referrer);
      let cli_resolver = resolver.as_cli_resolver(file_referrer);
+      let is_cjs_resolver = resolver.as_is_cjs_resolver(file_referrer);
      let config_data = resolver.as_config_data(file_referrer);
      let valid_referrer = specifier.clone();
      let jsx_import_source_config =
        config_data.and_then(|d| d.maybe_jsx_import_source_config());
+      let module_resolution_mode = is_cjs_resolver.get_lsp_resolution_mode(
+        &specifier,
+        Some(parsed_source.compute_is_script()),
+      );
      let resolver = SingleReferrerGraphResolver {
        valid_referrer: &valid_referrer,
-        referrer_kind: is_cjs_resolver.get_lsp_referrer_kind(
-          &specifier,
-          Some(parsed_source.compute_is_script()),
-        ),
+        module_resolution_mode,
        cli_resolver,
        jsx_import_source_config: jsx_import_source_config.as_ref(),
      };
-      Ok(deno_graph::parse_module_from_ast(
-        deno_graph::ParseModuleFromAstOptions {
-          graph_kind: deno_graph::GraphKind::TypesOnly,
-          specifier,
-          maybe_headers,
-          parsed_source,
-          // use a null file system because there's no need to bother resolving
-          // dynamic imports like import(`./dir/${something}`) in the LSP
-          file_system: &deno_graph::source::NullFileSystem,
-          jsr_url_provider: &CliJsrUrlProvider,
-          maybe_resolver: Some(&resolver),
-          maybe_npm_resolver: Some(&npm_resolver),
-        },
-      ))
+      (
+        Ok(deno_graph::parse_module_from_ast(
+          deno_graph::ParseModuleFromAstOptions {
+            graph_kind: deno_graph::GraphKind::TypesOnly,
+            specifier,
+            maybe_headers,
+            parsed_source,
+            // use a null file system because there's no need to bother resolving
+            // dynamic imports like import(`./dir/${something}`) in the LSP
+            file_system: &deno_graph::source::NullFileSystem,
+            jsr_url_provider: &CliJsrUrlProvider,
+            maybe_resolver: Some(&resolver),
+            maybe_npm_resolver: Some(&npm_resolver),
+          },
+        )),
+        module_resolution_mode,
+      )
    }
-    Err(err) => Err(deno_graph::ModuleGraphError::ModuleError(
-      deno_graph::ModuleError::ParseErr(specifier, err.clone()),
-    )),
+    Err(err) => (
+      Err(deno_graph::ModuleGraphError::ModuleError(
+        deno_graph::ModuleError::ParseErr(specifier, err.clone()),
+      )),
+      ResolutionMode::Import,
+    ),
+  }
+}
+
+fn bytes_to_content(
+  specifier: &ModuleSpecifier,
+  media_type: MediaType,
+  bytes: Vec<u8>,
+  maybe_charset: Option<&str>,
+) -> Result<String, AnyError> {
+  if media_type == MediaType::Wasm {
+    // we use the dts representation for Wasm modules
+    Ok(deno_graph::source::wasm::wasm_module_to_dts(&bytes)?)
+  } else {
+    Ok(deno_graph::source::decode_owned_source(
+      specifier,
+      bytes,
+      maybe_charset,
+    )?)
  }
 }

--- 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;
@ -78,7 +79,6 @@ use super::parent_process_checker;
 use super::performance::Performance;
 use super::refactor;
 use super::registries::ModuleRegistry;
-use super::resolver::LspIsCjsResolver;
 use super::resolver::LspResolver;
 use super::testing;
 use super::text;
@ -146,7 +146,6 @@ pub struct StateSnapshot {
  pub project_version: usize,
  pub assets: AssetsSnapshot,
  pub config: Arc<Config>,
-  pub is_cjs_resolver: Arc<LspIsCjsResolver>,
  pub documents: Arc<Documents>,
  pub resolver: Arc<LspResolver>,
 }
@ -206,7 +205,6 @@ pub struct Inner {
  pub documents: Documents,
  http_client_provider: Arc<HttpClientProvider>,
  initial_cwd: PathBuf,
-  pub is_cjs_resolver: Arc<LspIsCjsResolver>,
  jsr_search_api: CliJsrSearchApi,
  /// Handles module registries, which allow discovery of modules
  module_registry: ModuleRegistry,
@ -484,7 +482,6 @@ impl Inner {
    let initial_cwd = std::env::current_dir().unwrap_or_else(|_| {
      panic!("Could not resolve current working directory")
    });
-    let is_cjs_resolver = Arc::new(LspIsCjsResolver::new(&cache));

    Self {
      assets,
@ -496,7 +493,6 @@ impl Inner {
      documents,
      http_client_provider,
      initial_cwd: initial_cwd.clone(),
-      is_cjs_resolver,
      jsr_search_api,
      project_version: 0,
      task_queue: Default::default(),
@ -607,7 +603,6 @@ impl Inner {
      project_version: self.project_version,
      assets: self.assets.snapshot(),
      config: Arc::new(self.config.clone()),
-      is_cjs_resolver: self.is_cjs_resolver.clone(),
      documents: Arc::new(self.documents.clone()),
      resolver: self.resolver.snapshot(),
    })
@ -629,7 +624,6 @@ impl Inner {
      }
    });
    self.cache = LspCache::new(global_cache_url);
-    self.is_cjs_resolver = Arc::new(LspIsCjsResolver::new(&self.cache));
    let deno_dir = self.cache.deno_dir();
    let workspace_settings = self.config.workspace_settings();
    let maybe_root_path = self
@ -993,13 +987,10 @@ impl Inner {
              let resolver = inner.resolver.as_cli_resolver(Some(&referrer));
              let Ok(specifier) = resolver.resolve(
                &specifier,
-                &deno_graph::Range {
-                  specifier: referrer.clone(),
-                  start: deno_graph::Position::zeroed(),
-                  end: deno_graph::Position::zeroed(),
-                },
-                NodeModuleKind::Esm,
-                deno_graph::source::ResolutionMode::Types,
+                &referrer,
+                deno_graph::Position::zeroed(),
+                ResolutionMode::Import,
+                NodeResolutionKind::Types,
              ) else {
                return;
              };
@ -1036,7 +1027,7 @@ impl Inner {

    // refresh the npm specifiers because it might have discovered
    // a @types/node package and now's a good time to do that anyway
-    self.refresh_npm_specifiers().await;
+    self.refresh_dep_info().await;

    self.project_changed([], true);
  }
@ -1082,7 +1073,7 @@ impl Inner {
    );
    if document.is_diagnosable() {
      self.project_changed([(document.specifier(), ChangeKind::Opened)], false);
-      self.refresh_npm_specifiers().await;
+      self.refresh_dep_info().await;
      self.diagnostics_server.invalidate(&[specifier]);
      self.send_diagnostics_update();
      self.send_testing_update();
@ -1103,8 +1094,8 @@ impl Inner {
      Ok(document) => {
        if document.is_diagnosable() {
          let old_scopes_with_node_specifier =
-            self.documents.scopes_with_node_specifier().clone();
-          self.refresh_npm_specifiers().await;
+            self.documents.scopes_with_node_specifier();
+          self.refresh_dep_info().await;
          let mut config_changed = false;
          if !self
            .documents
@ -1155,13 +1146,15 @@ impl Inner {
    }));
  }

-  async fn refresh_npm_specifiers(&mut self) {
-    let package_reqs = self.documents.npm_reqs_by_scope();
+  async fn refresh_dep_info(&mut self) {
+    let dep_info_by_scope = self.documents.dep_info_by_scope();
    let resolver = self.resolver.clone();
    // spawn due to the lsp's `Send` requirement
-    spawn(async move { resolver.set_npm_reqs(&package_reqs).await })
-      .await
-      .ok();
+    spawn(
+      async move { resolver.set_dep_info_by_scope(&dep_info_by_scope).await },
+    )
+    .await
+    .ok();
  }

  async fn did_close(&mut self, params: DidCloseTextDocumentParams) {
@ -1180,7 +1173,7 @@ impl Inner {
      .uri_to_specifier(&params.text_document.uri, LspUrlKind::File);
    self.diagnostics_state.clear(&specifier);
    if self.is_diagnosable(&specifier) {
-      self.refresh_npm_specifiers().await;
+      self.refresh_dep_info().await;
      self.diagnostics_server.invalidate(&[specifier.clone()]);
      self.send_diagnostics_update();
      self.send_testing_update();
@ -1394,13 +1387,18 @@ impl Inner {
        .fmt_config_for_specifier(&specifier)
        .options
        .clone();
-      fmt_options.use_tabs = Some(!params.options.insert_spaces);
-      fmt_options.indent_width = Some(params.options.tab_size as u8);
      let config_data = self.config.tree.data_for_specifier(&specifier);
+      if !config_data.is_some_and(|d| d.maybe_deno_json().is_some()) {
+        fmt_options.use_tabs = Some(!params.options.insert_spaces);
+        fmt_options.indent_width = Some(params.options.tab_size as u8);
+      }
      let unstable_options = UnstableFmtOptions {
        component: config_data
          .map(|d| d.unstable.contains("fmt-component"))
          .unwrap_or(false),
+        sql: config_data
+          .map(|d| d.unstable.contains("fmt-sql"))
+          .unwrap_or(false),
      };
      let document = document.clone();
      move || {
@ -1633,8 +1631,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))
-        .unwrap_or(NodeModuleKind::Esm);
+        .map(|d| d.resolution_mode())
+        .unwrap_or(ResolutionMode::Import);
      let mut includes_no_cache = false;
      for diagnostic in &fixable_diagnostics {
        match diagnostic.source.as_deref() {
@ -1857,8 +1855,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))
-            .unwrap_or(NodeModuleKind::Esm),
+            .map(|d| d.resolution_mode())
+            .unwrap_or(ResolutionMode::Import),
          &combined_code_actions.changes,
          self,
        )
@ -1914,8 +1912,8 @@ impl Inner {
          &action_data.specifier,
          asset_or_doc
            .document()
-            .map(|d| self.is_cjs_resolver.get_doc_module_kind(d))
-            .unwrap_or(NodeModuleKind::Esm),
+            .map(|d| d.resolution_mode())
+            .unwrap_or(ResolutionMode::Import),
          &refactor_edit_info.edits,
          self,
        )
@ -2265,7 +2263,6 @@ impl Inner {
        &self.jsr_search_api,
        &self.npm_search_api,
        &self.documents,
-        &self.is_cjs_resolver,
        self.resolver.as_ref(),
        self
          .config
@ -3600,15 +3597,16 @@ impl Inner {

    if byonm {
      roots.retain(|s| s.scheme() != "npm");
-    } else if let Some(npm_reqs) = self
+    } else if let Some(dep_info) = self
      .documents
-      .npm_reqs_by_scope()
+      .dep_info_by_scope()
      .get(&config_data.map(|d| d.scope.as_ref().clone()))
    {
      // always include the npm packages since resolution of one npm package
      // might affect the resolution of other npm packages
      roots.extend(
-        npm_reqs
+        dep_info
+          .npm_reqs
          .iter()
          .map(|req| ModuleSpecifier::parse(&format!("npm:{}", req)).unwrap()),
      );
@ -3629,9 +3627,8 @@ impl Inner {
          deno_json_cache: None,
          pkg_json_cache: None,
          workspace_cache: None,
-          config_parse_options: deno_config::deno_json::ConfigParseOptions {
-            include_task_comments: false,
-          },
+          config_parse_options:
+            deno_config::deno_json::ConfigParseOptions::default(),
          additional_config_file_names: &[],
          discover_pkg_json: !has_flag_env_var("DENO_NO_PACKAGE_JSON"),
          maybe_vendor_override: if force_global_cache {
@ -3686,7 +3683,7 @@ impl Inner {

  async fn post_cache(&mut self) {
    self.resolver.did_cache();
-    self.refresh_npm_specifiers().await;
+    self.refresh_dep_info().await;
    self.diagnostics_server.invalidate_all();
    self.project_changed([], true);
    self.ts_server.cleanup_semantic_cache(self.snapshot()).await;
@ -3774,14 +3771,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() {
-        for (name, value) in tasks {
-          let Some(command) = value.as_str() else {
-            continue;
-          };
+      if let Some(tasks) = config_file.to_tasks_config().ok().flatten() {
+        for (name, def) in tasks {
          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
@ -7,14 +7,14 @@ use deno_cache_dir::HttpCache;
 use deno_config::deno_json::JsxImportSourceConfig;
 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;
 use deno_npm::NpmSystemInfo;
-use deno_path_util::url_from_directory_path;
 use deno_path_util::url_to_file_path;
+use deno_resolver::cjs::IsCjsResolutionMode;
 use deno_resolver::npm::NpmReqResolverOptions;
 use deno_resolver::DenoResolverOptions;
 use deno_resolver::NodeAndNpmReqResolver;
@ -29,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::NodeResolutionMode;
+use node_resolver::NodeResolutionKind;
+use node_resolver::ResolutionMode;
 use std::borrow::Cow;
 use std::collections::BTreeMap;
 use std::collections::BTreeSet;
@ -39,7 +39,6 @@ use std::collections::HashSet;
 use std::sync::Arc;

 use super::cache::LspCache;
-use super::documents::Document;
 use super::jsr::JsrCacheResolver;
 use crate::args::create_default_npmrc;
 use crate::args::CacheSetting;
@ -47,6 +46,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;
@ -69,7 +70,6 @@ use crate::resolver::CliResolverOptions;
 use crate::resolver::IsCjsResolver;
 use crate::resolver::WorkerCliNpmGraphResolver;
 use crate::tsc::into_specifier_and_media_type;
-use crate::util::fs::canonicalize_path_maybe_not_exists;
 use crate::util::progress_bar::ProgressBar;
 use crate::util::progress_bar::ProgressBarStyle;

@ -77,6 +77,7 @@ use crate::util::progress_bar::ProgressBarStyle;
 struct LspScopeResolver {
  resolver: Arc<CliResolver>,
  in_npm_pkg_checker: Arc<dyn InNpmPackageChecker>,
+  is_cjs_resolver: Arc<IsCjsResolver>,
  jsr_resolver: Option<Arc<JsrCacheResolver>>,
  npm_resolver: Option<Arc<dyn CliNpmResolver>>,
  node_resolver: Option<Arc<NodeResolver>>,
@ -84,6 +85,7 @@ struct LspScopeResolver {
  pkg_json_resolver: Arc<PackageJsonResolver>,
  redirect_resolver: Option<Arc<RedirectResolver>>,
  graph_imports: Arc<IndexMap<ModuleSpecifier, GraphImport>>,
+  dep_info: Arc<Mutex<Arc<ScopeDepInfo>>>,
  package_json_deps_by_resolution: Arc<IndexMap<ModuleSpecifier, String>>,
  config_data: Option<Arc<ConfigData>>,
 }
@ -94,6 +96,7 @@ impl Default for LspScopeResolver {
    Self {
      resolver: factory.cli_resolver().clone(),
      in_npm_pkg_checker: factory.in_npm_pkg_checker().clone(),
+      is_cjs_resolver: factory.is_cjs_resolver().clone(),
      jsr_resolver: None,
      npm_resolver: None,
      node_resolver: None,
@ -101,6 +104,7 @@ impl Default for LspScopeResolver {
      pkg_json_resolver: factory.pkg_json_resolver().clone(),
      redirect_resolver: None,
      graph_imports: Default::default(),
+      dep_info: Default::default(),
      package_json_deps_by_resolution: Default::default(),
      config_data: None,
    }
@ -143,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(),
@ -177,9 +181,18 @@ impl LspScopeResolver {
                &req_ref,
                &referrer,
                // todo(dsherret): this is wrong because it doesn't consider CJS referrers
-                NodeModuleKind::Esm,
-                NodeResolutionMode::Types,
+                ResolutionMode::Import,
+                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
+                  ResolutionMode::Import,
+                  NodeResolutionKind::Execution,
+                )
+              })
              .ok()?,
          ))
          .0;
@ -193,6 +206,7 @@ impl LspScopeResolver {
    Self {
      resolver: cli_resolver,
      in_npm_pkg_checker,
+      is_cjs_resolver: factory.is_cjs_resolver().clone(),
      jsr_resolver,
      npm_pkg_req_resolver,
      npm_resolver,
@ -200,6 +214,7 @@ impl LspScopeResolver {
      pkg_json_resolver,
      redirect_resolver,
      graph_imports,
+      dep_info: Default::default(),
      package_json_deps_by_resolution,
      config_data: config_data.cloned(),
    }
@ -215,6 +230,7 @@ impl LspScopeResolver {
    Arc::new(Self {
      resolver: factory.cli_resolver().clone(),
      in_npm_pkg_checker: factory.in_npm_pkg_checker().clone(),
+      is_cjs_resolver: factory.is_cjs_resolver().clone(),
      jsr_resolver: self.jsr_resolver.clone(),
      npm_pkg_req_resolver: factory.npm_pkg_req_resolver().cloned(),
      npm_resolver: factory.npm_resolver().cloned(),
@ -222,6 +238,7 @@ impl LspScopeResolver {
      redirect_resolver: self.redirect_resolver.clone(),
      pkg_json_resolver: factory.pkg_json_resolver().clone(),
      graph_imports: self.graph_imports.clone(),
+      dep_info: self.dep_info.clone(),
      package_json_deps_by_resolution: self
        .package_json_deps_by_resolution
        .clone(),
@ -288,19 +305,24 @@ impl LspResolver {
    }
  }

-  pub async fn set_npm_reqs(
+  pub async fn set_dep_info_by_scope(
    &self,
-    reqs: &BTreeMap<Option<ModuleSpecifier>, BTreeSet<PackageReq>>,
+    dep_info_by_scope: &Arc<
+      BTreeMap<Option<ModuleSpecifier>, Arc<ScopeDepInfo>>,
+    >,
  ) {
    for (scope, resolver) in [(None, &self.unscoped)]
      .into_iter()
      .chain(self.by_scope.iter().map(|(s, r)| (Some(s), r)))
    {
+      let dep_info = dep_info_by_scope.get(&scope.cloned());
+      if let Some(dep_info) = dep_info {
+        *resolver.dep_info.lock() = dep_info.clone();
+      }
      if let Some(npm_resolver) = resolver.npm_resolver.as_ref() {
        if let Some(npm_resolver) = npm_resolver.as_managed() {
-          let reqs = reqs
-            .get(&scope.cloned())
-            .map(|reqs| reqs.iter().cloned().collect::<Vec<_>>())
+          let reqs = dep_info
+            .map(|i| i.npm_reqs.iter().cloned().collect::<Vec<_>>())
            .unwrap_or_default();
          if let Err(err) = npm_resolver.set_package_reqs(&reqs).await {
            lsp_warn!("Could not set npm package requirements: {:#}", err);
@ -326,6 +348,14 @@ impl LspResolver {
    resolver.resolver.create_graph_npm_resolver()
  }

+  pub fn as_is_cjs_resolver(
+    &self,
+    file_referrer: Option<&ModuleSpecifier>,
+  ) -> &IsCjsResolver {
+    let resolver = self.get_scope_resolver(file_referrer);
+    resolver.is_cjs_resolver.as_ref()
+  }
+
  pub fn as_config_data(
    &self,
    file_referrer: Option<&ModuleSpecifier>,
@ -405,7 +435,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);
@ -415,8 +445,8 @@ impl LspResolver {
        .resolve_req_reference(
          req_ref,
          referrer,
-          referrer_kind,
-          NodeResolutionMode::Types,
+          resolution_mode,
+          NodeResolutionKind::Types,
        )
        .ok()?,
    )))
@ -434,6 +464,19 @@ impl LspResolver {
      .cloned()
  }

+  pub fn deno_types_to_code_resolution(
+    &self,
+    specifier: &ModuleSpecifier,
+    file_referrer: Option<&ModuleSpecifier>,
+  ) -> Option<ModuleSpecifier> {
+    let resolver = self.get_scope_resolver(file_referrer);
+    let dep_info = resolver.dep_info.lock().clone();
+    dep_info
+      .deno_types_to_code_resolutions
+      .get(specifier)
+      .cloned()
+  }
+
  pub fn in_node_modules(&self, specifier: &ModuleSpecifier) -> bool {
    fn has_node_modules_dir(specifier: &ModuleSpecifier) -> bool {
      // consider any /node_modules/ directory as being in the node_modules
@ -460,7 +503,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()
@ -471,8 +514,8 @@ impl LspResolver {
      .resolve_if_for_npm_pkg(
        specifier_text,
        referrer,
-        referrer_kind,
-        NodeResolutionMode::Types,
+        resolution_mode,
+        NodeResolutionKind::Types,
      )
      .ok()
      .flatten()
@ -538,10 +581,18 @@ impl LspResolver {
  }
 }

+#[derive(Debug, Default, Clone)]
+pub struct ScopeDepInfo {
+  pub deno_types_to_code_resolutions: HashMap<ModuleSpecifier, ModuleSpecifier>,
+  pub npm_reqs: BTreeSet<PackageReq>,
+  pub has_node_specifier: bool,
+}
+
 #[derive(Default)]
 struct ResolverFactoryServices {
  cli_resolver: Deferred<Arc<CliResolver>>,
  in_npm_pkg_checker: Deferred<Arc<dyn InNpmPackageChecker>>,
+  is_cjs_resolver: Deferred<Arc<IsCjsResolver>>,
  node_resolver: Deferred<Option<Arc<NodeResolver>>>,
  npm_pkg_req_resolver: Deferred<Option<Arc<CliNpmReqResolver>>>,
  npm_resolver: Option<Arc<dyn CliNpmResolver>>,
@ -705,6 +756,23 @@ impl<'a> ResolverFactory<'a> {
    })
  }

+  pub fn is_cjs_resolver(&self) -> &Arc<IsCjsResolver> {
+    self.services.is_cjs_resolver.get_or_init(|| {
+      Arc::new(IsCjsResolver::new(
+        self.in_npm_pkg_checker().clone(),
+        self.pkg_json_resolver().clone(),
+        if self
+          .config_data
+          .is_some_and(|d| d.unstable.contains("detect-cjs"))
+        {
+          IsCjsResolutionMode::ImplicitTypeCommonJs
+        } else {
+          IsCjsResolutionMode::ExplicitTypeCommonJs
+        },
+      ))
+    })
+  }
+
  pub fn node_resolver(&self) -> Option<&Arc<NodeResolver>> {
    self
      .services
@ -764,99 +832,10 @@ impl std::fmt::Debug for RedirectResolver {
  }
 }

-#[derive(Debug)]
-pub struct LspIsCjsResolver {
-  inner: IsCjsResolver,
-}
-
-impl Default for LspIsCjsResolver {
-  fn default() -> Self {
-    LspIsCjsResolver::new(&Default::default())
-  }
-}
-
-impl LspIsCjsResolver {
-  pub fn new(cache: &LspCache) -> Self {
-    #[derive(Debug)]
-    struct LspInNpmPackageChecker {
-      global_cache_dir: ModuleSpecifier,
-    }
-
-    impl LspInNpmPackageChecker {
-      pub fn new(cache: &LspCache) -> Self {
-        let npm_folder_path = cache.deno_dir().npm_folder_path();
-        Self {
-          global_cache_dir: url_from_directory_path(
-            &canonicalize_path_maybe_not_exists(&npm_folder_path)
-              .unwrap_or(npm_folder_path),
-          )
-          .unwrap_or_else(|_| {
-            ModuleSpecifier::parse("file:///invalid/").unwrap()
-          }),
-        }
-      }
-    }
-
-    impl InNpmPackageChecker for LspInNpmPackageChecker {
-      fn in_npm_package(&self, specifier: &ModuleSpecifier) -> bool {
-        if specifier.scheme() != "file" {
-          return false;
-        }
-        if specifier
-          .as_str()
-          .starts_with(self.global_cache_dir.as_str())
-        {
-          return true;
-        }
-        specifier.as_str().contains("/node_modules/")
-      }
-    }
-
-    let fs = Arc::new(deno_fs::RealFs);
-    let pkg_json_resolver = Arc::new(PackageJsonResolver::new(
-      deno_runtime::deno_node::DenoFsNodeResolverEnv::new(fs.clone()),
-    ));
-
-    LspIsCjsResolver {
-      inner: IsCjsResolver::new(
-        Arc::new(LspInNpmPackageChecker::new(cache)),
-        pkg_json_resolver,
-        crate::resolver::IsCjsResolverOptions {
-          detect_cjs: true,
-          is_node_main: false,
-        },
-      ),
-    }
-  }
-
-  pub fn get_maybe_doc_module_kind(
-    &self,
-    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 {
-    self.get_lsp_referrer_kind(document.specifier(), document.is_script())
-  }
-
-  pub fn get_lsp_referrer_kind(
-    &self,
-    specifier: &ModuleSpecifier,
-    is_script: Option<bool>,
-  ) -> NodeModuleKind {
-    self.inner.get_lsp_referrer_kind(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>,
 }
@ -885,16 +864,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,
-      self.referrer_kind,
-      mode,
+      &referrer_range.specifier,
+      referrer_range.range.start,
+      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;
@ -3417,9 +3417,18 @@ fn parse_code_actions(
          additional_text_edits.extend(change.text_changes.iter().map(|tc| {
            let mut text_edit = tc.as_text_edit(asset_or_doc.line_index());
            if let Some(specifier_rewrite) = &data.specifier_rewrite {
-              text_edit.new_text = text_edit
-                .new_text
-                .replace(&specifier_rewrite.0, &specifier_rewrite.1);
+              text_edit.new_text = text_edit.new_text.replace(
+                &specifier_rewrite.old_specifier,
+                &specifier_rewrite.new_specifier,
+              );
+              if let Some(deno_types_specifier) =
+                &specifier_rewrite.new_deno_types_specifier
+              {
+                text_edit.new_text = format!(
+                  "// @deno-types=\"{}\"\n{}",
+                  deno_types_specifier, &text_edit.new_text
+                );
+              }
            }
            text_edit
          }));
@ -3578,17 +3587,23 @@ impl CompletionEntryDetails {
    let mut text_edit = original_item.text_edit.clone();
    if let Some(specifier_rewrite) = &data.specifier_rewrite {
      if let Some(text_edit) = &mut text_edit {
-        match text_edit {
-          lsp::CompletionTextEdit::Edit(text_edit) => {
-            text_edit.new_text = text_edit
-              .new_text
-              .replace(&specifier_rewrite.0, &specifier_rewrite.1);
-          }
+        let new_text = match text_edit {
+          lsp::CompletionTextEdit::Edit(text_edit) => &mut text_edit.new_text,
          lsp::CompletionTextEdit::InsertAndReplace(insert_replace_edit) => {
-            insert_replace_edit.new_text = insert_replace_edit
-              .new_text
-              .replace(&specifier_rewrite.0, &specifier_rewrite.1);
+            &mut insert_replace_edit.new_text
          }
+        };
+        *new_text = new_text.replace(
+          &specifier_rewrite.old_specifier,
+          &specifier_rewrite.new_specifier,
+        );
+        if let Some(deno_types_specifier) =
+          &specifier_rewrite.new_deno_types_specifier
+        {
+          *new_text = format!(
+            "// @deno-types=\"{}\"\n{}",
+            deno_types_specifier, new_text
+          );
        }
      }
    }
@ -3693,6 +3708,13 @@ impl CompletionInfo {
  }
 }

+#[derive(Debug, Clone, Deserialize, Serialize)]
+pub struct CompletionSpecifierRewrite {
+  old_specifier: String,
+  new_specifier: String,
+  new_deno_types_specifier: Option<String>,
+}
+
 #[derive(Debug, Deserialize, Serialize)]
 #[serde(rename_all = "camelCase")]
 pub struct CompletionItemData {
@ -3705,7 +3727,7 @@ pub struct CompletionItemData {
  /// be rewritten by replacing the first string with the second. Intended for
  /// auto-import specifiers to be reverse-import-mapped.
  #[serde(skip_serializing_if = "Option::is_none")]
-  pub specifier_rewrite: Option<(String, String)>,
+  pub specifier_rewrite: Option<CompletionSpecifierRewrite>,
  #[serde(skip_serializing_if = "Option::is_none")]
  pub data: Option<Value>,
  pub use_code_snippet: bool,
@ -3927,20 +3949,40 @@ impl CompletionEntry {
    if let Some(source) = &self.source {
      let mut display_source = source.clone();
      if let Some(import_data) = &self.auto_import_data {
-        if let Some(new_module_specifier) = language_server
-          .get_ts_response_import_mapper(specifier)
+        let import_mapper =
+          language_server.get_ts_response_import_mapper(specifier);
+        if let Some(mut new_specifier) = import_mapper
          .check_specifier(&import_data.normalized, specifier)
          .or_else(|| relative_specifier(specifier, &import_data.normalized))
        {
-          if new_module_specifier.contains("/node_modules/") {
+          if new_specifier.contains("/node_modules/") {
            return None;
          }
-          display_source.clone_from(&new_module_specifier);
-          if new_module_specifier != import_data.raw.module_specifier {
-            specifier_rewrite = Some((
-              import_data.raw.module_specifier.clone(),
-              new_module_specifier,
-            ));
+          let mut new_deno_types_specifier = None;
+          if let Some(code_specifier) = language_server
+            .resolver
+            .deno_types_to_code_resolution(
+              &import_data.normalized,
+              Some(specifier),
+            )
+            .and_then(|s| {
+              import_mapper
+                .check_specifier(&s, specifier)
+                .or_else(|| relative_specifier(specifier, &s))
+            })
+          {
+            new_deno_types_specifier =
+              Some(std::mem::replace(&mut new_specifier, code_specifier));
+          }
+          display_source.clone_from(&new_specifier);
+          if new_specifier != import_data.raw.module_specifier
+            || new_deno_types_specifier.is_some()
+          {
+            specifier_rewrite = Some(CompletionSpecifierRewrite {
+              old_specifier: import_data.raw.module_specifier.clone(),
+              new_specifier,
+              new_deno_types_specifier,
+            });
          }
        } else if source.starts_with(jsr_url().as_str()) {
          return None;
@ -4246,9 +4288,7 @@ impl TscSpecifierMap {
      return specifier.to_string();
    }
    let mut specifier = original.to_string();
-    if specifier.contains("/node_modules/.deno/")
-      && !specifier.contains("/node_modules/@types/node/")
-    {
+    if !specifier.contains("/node_modules/@types/node/") {
      // The ts server doesn't give completions from files in
      // `node_modules/.deno/`. We work around it like this.
      specifier = specifier.replace("/node_modules/", "/$node_modules/");
@ -4409,14 +4449,12 @@ 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))
-          .unwrap_or(NodeModuleKind::Esm)
-          == NodeModuleKind::Cjs,
+          .map(|d| d.resolution_mode())
+          .unwrap_or(ResolutionMode::Import)
+          == ResolutionMode::Require,
      })
    };
-
  let serialized = serde_v8::to_v8(scope, maybe_load_response)?;
-
  state.performance.measure(mark);
  Ok(serialized)
 }
@ -4441,17 +4479,9 @@ fn op_release(
 fn op_resolve(
  state: &mut OpState,
  #[string] base: String,
-  is_base_cjs: bool,
-  #[serde] specifiers: Vec<String>,
+  #[serde] specifiers: Vec<(bool, String)>,
 ) -> Result<Vec<Option<(String, String)>>, AnyError> {
-  op_resolve_inner(
-    state,
-    ResolveArgs {
-      base,
-      is_base_cjs,
-      specifiers,
-    },
-  )
+  op_resolve_inner(state, ResolveArgs { base, specifiers })
 }

 struct TscRequestArray {
@ -4654,10 +4684,7 @@ fn op_script_names(state: &mut OpState) -> ScriptNames {
        let (types, _) = documents.resolve_dependency(
          types,
          specifier,
-          state
-            .state_snapshot
-            .is_cjs_resolver
-            .get_doc_module_kind(doc),
+          doc.resolution_mode(),
          doc.file_referrer(),
        )?;
        let types_doc = documents.get_or_load(&types, doc.file_referrer())?;
@ -5541,7 +5568,6 @@ mod tests {
      documents: Arc::new(documents),
      assets: Default::default(),
      config: Arc::new(config),
-      is_cjs_resolver: Default::default(),
      resolver,
    });
    let performance = Arc::new(Performance::default());
@ -5567,7 +5593,7 @@ mod tests {
    let (_tx, rx) = mpsc::unbounded_channel();
    let state =
      State::new(state_snapshot, Default::default(), Default::default(), rx);
-    let mut op_state = OpState::new(None);
+    let mut op_state = OpState::new(None, None);
    op_state.put(state);
    op_state
  }
@ -6392,8 +6418,7 @@ mod tests {
      &mut state,
      ResolveArgs {
        base: temp_dir.url().join("a.ts").unwrap().to_string(),
-        is_base_cjs: false,
-        specifiers: vec!["./b.ts".to_string()],
+        specifiers: vec![(false, "./b.ts".to_string())],
      },
    )
    .unwrap();
--- a/cli/main.rs
+++ b/cli/main.rs
@ -144,9 +144,7 @@ async fn run_subcommand(flags: Arc<Flags>) -> Result<i32, AnyError> {
    }
    DenoSubcommand::Init(init_flags) => {
      spawn_subcommand(async {
-        // make compiler happy since init_project is sync
-        tokio::task::yield_now().await;
-        tools::init::init_project(init_flags)
+        tools::init::init_project(init_flags).await
      })
    }
    DenoSubcommand::Info(info_flags) => {
@ -188,6 +186,11 @@ async fn run_subcommand(flags: Arc<Flags>) -> Result<i32, AnyError> {
        tools::lint::lint(flags, lint_flags).await
      }
    }),
+    DenoSubcommand::Outdated(update_flags) => {
+      spawn_subcommand(async move {
+        tools::registry::outdated(flags, update_flags).await
+      })
+    }
    DenoSubcommand::Repl(repl_flags) => {
      spawn_subcommand(async move { tools::repl::run(flags, repl_flags).await })
    }
@ -238,6 +241,9 @@ async fn run_subcommand(flags: Arc<Flags>) -> Result<i32, AnyError> {
                  cwd: None,
                  task: Some(run_flags.script.clone()),
                  is_run: true,
+                  recursive: false,
+                  filter: None,
+                  eval: false,
                };
                new_flags.subcommand = DenoSubcommand::Task(task_flags.clone());
                let result = tools::task::execute_script(Arc::new(new_flags), task_flags.clone()).await;
@ -442,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,15 +57,14 @@ 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;
 use deno_graph::Module;
 use deno_graph::ModuleGraph;
 use deno_graph::Resolution;
+use deno_graph::WasmModule;
 use deno_runtime::code_cache;
 use deno_runtime::deno_fs::FileSystem;
 use deno_runtime::deno_node::create_host_defined_options;
@ -75,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>,
@ -368,7 +368,9 @@ impl<TGraphContainer: ModuleGraphContainer>
    requested_module_type: RequestedModuleType,
  ) -> Result<ModuleSource, AnyError> {
    let code_source = self.load_code_source(specifier, maybe_referrer).await?;
-    let code = if self.shared.is_inspecting {
+    let code = if self.shared.is_inspecting
+      || code_source.media_type == MediaType::Wasm
+    {
      // we need the code with the source map in order for
      // it to work with --inspect or --inspect-brk
      code_source.code
@ -378,6 +380,7 @@ impl<TGraphContainer: ModuleGraphContainer>
    };
    let module_type = match code_source.media_type {
      MediaType::Json => ModuleType::Json,
+      MediaType::Wasm => ModuleType::Wasm,
      _ => ModuleType::JavaScript,
    };

@ -474,21 +477,6 @@ impl<TGraphContainer: ModuleGraphContainer>
    raw_specifier: &str,
    referrer: &ModuleSpecifier,
  ) -> Result<ModuleSpecifier, AnyError> {
-    if self.shared.in_npm_pkg_checker.in_npm_package(referrer) {
-      return Ok(
-        self
-          .shared
-          .node_resolver
-          .resolve(
-            raw_specifier,
-            referrer,
-            self.shared.cjs_tracker.get_referrer_kind(referrer),
-            NodeResolutionMode::Execution,
-          )?
-          .into_url(),
-      );
-    }
-
    let graph = self.graph_container.graph();
    let resolution = match graph.get(referrer) {
      Some(Module::Js(module)) => module
@ -509,13 +497,11 @@ impl<TGraphContainer: ModuleGraphContainer>
      }
      Resolution::None => Cow::Owned(self.shared.resolver.resolve(
        raw_specifier,
-        &deno_graph::Range {
-          specifier: referrer.clone(),
-          start: deno_graph::Position::zeroed(),
-          end: deno_graph::Position::zeroed(),
-        },
-        self.shared.cjs_tracker.get_referrer_kind(referrer),
-        ResolutionMode::Execution,
+        referrer,
+        deno_graph::Position::zeroed(),
+        // if we're here, that means it's resolving a dynamic import
+        ResolutionMode::Import,
+        NodeResolutionKind::Execution,
      )?),
    };

@ -528,8 +514,8 @@ impl<TGraphContainer: ModuleGraphContainer>
          .resolve_req_reference(
            &reference,
            referrer,
-            self.shared.cjs_tracker.get_referrer_kind(referrer),
-            NodeResolutionMode::Execution,
+            ResolutionMode::Import,
+            NodeResolutionKind::Execution,
          )
          .map_err(AnyError::from);
      }
@ -550,8 +536,8 @@ impl<TGraphContainer: ModuleGraphContainer>
            &package_folder,
            module.nv_reference.sub_path(),
            Some(referrer),
-            self.shared.cjs_tracker.get_referrer_kind(referrer),
-            NodeResolutionMode::Execution,
+            ResolutionMode::Import,
+            NodeResolutionKind::Execution,
          )
          .with_context(|| {
            format!("Could not resolve '{}'.", module.nv_reference)
@ -560,6 +546,7 @@ impl<TGraphContainer: ModuleGraphContainer>
      Some(Module::Node(module)) => module.specifier.clone(),
      Some(Module::Js(module)) => module.specifier.clone(),
      Some(Module::Json(module)) => module.specifier.clone(),
+      Some(Module::Wasm(module)) => module.specifier.clone(),
      Some(Module::External(module)) => {
        node::resolve_specifier_into_node_modules(
          &module.specifier,
@ -731,6 +718,13 @@ impl<TGraphContainer: ModuleGraphContainer>
          media_type: *media_type,
        })))
      }
+      Some(deno_graph::Module::Wasm(WasmModule {
+        source, specifier, ..
+      })) => Ok(Some(CodeOrDeferredEmit::Code(ModuleCodeStringSource {
+        code: ModuleSourceCode::Bytes(source.clone().into()),
+        found_url: specifier.clone(),
+        media_type: MediaType::Wasm,
+      }))),
      Some(
        deno_graph::Module::External(_)
        | deno_graph::Module::Node(_)
@ -809,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,
@ -1066,7 +1060,10 @@ impl<TGraphContainer: ModuleGraphContainer> NodeRequireLoader
    self.npm_resolver.ensure_read_permission(permissions, path)
  }

-  fn load_text_file_lossy(&self, path: &Path) -> Result<String, AnyError> {
+  fn load_text_file_lossy(
+    &self,
+    path: &Path,
+  ) -> Result<Cow<'static, str>, AnyError> {
    // todo(dsherret): use the preloaded module from the graph if available?
    let media_type = MediaType::from_path(path);
    let text = self.fs.read_text_file_lossy_sync(path, None)?;
@ -1081,15 +1078,18 @@ impl<TGraphContainer: ModuleGraphContainer> NodeRequireLoader
          .into(),
        );
      }
-      self.emitter.emit_parsed_source_sync(
-        &specifier,
-        media_type,
-        // this is probably not super accurate due to require esm, but probably ok.
-        // If we find this causes a lot of churn in the emit cache then we should
-        // investigate how we can make this better
-        ModuleKind::Cjs,
-        &text.into(),
-      )
+      self
+        .emitter
+        .emit_parsed_source_sync(
+          &specifier,
+          media_type,
+          // this is probably not super accurate due to require esm, but probably ok.
+          // If we find this causes a lot of churn in the emit cache then we should
+          // investigate how we can make this better
+          ModuleKind::Cjs,
+          &text.into(),
+        )
+        .map(Cow::Owned)
    } else {
      Ok(text)
    }
--- a/cli/node.rs
+++ b/cli/node.rs
@ -160,7 +160,7 @@ impl CjsCodeAnalyzer for CliCjsCodeAnalyzer {
          if let Ok(source_from_file) =
            self.fs.read_text_file_lossy_async(path, None).await
          {
-            Cow::Owned(source_from_file)
+            source_from_file
          } else {
            return Ok(ExtNodeCjsAnalysis::Cjs(CjsAnalysisExports {
              exports: vec![],
--- a/cli/npm/managed/mod.rs
+++ b/cli/npm/managed/mod.rs
@ -500,7 +500,7 @@ impl ManagedCliNpmResolver {
    self.resolve_pkg_folder_from_pkg_id(&pkg_id)
  }

-  fn resolve_pkg_id_from_pkg_req(
+  pub fn resolve_pkg_id_from_pkg_req(
    &self,
    req: &PackageReq,
  ) -> Result<NpmPackageId, PackageReqNotFoundError> {
--- 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/ops/bench.rs
+++ b/cli/ops/bench.rs
@ -51,7 +51,7 @@ fn op_bench_get_origin(state: &mut OpState) -> String {
 #[derive(Clone)]
 struct PermissionsHolder(Uuid, PermissionsContainer);

-#[op2]
+#[op2(stack_trace)]
 #[serde]
 pub fn op_pledge_test_permissions(
  state: &mut OpState,
--- a/cli/ops/testing.rs
+++ b/cli/ops/testing.rs
@ -46,7 +46,7 @@ deno_core::extension!(deno_test,
 #[derive(Clone)]
 struct PermissionsHolder(Uuid, PermissionsContainer);

-#[op2]
+#[op2(stack_trace)]
 #[serde]
 pub fn op_pledge_test_permissions(
  state: &mut OpState,
--- 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::NodeResolutionMode;
+use node_resolver::NodeResolutionKind;
+use node_resolver::ResolutionMode;
 use std::borrow::Cow;
 use std::path::Path;
 use std::path::PathBuf;
@ -38,12 +37,11 @@ use crate::node::CliNodeCodeTranslator;
 use crate::npm::CliNpmResolver;
 use crate::npm::InnerCliNpmResolverRef;
 use crate::util::sync::AtomicFlag;
-use crate::util::text_encoding::from_utf8_lossy_owned;
+use crate::util::text_encoding::from_utf8_lossy_cow;

 pub type CjsTracker = deno_resolver::cjs::CjsTracker<DenoFsNodeResolverEnv>;
 pub type IsCjsResolver =
  deno_resolver::cjs::IsCjsResolver<DenoFsNodeResolverEnv>;
-pub type IsCjsResolverOptions = deno_resolver::cjs::IsCjsResolverOptions;
 pub type CliSloppyImportsResolver =
  SloppyImportsResolver<SloppyImportsCachedFs>;
 pub type CliDenoResolver = deno_resolver::DenoResolver<
@ -64,7 +62,10 @@ pub struct ModuleCodeStringSource {
 pub struct CliDenoResolverFs(pub Arc<dyn FileSystem>);

 impl deno_resolver::fs::DenoResolverFs for CliDenoResolverFs {
-  fn read_to_string_lossy(&self, path: &Path) -> std::io::Result<String> {
+  fn read_to_string_lossy(
+    &self,
+    path: &Path,
+  ) -> std::io::Result<Cow<'static, str>> {
    self
      .0
      .read_text_file_lossy_sync(path, None)
@ -184,18 +185,21 @@ impl NpmModuleLoader {

    let code = if self.cjs_tracker.is_maybe_cjs(specifier, media_type)? {
      // translate cjs to esm if it's cjs and inject node globals
-      let code = from_utf8_lossy_owned(code);
+      let code = from_utf8_lossy_cow(code);
      ModuleSourceCode::String(
        self
          .node_code_translator
-          .translate_cjs_to_esm(specifier, Some(Cow::Owned(code)))
+          .translate_cjs_to_esm(specifier, Some(code))
          .await?
          .into_owned()
          .into(),
      )
    } else {
      // esm and json code is untouched
-      ModuleSourceCode::Bytes(code.into_boxed_slice().into())
+      ModuleSourceCode::Bytes(match code {
+        Cow::Owned(bytes) => bytes.into_boxed_slice().into(),
+        Cow::Borrowed(bytes) => bytes.into(),
+      })
    };

    Ok(ModuleCodeStringSource {
@ -247,25 +251,14 @@ impl CliResolver {
  pub fn resolve(
    &self,
    raw_specifier: &str,
-    referrer_range: &deno_graph::Range,
-    referrer_kind: NodeModuleKind,
-    mode: ResolutionMode,
+    referrer: &ModuleSpecifier,
+    referrer_range_start: deno_graph::Position,
+    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(
-        raw_specifier,
-        &referrer_range.specifier,
-        referrer_kind,
-        to_node_mode(mode),
-      )
+      .resolve(raw_specifier, referrer, resolution_mode, resolution_kind)
      .map_err(|err| match err.into_kind() {
        deno_resolver::DenoResolveErrorKind::MappedResolution(
          mapped_resolution_error,
@ -291,10 +284,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 +329,10 @@ impl<'a> deno_graph::source::NpmResolver for WorkerCliNpmGraphResolver<'a> {
    module_name: &str,
    range: &deno_graph::Range,
  ) {
-    let deno_graph::Range {
-      start, specifier, ..
-    } = range;
-    let line = start.line + 1;
-    let column = start.character + 1;
+    let start = range.range.start;
+    let specifier = &range.specifier;
    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/schemas/config-file.v1.json
+++ b/cli/schemas/config-file.v1.json
@ -431,8 +431,34 @@
      "type": "object",
      "patternProperties": {
        "^[A-Za-z][A-Za-z0-9_\\-:]*$": {
-          "type": "string",
-          "description": "Command to execute for this task name."
+          "oneOf": [
+            {
+              "type": "string",
+              "description": "Command to execute for this task name."
+            },
+            {
+              "type": "object",
+              "description": "A definition of a task to execute",
+              "properties": {
+                "description": {
+                  "type": "string",
+                  "description": "Description of a task that will be shown when running `deno task` without a task name"
+                },
+                "command": {
+                  "type": "string",
+                  "required": true,
+                  "description": "The task to execute"
+                },
+                "dependencies": {
+                  "type": "array",
+                  "items": {
+                    "type": "string"
+                  },
+                  "description": "Tasks that should be executed before this task"
+                }
+              }
+            }
+          ]
        }
      },
      "additionalProperties": false
@ -528,9 +554,11 @@
          "bare-node-builtins",
          "byonm",
          "cron",
+          "detect-cjs",
          "ffi",
          "fs",
          "fmt-component",
+          "fmt-sql",
          "http",
          "kv",
          "net",
--- 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;
@ -64,6 +66,7 @@ use crate::args::NpmInstallDepsProvider;
 use crate::args::PermissionFlags;
 use crate::args::UnstableConfig;
 use crate::cache::DenoDir;
+use crate::cache::FastInsecureHasher;
 use crate::emit::Emitter;
 use crate::file_fetcher::FileFetcher;
 use crate::http_util::HttpClientProvider;
@ -86,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;

@ -174,6 +178,7 @@ pub struct SerializedWorkspaceResolver {
 pub struct Metadata {
  pub argv: Vec<String>,
  pub seed: Option<u64>,
+  pub code_cache_key: Option<u64>,
  pub permissions: PermissionFlags,
  pub location: Option<Url>,
  pub v8_flags: Vec<String>,
@ -199,7 +204,8 @@ fn write_binary_bytes(
  compile_flags: &CompileFlags,
 ) -> Result<(), AnyError> {
  let data_section_bytes =
-    serialize_binary_data_section(metadata, npm_snapshot, remote_modules, vfs)?;
+    serialize_binary_data_section(metadata, npm_snapshot, remote_modules, vfs)
+      .context("Serializing binary data section.")?;

  let target = compile_flags.resolve_target();
  if target.contains("linux") {
@ -272,16 +278,17 @@ 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) {
+          match RealFs.read_file_sync(&path, None) {
            Ok(bytes) => bytes,
            Err(FsError::Io(err)) if err.kind() == ErrorKind::NotFound => {
              return Ok(None)
            }
            Err(err) => return Err(err.into()),
-          };
-          Cow::Owned(bytes)
+          }
        }
        Err(err) => return Err(err.into()),
      };
@ -362,6 +369,7 @@ pub fn extract_standalone(

 pub struct DenoCompileBinaryWriter<'a> {
  cjs_tracker: &'a CjsTracker,
+  cli_options: &'a CliOptions,
  deno_dir: &'a DenoDir,
  emitter: &'a Emitter,
  file_fetcher: &'a FileFetcher,
@ -375,6 +383,7 @@ impl<'a> DenoCompileBinaryWriter<'a> {
  #[allow(clippy::too_many_arguments)]
  pub fn new(
    cjs_tracker: &'a CjsTracker,
+    cli_options: &'a CliOptions,
    deno_dir: &'a DenoDir,
    emitter: &'a Emitter,
    file_fetcher: &'a FileFetcher,
@ -385,6 +394,7 @@ impl<'a> DenoCompileBinaryWriter<'a> {
  ) -> Self {
    Self {
      cjs_tracker,
+      cli_options,
      deno_dir,
      emitter,
      file_fetcher,
@ -401,8 +411,8 @@ impl<'a> DenoCompileBinaryWriter<'a> {
    graph: &ModuleGraph,
    root_dir_url: StandaloneRelativeFileBaseUrl<'_>,
    entrypoint: &ModuleSpecifier,
+    include_files: &[ModuleSpecifier],
    compile_flags: &CompileFlags,
-    cli_options: &CliOptions,
  ) -> Result<(), AnyError> {
    // Select base binary based on target
    let mut original_binary = self.get_base_binary(compile_flags).await?;
@ -415,7 +425,8 @@ impl<'a> DenoCompileBinaryWriter<'a> {
          target,
        )
      }
-      set_windows_binary_to_gui(&mut original_binary)?;
+      set_windows_binary_to_gui(&mut original_binary)
+        .context("Setting windows binary to GUI.")?;
    }
    if compile_flags.icon.is_some() {
      let target = compile_flags.resolve_target();
@ -433,7 +444,7 @@ impl<'a> DenoCompileBinaryWriter<'a> {
        graph,
        root_dir_url,
        entrypoint,
-        cli_options,
+        include_files,
        compile_flags,
      )
      .await
@ -447,7 +458,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())
      });
@ -476,10 +487,14 @@ impl<'a> DenoCompileBinaryWriter<'a> {
    if !binary_path.exists() {
      self
        .download_base_binary(&download_directory, &binary_path_suffix)
-        .await?;
+        .await
+        .context("Setting up base binary.")?;
    }

-    let archive_data = std::fs::read(binary_path)?;
+    let read_file = |path: &Path| -> Result<Vec<u8>, AnyError> {
+      std::fs::read(path).with_context(|| format!("Reading {}", path.display()))
+    };
+    let archive_data = read_file(&binary_path)?;
    let temp_dir = tempfile::TempDir::new()?;
    let base_binary_path = archive::unpack_into_dir(archive::UnpackArgs {
      exe_name: "denort",
@ -488,7 +503,7 @@ impl<'a> DenoCompileBinaryWriter<'a> {
      is_windows: target.contains("windows"),
      dest_path: temp_dir.path(),
    })?;
-    let base_binary = std::fs::read(base_binary_path)?;
+    let base_binary = read_file(&base_binary_path)?;
    drop(temp_dir); // delete the temp dir
    Ok(base_binary)
  }
@ -516,15 +531,19 @@ impl<'a> DenoCompileBinaryWriter<'a> {
    let bytes = match maybe_bytes {
      Some(bytes) => bytes,
      None => {
-        log::info!("Download could not be found, aborting");
-        deno_runtime::exit(1);
+        bail!("Download could not be found, aborting");
      }
    };

-    std::fs::create_dir_all(output_directory)?;
+    let create_dir_all = |dir: &Path| {
+      std::fs::create_dir_all(dir)
+        .with_context(|| format!("Creating {}", dir.display()))
+    };
+    create_dir_all(output_directory)?;
    let output_path = output_directory.join(binary_path_suffix);
-    std::fs::create_dir_all(output_path.parent().unwrap())?;
-    tokio::fs::write(output_path, bytes).await?;
+    create_dir_all(output_path.parent().unwrap())?;
+    std::fs::write(&output_path, bytes)
+      .with_context(|| format!("Writing {}", output_path.display()))?;
    Ok(())
  }

@ -538,76 +557,101 @@ impl<'a> DenoCompileBinaryWriter<'a> {
    graph: &ModuleGraph,
    root_dir_url: StandaloneRelativeFileBaseUrl<'_>,
    entrypoint: &ModuleSpecifier,
-    cli_options: &CliOptions,
+    include_files: &[ModuleSpecifier],
    compile_flags: &CompileFlags,
  ) -> Result<(), AnyError> {
-    let ca_data = match cli_options.ca_data() {
+    let ca_data = match self.cli_options.ca_data() {
      Some(CaData::File(ca_file)) => Some(
-        std::fs::read(ca_file)
-          .with_context(|| format!("Reading: {ca_file}"))?,
+        std::fs::read(ca_file).with_context(|| format!("Reading {ca_file}"))?,
      ),
      Some(CaData::Bytes(bytes)) => Some(bytes.clone()),
      None => None,
    };
    let root_path = root_dir_url.inner().to_file_path().unwrap();
-    let (maybe_npm_vfs, node_modules, npm_snapshot) = match self
-      .npm_resolver
-      .as_inner()
-    {
-      InnerCliNpmResolverRef::Managed(managed) => {
-        let snapshot =
-          managed.serialized_valid_snapshot_for_system(&self.npm_system_info);
-        if !snapshot.as_serialized().packages.is_empty() {
-          let npm_vfs_builder = self.build_npm_vfs(&root_path, cli_options)?;
+    let (maybe_npm_vfs, node_modules, npm_snapshot) =
+      match self.npm_resolver.as_inner() {
+        InnerCliNpmResolverRef::Managed(managed) => {
+          let snapshot =
+            managed.serialized_valid_snapshot_for_system(&self.npm_system_info);
+          if !snapshot.as_serialized().packages.is_empty() {
+            let npm_vfs_builder = self
+              .build_npm_vfs(&root_path)
+              .context("Building npm vfs.")?;
+            (
+              Some(npm_vfs_builder),
+              Some(NodeModules::Managed {
+                node_modules_dir: self
+                  .npm_resolver
+                  .root_node_modules_path()
+                  .map(|path| {
+                    root_dir_url
+                      .specifier_key(
+                        &ModuleSpecifier::from_directory_path(path).unwrap(),
+                      )
+                      .into_owned()
+                  }),
+              }),
+              Some(snapshot),
+            )
+          } else {
+            (None, None, None)
+          }
+        }
+        InnerCliNpmResolverRef::Byonm(resolver) => {
+          let npm_vfs_builder = self.build_npm_vfs(&root_path)?;
          (
            Some(npm_vfs_builder),
-            Some(NodeModules::Managed {
-              node_modules_dir: self.npm_resolver.root_node_modules_path().map(
-                |path| {
+            Some(NodeModules::Byonm {
+              root_node_modules_dir: resolver.root_node_modules_path().map(
+                |node_modules_dir| {
                  root_dir_url
                    .specifier_key(
-                      &ModuleSpecifier::from_directory_path(path).unwrap(),
+                      &ModuleSpecifier::from_directory_path(node_modules_dir)
+                        .unwrap(),
                    )
                    .into_owned()
                },
              ),
            }),
-            Some(snapshot),
+            None,
          )
-        } else {
-          (None, None, None)
        }
-      }
-      InnerCliNpmResolverRef::Byonm(resolver) => {
-        let npm_vfs_builder = self.build_npm_vfs(&root_path, cli_options)?;
-        (
-          Some(npm_vfs_builder),
-          Some(NodeModules::Byonm {
-            root_node_modules_dir: resolver.root_node_modules_path().map(
-              |node_modules_dir| {
-                root_dir_url
-                  .specifier_key(
-                    &ModuleSpecifier::from_directory_path(node_modules_dir)
-                      .unwrap(),
-                  )
-                  .into_owned()
-              },
-            ),
-          }),
-          None,
-        )
-      }
-    };
+      };
    let mut vfs = if let Some(npm_vfs) = maybe_npm_vfs {
      npm_vfs
    } else {
      VfsBuilder::new(root_path.clone())?
    };
+    for include_file in include_files {
+      let path = deno_path_util::url_to_file_path(include_file)?;
+      if path.is_dir() {
+        // TODO(#26941): we should analyze if any of these are
+        // modules in order to include their dependencies
+        vfs
+          .add_dir_recursive(&path)
+          .with_context(|| format!("Including {}", path.display()))?;
+      } else {
+        vfs
+          .add_file_at_path(&path)
+          .with_context(|| format!("Including {}", path.display()))?;
+      }
+    }
    let mut remote_modules_store = RemoteModulesStoreBuilder::default();
+    let mut code_cache_key_hasher = if self.cli_options.code_cache_enabled() {
+      Some(FastInsecureHasher::new_deno_versioned())
+    } else {
+      None
+    };
    for module in graph.modules() {
      if module.specifier().scheme() == "data" {
        continue; // don't store data urls as an entry as they're in the code
      }
+      if let Some(hasher) = &mut code_cache_key_hasher {
+        if let Some(source) = module.source() {
+          hasher.write(module.specifier().as_str().as_bytes());
+          hasher.write(source.as_bytes());
+        }
+      }
      let (maybe_source, media_type) = match module {
        deno_graph::Module::Js(m) => {
          let source = if m.media_type.is_emittable() {
@ -635,6 +679,9 @@ impl<'a> DenoCompileBinaryWriter<'a> {
        deno_graph::Module::Json(m) => {
          (Some(m.source.as_bytes().to_vec()), m.media_type)
        }
+        deno_graph::Module::Wasm(m) => {
+          (Some(m.source.to_vec()), MediaType::Wasm)
+        }
        deno_graph::Module::Npm(_)
        | deno_graph::Module::Node(_)
        | deno_graph::Module::External(_) => (None, MediaType::Unknown),
@ -646,8 +693,9 @@ impl<'a> DenoCompileBinaryWriter<'a> {
            &file_path,
            match maybe_source {
              Some(source) => source,
-              None => RealFs.read_file_sync(&file_path, None)?,
+              None => RealFs.read_file_sync(&file_path, None)?.into_owned(),
            },
+            VfsFileSubDataKind::ModuleGraph,
          )
          .with_context(|| {
            format!("Failed adding '{}'", file_path.display())
@ -658,25 +706,33 @@ impl<'a> DenoCompileBinaryWriter<'a> {
    }
    remote_modules_store.add_redirects(&graph.redirects);

-    let env_vars_from_env_file = match cli_options.env_file_name() {
-      Some(env_filename) => {
-        log::info!("{} Environment variables from the file \"{}\" were embedded in the generated executable file", crate::colors::yellow("Warning"), env_filename);
-        get_file_env_vars(env_filename.to_string())?
+    let env_vars_from_env_file = match self.cli_options.env_file_name() {
+      Some(env_filenames) => {
+        let mut aggregated_env_vars = IndexMap::new();
+        for env_filename in env_filenames.iter().rev() {
+          log::info!("{} Environment variables from the file \"{}\" were embedded in the generated executable file", crate::colors::yellow("Warning"), env_filename);
+
+          let env_vars = get_file_env_vars(env_filename.to_string())?;
+          aggregated_env_vars.extend(env_vars);
+        }
+        aggregated_env_vars
      }
      None => Default::default(),
    };

    let metadata = Metadata {
      argv: compile_flags.args.clone(),
-      seed: cli_options.seed(),
-      location: cli_options.location_flag().clone(),
-      permissions: cli_options.permission_flags().clone(),
-      v8_flags: cli_options.v8_flags().clone(),
-      unsafely_ignore_certificate_errors: cli_options
+      seed: self.cli_options.seed(),
+      code_cache_key: code_cache_key_hasher.map(|h| h.finish()),
+      location: self.cli_options.location_flag().clone(),
+      permissions: self.cli_options.permission_flags().clone(),
+      v8_flags: self.cli_options.v8_flags().clone(),
+      unsafely_ignore_certificate_errors: self
+        .cli_options
        .unsafely_ignore_certificate_errors()
        .clone(),
-      log_level: cli_options.log_level(),
-      ca_stores: cli_options.ca_stores().clone(),
+      log_level: self.cli_options.log_level(),
+      ca_stores: self.cli_options.ca_stores().clone(),
      ca_data,
      env_vars_from_env_file,
      entrypoint_key: root_dir_url.specifier_key(entrypoint).into_owned(),
@ -719,11 +775,12 @@ impl<'a> DenoCompileBinaryWriter<'a> {
      node_modules,
      unstable_config: UnstableConfig {
        legacy_flag_enabled: false,
-        bare_node_builtins: cli_options.unstable_bare_node_builtins(),
-        sloppy_imports: cli_options.unstable_sloppy_imports(),
-        features: cli_options.unstable_features(),
+        bare_node_builtins: self.cli_options.unstable_bare_node_builtins(),
+        detect_cjs: self.cli_options.unstable_detect_cjs(),
+        sloppy_imports: self.cli_options.unstable_sloppy_imports(),
+        features: self.cli_options.unstable_features(),
      },
-      otel_config: cli_options.otel_config(),
+      otel_config: self.cli_options.otel_config(),
    };

    write_binary_bytes(
@ -735,13 +792,10 @@ impl<'a> DenoCompileBinaryWriter<'a> {
      vfs,
      compile_flags,
    )
+    .context("Writing binary bytes")
  }

-  fn build_npm_vfs(
-    &self,
-    root_path: &Path,
-    cli_options: &CliOptions,
-  ) -> Result<VfsBuilder, AnyError> {
+  fn build_npm_vfs(&self, root_path: &Path) -> Result<VfsBuilder, AnyError> {
    fn maybe_warn_different_system(system_info: &NpmSystemInfo) {
      if system_info != &NpmSystemInfo::default() {
        log::warn!("{} The node_modules directory may be incompatible with the target system.", crate::colors::yellow("Warning"));
@ -818,13 +872,18 @@ impl<'a> DenoCompileBinaryWriter<'a> {
      InnerCliNpmResolverRef::Byonm(_) => {
        maybe_warn_different_system(&self.npm_system_info);
        let mut builder = VfsBuilder::new(root_path.to_path_buf())?;
-        for pkg_json in cli_options.workspace().package_jsons() {
+        for pkg_json in self.cli_options.workspace().package_jsons() {
          builder.add_file_at_path(&pkg_json.path)?;
        }
        // traverse and add all the node_modules directories in the workspace
        let mut pending_dirs = VecDeque::new();
        pending_dirs.push_back(
-          cli_options.workspace().root_dir().to_file_path().unwrap(),
+          self
+            .cli_options
+            .workspace()
+            .root_dir()
+            .to_file_path()
+            .unwrap(),
        );
        while let Some(pending_dir) = pending_dirs.pop_front() {
          let mut entries = fs::read_dir(&pending_dir)
@ -851,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/code_cache.rs
+++ b/cli/standalone/code_cache.rs
@ -0,0 +1,523 @@
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+
+use std::collections::BTreeMap;
+use std::collections::HashMap;
+use std::io::BufReader;
+use std::io::BufWriter;
+use std::io::Read;
+use std::io::Write;
+use std::path::Path;
+use std::path::PathBuf;
+use std::sync::Arc;
+
+use deno_ast::ModuleSpecifier;
+use deno_core::anyhow::bail;
+use deno_core::error::AnyError;
+use deno_core::parking_lot::Mutex;
+use deno_core::unsync::sync::AtomicFlag;
+use deno_runtime::code_cache::CodeCache;
+use deno_runtime::code_cache::CodeCacheType;
+
+use crate::cache::FastInsecureHasher;
+use crate::util::path::get_atomic_file_path;
+use crate::worker::CliCodeCache;
+
+enum CodeCacheStrategy {
+  FirstRun(FirstRunCodeCacheStrategy),
+  SubsequentRun(SubsequentRunCodeCacheStrategy),
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct DenoCompileCodeCacheEntry {
+  pub source_hash: u64,
+  pub data: Vec<u8>,
+}
+
+pub struct DenoCompileCodeCache {
+  strategy: CodeCacheStrategy,
+}
+
+impl DenoCompileCodeCache {
+  pub fn new(file_path: PathBuf, cache_key: u64) -> Self {
+    // attempt to deserialize the cache data
+    match deserialize(&file_path, cache_key) {
+      Ok(data) => {
+        log::debug!(
+          "Loaded {} code cache entries from {}",
+          data.len(),
+          file_path.display()
+        );
+        Self {
+          strategy: CodeCacheStrategy::SubsequentRun(
+            SubsequentRunCodeCacheStrategy {
+              is_finished: AtomicFlag::lowered(),
+              data: Mutex::new(data),
+            },
+          ),
+        }
+      }
+      Err(err) => {
+        log::debug!(
+          "Failed to deserialize code cache from {}: {:#}",
+          file_path.display(),
+          err
+        );
+        Self {
+          strategy: CodeCacheStrategy::FirstRun(FirstRunCodeCacheStrategy {
+            cache_key,
+            file_path,
+            is_finished: AtomicFlag::lowered(),
+            data: Mutex::new(FirstRunCodeCacheData {
+              cache: HashMap::new(),
+              add_count: 0,
+            }),
+          }),
+        }
+      }
+    }
+  }
+}
+
+impl CodeCache for DenoCompileCodeCache {
+  fn get_sync(
+    &self,
+    specifier: &ModuleSpecifier,
+    code_cache_type: CodeCacheType,
+    source_hash: u64,
+  ) -> Option<Vec<u8>> {
+    match &self.strategy {
+      CodeCacheStrategy::FirstRun(strategy) => {
+        if !strategy.is_finished.is_raised() {
+          // we keep track of how many times the cache is requested
+          // then serialize the cache when we get that number of
+          // "set" calls
+          strategy.data.lock().add_count += 1;
+        }
+        None
+      }
+      CodeCacheStrategy::SubsequentRun(strategy) => {
+        if strategy.is_finished.is_raised() {
+          return None;
+        }
+        strategy.take_from_cache(specifier, code_cache_type, source_hash)
+      }
+    }
+  }
+
+  fn set_sync(
+    &self,
+    specifier: ModuleSpecifier,
+    code_cache_type: CodeCacheType,
+    source_hash: u64,
+    bytes: &[u8],
+  ) {
+    match &self.strategy {
+      CodeCacheStrategy::FirstRun(strategy) => {
+        if strategy.is_finished.is_raised() {
+          return;
+        }
+
+        let data_to_serialize = {
+          let mut data = strategy.data.lock();
+          data.cache.insert(
+            (specifier.to_string(), code_cache_type),
+            DenoCompileCodeCacheEntry {
+              source_hash,
+              data: bytes.to_vec(),
+            },
+          );
+          if data.add_count != 0 {
+            data.add_count -= 1;
+          }
+          if data.add_count == 0 {
+            // don't allow using the cache anymore
+            strategy.is_finished.raise();
+            if data.cache.is_empty() {
+              None
+            } else {
+              Some(std::mem::take(&mut data.cache))
+            }
+          } else {
+            None
+          }
+        };
+        if let Some(cache_data) = &data_to_serialize {
+          strategy.write_cache_data(cache_data);
+        }
+      }
+      CodeCacheStrategy::SubsequentRun(_) => {
+        // do nothing
+      }
+    }
+  }
+}
+
+impl CliCodeCache for DenoCompileCodeCache {
+  fn enabled(&self) -> bool {
+    match &self.strategy {
+      CodeCacheStrategy::FirstRun(strategy) => {
+        !strategy.is_finished.is_raised()
+      }
+      CodeCacheStrategy::SubsequentRun(strategy) => {
+        !strategy.is_finished.is_raised()
+      }
+    }
+  }
+
+  fn as_code_cache(self: Arc<Self>) -> Arc<dyn CodeCache> {
+    self
+  }
+}
+
+type CodeCacheKey = (String, CodeCacheType);
+
+struct FirstRunCodeCacheData {
+  cache: HashMap<CodeCacheKey, DenoCompileCodeCacheEntry>,
+  add_count: usize,
+}
+
+struct FirstRunCodeCacheStrategy {
+  cache_key: u64,
+  file_path: PathBuf,
+  is_finished: AtomicFlag,
+  data: Mutex<FirstRunCodeCacheData>,
+}
+
+impl FirstRunCodeCacheStrategy {
+  fn write_cache_data(
+    &self,
+    cache_data: &HashMap<CodeCacheKey, DenoCompileCodeCacheEntry>,
+  ) {
+    let count = cache_data.len();
+    let temp_file = get_atomic_file_path(&self.file_path);
+    match serialize(&temp_file, self.cache_key, cache_data) {
+      Ok(()) => {
+        if let Err(err) = std::fs::rename(&temp_file, &self.file_path) {
+          log::debug!("Failed to rename code cache: {}", err);
+          let _ = std::fs::remove_file(&temp_file);
+        } else {
+          log::debug!("Serialized {} code cache entries", count);
+        }
+      }
+      Err(err) => {
+        let _ = std::fs::remove_file(&temp_file);
+        log::debug!("Failed to serialize code cache: {}", err);
+      }
+    }
+  }
+}
+
+struct SubsequentRunCodeCacheStrategy {
+  is_finished: AtomicFlag,
+  data: Mutex<HashMap<CodeCacheKey, DenoCompileCodeCacheEntry>>,
+}
+
+impl SubsequentRunCodeCacheStrategy {
+  fn take_from_cache(
+    &self,
+    specifier: &ModuleSpecifier,
+    code_cache_type: CodeCacheType,
+    source_hash: u64,
+  ) -> Option<Vec<u8>> {
+    let mut data = self.data.lock();
+    // todo(dsherret): how to avoid the clone here?
+    let entry = data.remove(&(specifier.to_string(), code_cache_type))?;
+    if entry.source_hash != source_hash {
+      return None;
+    }
+    if data.is_empty() {
+      self.is_finished.raise();
+    }
+    Some(entry.data)
+  }
+}
+
+/// File format:
+/// - <header>
+///   - <cache key>
+///   - <u32: number of entries>
+/// - <[entry length]> - u64 * number of entries
+/// - <[entry]>
+///   - <[u8]: entry data>
+///   - <String: specifier>
+///   - <u8>: code cache type
+///   - <u32: specifier length>
+///   - <u64: source hash>
+///   - <u64: entry data hash>
+fn serialize(
+  file_path: &Path,
+  cache_key: u64,
+  cache: &HashMap<CodeCacheKey, DenoCompileCodeCacheEntry>,
+) -> Result<(), AnyError> {
+  let cache_file = std::fs::OpenOptions::new()
+    .create(true)
+    .truncate(true)
+    .write(true)
+    .open(file_path)?;
+  let mut writer = BufWriter::new(cache_file);
+  serialize_with_writer(&mut writer, cache_key, cache)
+}
+
+fn serialize_with_writer<T: Write>(
+  writer: &mut BufWriter<T>,
+  cache_key: u64,
+  cache: &HashMap<CodeCacheKey, DenoCompileCodeCacheEntry>,
+) -> Result<(), AnyError> {
+  // header
+  writer.write_all(&cache_key.to_le_bytes())?;
+  writer.write_all(&(cache.len() as u32).to_le_bytes())?;
+  // lengths of each entry
+  for ((specifier, _), entry) in cache {
+    let len: u64 =
+      entry.data.len() as u64 + specifier.len() as u64 + 1 + 4 + 8 + 8;
+    writer.write_all(&len.to_le_bytes())?;
+  }
+  // entries
+  for ((specifier, code_cache_type), entry) in cache {
+    writer.write_all(&entry.data)?;
+    writer.write_all(&[match code_cache_type {
+      CodeCacheType::EsModule => 0,
+      CodeCacheType::Script => 1,
+    }])?;
+    writer.write_all(specifier.as_bytes())?;
+    writer.write_all(&(specifier.len() as u32).to_le_bytes())?;
+    writer.write_all(&entry.source_hash.to_le_bytes())?;
+    let hash: u64 = FastInsecureHasher::new_without_deno_version()
+      .write(&entry.data)
+      .finish();
+    writer.write_all(&hash.to_le_bytes())?;
+  }
+
+  writer.flush()?;
+
+  Ok(())
+}
+
+fn deserialize(
+  file_path: &Path,
+  expected_cache_key: u64,
+) -> Result<HashMap<CodeCacheKey, DenoCompileCodeCacheEntry>, AnyError> {
+  let cache_file = std::fs::File::open(file_path)?;
+  let mut reader = BufReader::new(cache_file);
+  deserialize_with_reader(&mut reader, expected_cache_key)
+}
+
+fn deserialize_with_reader<T: Read>(
+  reader: &mut BufReader<T>,
+  expected_cache_key: u64,
+) -> Result<HashMap<CodeCacheKey, DenoCompileCodeCacheEntry>, AnyError> {
+  // it's very important to use this below so that a corrupt cache file
+  // doesn't cause a memory allocation error
+  fn new_vec_sized<T: Clone>(
+    capacity: usize,
+    default_value: T,
+  ) -> Result<Vec<T>, AnyError> {
+    let mut vec = Vec::new();
+    vec.try_reserve(capacity)?;
+    vec.resize(capacity, default_value);
+    Ok(vec)
+  }
+
+  fn try_subtract(a: usize, b: usize) -> Result<usize, AnyError> {
+    if a < b {
+      bail!("Integer underflow");
+    }
+    Ok(a - b)
+  }
+
+  let mut header_bytes = vec![0; 8 + 4];
+  reader.read_exact(&mut header_bytes)?;
+  let actual_cache_key = u64::from_le_bytes(header_bytes[..8].try_into()?);
+  if actual_cache_key != expected_cache_key {
+    // cache bust
+    bail!("Cache key mismatch");
+  }
+  let len = u32::from_le_bytes(header_bytes[8..].try_into()?) as usize;
+  // read the lengths for each entry found in the file
+  let entry_len_bytes_capacity = len * 8;
+  let mut entry_len_bytes = new_vec_sized(entry_len_bytes_capacity, 0)?;
+  reader.read_exact(&mut entry_len_bytes)?;
+  let mut lengths = Vec::new();
+  lengths.try_reserve(len)?;
+  for i in 0..len {
+    let pos = i * 8;
+    lengths.push(
+      u64::from_le_bytes(entry_len_bytes[pos..pos + 8].try_into()?) as usize,
+    );
+  }
+
+  let mut map = HashMap::new();
+  map.try_reserve(len)?;
+  for len in lengths {
+    let mut buffer = new_vec_sized(len, 0)?;
+    reader.read_exact(&mut buffer)?;
+    let entry_data_hash_start_pos = try_subtract(buffer.len(), 8)?;
+    let expected_entry_data_hash =
+      u64::from_le_bytes(buffer[entry_data_hash_start_pos..].try_into()?);
+    let source_hash_start_pos = try_subtract(entry_data_hash_start_pos, 8)?;
+    let source_hash = u64::from_le_bytes(
+      buffer[source_hash_start_pos..entry_data_hash_start_pos].try_into()?,
+    );
+    let specifier_end_pos = try_subtract(source_hash_start_pos, 4)?;
+    let specifier_len = u32::from_le_bytes(
+      buffer[specifier_end_pos..source_hash_start_pos].try_into()?,
+    ) as usize;
+    let specifier_start_pos = try_subtract(specifier_end_pos, specifier_len)?;
+    let specifier = String::from_utf8(
+      buffer[specifier_start_pos..specifier_end_pos].to_vec(),
+    )?;
+    let code_cache_type_pos = try_subtract(specifier_start_pos, 1)?;
+    let code_cache_type = match buffer[code_cache_type_pos] {
+      0 => CodeCacheType::EsModule,
+      1 => CodeCacheType::Script,
+      _ => bail!("Invalid code cache type"),
+    };
+    buffer.truncate(code_cache_type_pos);
+    let actual_entry_data_hash: u64 =
+      FastInsecureHasher::new_without_deno_version()
+        .write(&buffer)
+        .finish();
+    if expected_entry_data_hash != actual_entry_data_hash {
+      bail!("Hash mismatch.")
+    }
+    map.insert(
+      (specifier, code_cache_type),
+      DenoCompileCodeCacheEntry {
+        source_hash,
+        data: buffer,
+      },
+    );
+  }
+
+  Ok(map)
+}
+
+#[cfg(test)]
+mod test {
+  use test_util::TempDir;
+
+  use super::*;
+  use std::fs::File;
+
+  #[test]
+  fn serialize_deserialize() {
+    let cache_key = 123456;
+    let cache = {
+      let mut cache = HashMap::new();
+      cache.insert(
+        ("specifier1".to_string(), CodeCacheType::EsModule),
+        DenoCompileCodeCacheEntry {
+          source_hash: 1,
+          data: vec![1, 2, 3],
+        },
+      );
+      cache.insert(
+        ("specifier2".to_string(), CodeCacheType::EsModule),
+        DenoCompileCodeCacheEntry {
+          source_hash: 2,
+          data: vec![4, 5, 6],
+        },
+      );
+      cache.insert(
+        ("specifier2".to_string(), CodeCacheType::Script),
+        DenoCompileCodeCacheEntry {
+          source_hash: 2,
+          data: vec![6, 5, 1],
+        },
+      );
+      cache
+    };
+    let mut buffer = Vec::new();
+    serialize_with_writer(&mut BufWriter::new(&mut buffer), cache_key, &cache)
+      .unwrap();
+    let deserialized =
+      deserialize_with_reader(&mut BufReader::new(&buffer[..]), cache_key)
+        .unwrap();
+    assert_eq!(cache, deserialized);
+  }
+
+  #[test]
+  fn serialize_deserialize_empty() {
+    let cache_key = 1234;
+    let cache = HashMap::new();
+    let mut buffer = Vec::new();
+    serialize_with_writer(&mut BufWriter::new(&mut buffer), cache_key, &cache)
+      .unwrap();
+    let deserialized =
+      deserialize_with_reader(&mut BufReader::new(&buffer[..]), cache_key)
+        .unwrap();
+    assert_eq!(cache, deserialized);
+  }
+
+  #[test]
+  fn serialize_deserialize_corrupt() {
+    let buffer = "corrupttestingtestingtesting".as_bytes().to_vec();
+    let err = deserialize_with_reader(&mut BufReader::new(&buffer[..]), 1234)
+      .unwrap_err();
+    assert_eq!(err.to_string(), "Cache key mismatch");
+  }
+
+  #[test]
+  fn code_cache() {
+    let temp_dir = TempDir::new();
+    let file_path = temp_dir.path().join("cache.bin").to_path_buf();
+    let url1 = ModuleSpecifier::parse("https://deno.land/example1.js").unwrap();
+    let url2 = ModuleSpecifier::parse("https://deno.land/example2.js").unwrap();
+    // first run
+    {
+      let code_cache = DenoCompileCodeCache::new(file_path.clone(), 1234);
+      assert!(code_cache
+        .get_sync(&url1, CodeCacheType::EsModule, 0)
+        .is_none());
+      assert!(code_cache
+        .get_sync(&url2, CodeCacheType::EsModule, 1)
+        .is_none());
+      assert!(code_cache.enabled());
+      code_cache.set_sync(url1.clone(), CodeCacheType::EsModule, 0, &[1, 2, 3]);
+      assert!(code_cache.enabled());
+      assert!(!file_path.exists());
+      code_cache.set_sync(url2.clone(), CodeCacheType::EsModule, 1, &[2, 1, 3]);
+      assert!(file_path.exists()); // now the new code cache exists
+      assert!(!code_cache.enabled()); // no longer enabled
+    }
+    // second run
+    {
+      let code_cache = DenoCompileCodeCache::new(file_path.clone(), 1234);
+      assert!(code_cache.enabled());
+      let result1 = code_cache
+        .get_sync(&url1, CodeCacheType::EsModule, 0)
+        .unwrap();
+      assert!(code_cache.enabled());
+      let result2 = code_cache
+        .get_sync(&url2, CodeCacheType::EsModule, 1)
+        .unwrap();
+      assert!(!code_cache.enabled()); // no longer enabled
+      assert_eq!(result1, vec![1, 2, 3]);
+      assert_eq!(result2, vec![2, 1, 3]);
+    }
+
+    // new cache key first run
+    {
+      let code_cache = DenoCompileCodeCache::new(file_path.clone(), 54321);
+      assert!(code_cache
+        .get_sync(&url1, CodeCacheType::EsModule, 0)
+        .is_none());
+      assert!(code_cache
+        .get_sync(&url2, CodeCacheType::EsModule, 1)
+        .is_none());
+      code_cache.set_sync(url1.clone(), CodeCacheType::EsModule, 0, &[2, 2, 3]);
+      code_cache.set_sync(url2.clone(), CodeCacheType::EsModule, 1, &[3, 2, 3]);
+    }
+    // new cache key second run
+    {
+      let code_cache = DenoCompileCodeCache::new(file_path.clone(), 54321);
+      let result1 = code_cache
+        .get_sync(&url1, CodeCacheType::EsModule, 0)
+        .unwrap();
+      assert_eq!(result1, vec![2, 2, 3]);
+      assert!(code_cache
+        .get_sync(&url2, CodeCacheType::EsModule, 5) // different hash will cause none
+        .is_none());
+    }
+  }
+}
--- 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
@ -7,6 +7,7 @@

 use binary::StandaloneData;
 use binary::StandaloneModules;
+use code_cache::DenoCompileCodeCache;
 use deno_ast::MediaType;
 use deno_cache_dir::npm::NpmCacheDir;
 use deno_config::workspace::MappedResolution;
@ -17,6 +18,7 @@ use deno_core::anyhow::Context;
 use deno_core::error::generic_error;
 use deno_core::error::type_error;
 use deno_core::error::AnyError;
+use deno_core::futures::future::LocalBoxFuture;
 use deno_core::futures::FutureExt;
 use deno_core::v8_set_flags;
 use deno_core::FastString;
@ -27,8 +29,10 @@ use deno_core::ModuleSpecifier;
 use deno_core::ModuleType;
 use deno_core::RequestedModuleType;
 use deno_core::ResolutionKind;
+use deno_core::SourceCodeCacheInfo;
 use deno_npm::npm_rc::ResolvedNpmRc;
 use deno_package_json::PackageJsonDepValue;
+use deno_resolver::cjs::IsCjsResolutionMode;
 use deno_resolver::npm::NpmReqResolverOptions;
 use deno_runtime::deno_fs;
 use deno_runtime::deno_node::create_host_defined_options;
@ -47,12 +51,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::NodeResolutionMode;
+use node_resolver::NodeResolutionKind;
+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;
@ -64,6 +70,7 @@ use crate::args::StorageKeyResolver;
 use crate::cache::Caches;
 use crate::cache::DenoCacheEnvFsAdapter;
 use crate::cache::DenoDirProvider;
+use crate::cache::FastInsecureHasher;
 use crate::cache::NodeAnalysisCache;
 use crate::cache::RealDenoCacheEnv;
 use crate::http_util::HttpClientProvider;
@ -81,17 +88,19 @@ use crate::npm::CreateInNpmPkgCheckerOptions;
 use crate::resolver::CjsTracker;
 use crate::resolver::CliDenoResolverFs;
 use crate::resolver::CliNpmReqResolver;
-use crate::resolver::IsCjsResolverOptions;
 use crate::resolver::NpmModuleLoader;
 use crate::util::progress_bar::ProgressBar;
 use crate::util::progress_bar::ProgressBarStyle;
+use crate::util::text_encoding::from_utf8_lossy_cow;
 use crate::util::v8::construct_v8_flags;
+use crate::worker::CliCodeCache;
 use crate::worker::CliMainWorkerFactory;
 use crate::worker::CliMainWorkerOptions;
 use crate::worker::CreateModuleLoaderResult;
 use crate::worker::ModuleLoaderFactory;

 pub mod binary;
+mod code_cache;
 mod file_system;
 mod serialization;
 mod virtual_fs;
@ -105,6 +114,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>,
@ -112,9 +122,38 @@ struct SharedModuleLoaderState {
  npm_module_loader: Arc<NpmModuleLoader>,
  npm_req_resolver: Arc<CliNpmReqResolver>,
  npm_resolver: Arc<dyn CliNpmResolver>,
+  vfs: Arc<FileBackedVfs>,
  workspace_resolver: WorkspaceResolver,
 }

+impl SharedModuleLoaderState {
+  fn get_code_cache(
+    &self,
+    specifier: &ModuleSpecifier,
+    source: &[u8],
+  ) -> Option<SourceCodeCacheInfo> {
+    let Some(code_cache) = &self.code_cache else {
+      return None;
+    };
+    if !code_cache.enabled() {
+      return None;
+    }
+    // deno version is already included in the root cache key
+    let hash = FastInsecureHasher::new_without_deno_version()
+      .write_hashable(source)
+      .finish();
+    let data = code_cache.get_sync(
+      specifier,
+      deno_runtime::code_cache::CodeCacheType::EsModule,
+      hash,
+    );
+    Some(SourceCodeCacheInfo {
+      hash,
+      data: data.map(Cow::Owned),
+    })
+  }
+}
+
 #[derive(Clone)]
 struct EmbeddedModuleLoader {
  shared: Arc<SharedModuleLoaderState>,
@ -155,9 +194,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) {
@ -169,7 +208,7 @@ impl ModuleLoader for EmbeddedModuleLoader {
            raw_specifier,
            &referrer,
            referrer_kind,
-            NodeResolutionMode::Execution,
+            NodeResolutionKind::Execution,
          )?
          .into_url(),
      );
@ -197,7 +236,7 @@ impl ModuleLoader for EmbeddedModuleLoader {
            sub_path.as_deref(),
            Some(&referrer),
            referrer_kind,
-            NodeResolutionMode::Execution,
+            NodeResolutionKind::Execution,
          )?,
      ),
      Ok(MappedResolution::PackageJson {
@ -214,7 +253,7 @@ impl ModuleLoader for EmbeddedModuleLoader {
            sub_path.as_deref(),
            &referrer,
            referrer_kind,
-            NodeResolutionMode::Execution,
+            NodeResolutionKind::Execution,
          )
          .map_err(AnyError::from),
        PackageJsonDepValue::Workspace(version_req) => {
@ -234,7 +273,7 @@ impl ModuleLoader for EmbeddedModuleLoader {
                sub_path.as_deref(),
                Some(&referrer),
                referrer_kind,
-                NodeResolutionMode::Execution,
+                NodeResolutionKind::Execution,
              )?,
          )
        }
@ -248,7 +287,7 @@ impl ModuleLoader for EmbeddedModuleLoader {
            &reference,
            &referrer,
            referrer_kind,
-            NodeResolutionMode::Execution,
+            NodeResolutionKind::Execution,
          )?);
        }

@ -275,7 +314,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());
@ -329,14 +368,19 @@ impl ModuleLoader for EmbeddedModuleLoader {
    }

    if self.shared.node_resolver.in_npm_package(original_specifier) {
-      let npm_module_loader = self.shared.npm_module_loader.clone();
+      let shared = self.shared.clone();
      let original_specifier = original_specifier.clone();
      let maybe_referrer = maybe_referrer.cloned();
      return deno_core::ModuleLoadResponse::Async(
        async move {
-          let code_source = npm_module_loader
+          let code_source = shared
+            .npm_module_loader
            .load(&original_specifier, maybe_referrer.as_ref())
            .await?;
+          let code_cache_entry = shared.get_code_cache(
+            &code_source.found_url,
+            code_source.code.as_bytes(),
+          );
          Ok(deno_core::ModuleSource::new_with_redirect(
            match code_source.media_type {
              MediaType::Json => ModuleType::Json,
@ -345,7 +389,7 @@ impl ModuleLoader for EmbeddedModuleLoader {
            code_source.code,
            &original_specifier,
            &code_source.found_url,
-            None,
+            code_cache_entry,
          ))
        }
        .boxed_local(),
@ -398,25 +442,30 @@ impl ModuleLoader for EmbeddedModuleLoader {
                  ModuleSourceCode::String(FastString::from_static(source))
                }
              };
+              let code_cache_entry = shared
+                .get_code_cache(&module_specifier, module_source.as_bytes());
              Ok(deno_core::ModuleSource::new_with_redirect(
                module_type,
                module_source,
                &original_specifier,
                &module_specifier,
-                None,
+                code_cache_entry,
              ))
            }
            .boxed_local(),
          )
        } else {
          let module_source = module_source.into_for_v8();
+          let code_cache_entry = self
+            .shared
+            .get_code_cache(module_specifier, module_source.as_bytes());
          deno_core::ModuleLoadResponse::Sync(Ok(
            deno_core::ModuleSource::new_with_redirect(
              module_type,
              module_source,
              original_specifier,
              module_specifier,
-              None,
+              code_cache_entry,
            ),
          ))
        }
@ -429,6 +478,23 @@ impl ModuleLoader for EmbeddedModuleLoader {
      ))),
    }
  }
+
+  fn code_cache_ready(
+    &self,
+    specifier: ModuleSpecifier,
+    source_hash: u64,
+    code_cache_data: &[u8],
+  ) -> LocalBoxFuture<'static, ()> {
+    if let Some(code_cache) = &self.shared.code_cache {
+      code_cache.set_sync(
+        specifier,
+        deno_runtime::code_cache::CodeCacheType::EsModule,
+        source_hash,
+        code_cache_data,
+      );
+    }
+    std::future::ready(()).boxed_local()
+  }
 }

 impl NodeRequireLoader for EmbeddedModuleLoader {
@ -451,8 +517,13 @@ impl NodeRequireLoader for EmbeddedModuleLoader {
  fn load_text_file_lossy(
    &self,
    path: &std::path::Path,
-  ) -> Result<String, AnyError> {
-    Ok(self.shared.fs.read_text_file_lossy_sync(path, None)?)
+  ) -> Result<Cow<'static, str>, AnyError> {
+    let file_entry = self.shared.vfs.file_entry(path)?;
+    let file_bytes = self
+      .shared
+      .vfs
+      .read_file_all(file_entry, VfsFileSubDataKind::ModuleGraph)?;
+    Ok(from_utf8_lossy_cow(file_bytes))
  }

  fn is_maybe_cjs(
@ -661,9 +732,12 @@ pub async fn run(data: StandaloneData) -> Result<i32, AnyError> {
  let cjs_tracker = Arc::new(CjsTracker::new(
    in_npm_pkg_checker.clone(),
    pkg_json_resolver.clone(),
-    IsCjsResolverOptions {
-      detect_cjs: !metadata.workspace_resolver.package_jsons.is_empty(),
-      is_node_main: false,
+    if metadata.unstable_config.detect_cjs {
+      IsCjsResolutionMode::ImplicitTypeCommonJs
+    } else if metadata.workspace_resolver.package_jsons.is_empty() {
+      IsCjsResolutionMode::Disabled
+    } else {
+      IsCjsResolutionMode::ExplicitTypeCommonJs
    },
  ));
  let cache_db = Caches::new(deno_dir_provider.clone());
@ -739,9 +813,23 @@ pub async fn run(data: StandaloneData) -> Result<i32, AnyError> {
      metadata.workspace_resolver.pkg_json_resolution,
    )
  };
+  let code_cache = match metadata.code_cache_key {
+    Some(code_cache_key) => Some(Arc::new(DenoCompileCodeCache::new(
+      root_path.with_file_name(format!(
+        "{}.cache",
+        root_path.file_name().unwrap().to_string_lossy()
+      )),
+      code_cache_key,
+    )) as Arc<dyn CliCodeCache>),
+    None => {
+      log::debug!("Code cache disabled.");
+      None
+    }
+  };
  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(),
@ -752,8 +840,9 @@ pub async fn run(data: StandaloneData) -> Result<i32, AnyError> {
        node_code_translator,
      )),
      npm_resolver: npm_resolver.clone(),
-      workspace_resolver,
      npm_req_resolver,
+      vfs,
+      workspace_resolver,
    }),
  };

@ -792,8 +881,7 @@ pub async fn run(data: StandaloneData) -> Result<i32, AnyError> {
  });
  let worker_factory = CliMainWorkerFactory::new(
    Arc::new(BlobStore::default()),
-    // Code cache is not supported for standalone binary yet.
-    None,
+    code_cache,
    feature_checker,
    fs,
    None,
--- 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()
@ -51,7 +60,8 @@ pub struct VfsBuilder {

 impl VfsBuilder {
  pub fn new(root_path: PathBuf) -> Result<Self, AnyError> {
-    let root_path = canonicalize_path(&root_path)?;
+    let root_path = canonicalize_path(&root_path)
+      .with_context(|| format!("Canonicalizing {}", root_path.display()))?;
    log::debug!("Building vfs with root '{}'", root_path.display());
    Ok(Self {
      root_dir: VirtualDirectory {
@ -140,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 '{}'.",
@ -218,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]);
@ -252,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(_) => {
-        // already added, just ignore
+      Ok(index) => {
+        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(
@ -261,6 +288,7 @@ impl VfsBuilder {
          VfsEntry::File(VirtualFile {
            name: name.to_string(),
            offset,
+            module_graph_offset: offset,
            len: data.len() as u64,
          }),
        );
@ -301,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,
@ -313,9 +341,9 @@ impl VfsBuilder {
              .collect::<Vec<_>>(),
          }),
        );
+        Ok(())
      }
    }
-    Ok(())
  }

  pub fn into_dir_and_files(self) -> (VirtualDirectory, Vec<Vec<u8>>) {
@ -453,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,
 }

@ -633,7 +667,7 @@ impl FileBackedVfsFile {
  }

  fn read_to_buf(&self, buf: &mut [u8]) -> FsResult<usize> {
-    let pos = {
+    let read_pos = {
      let mut pos = self.pos.lock();
      let read_pos = *pos;
      // advance the position due to the read
@ -642,12 +676,12 @@ impl FileBackedVfsFile {
    };
    self
      .vfs
-      .read_file(&self.file, pos, buf)
+      .read_file(&self.file, read_pos, buf)
      .map_err(|err| err.into())
  }

-  fn read_to_end(&self) -> FsResult<Vec<u8>> {
-    let pos = {
+  fn read_to_end(&self) -> FsResult<Cow<'static, [u8]>> {
+    let read_pos = {
      let mut pos = self.pos.lock();
      let read_pos = *pos;
      // todo(dsherret): should this always set it to the end of the file?
@ -657,13 +691,21 @@ impl FileBackedVfsFile {
      }
      read_pos
    };
-    if pos > self.file.len {
-      return Ok(Vec::new());
+    if read_pos > self.file.len {
+      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 - pos) as usize;
-    let mut buf = vec![0; size];
-    self.vfs.read_file(&self.file, pos, &mut buf)?;
-    Ok(buf)
  }
 }

@ -701,10 +743,10 @@ impl deno_io::fs::File for FileBackedVfsFile {
    Err(FsError::NotSupported)
  }

-  fn read_all_sync(self: Rc<Self>) -> FsResult<Vec<u8>> {
+  fn read_all_sync(self: Rc<Self>) -> FsResult<Cow<'static, [u8]>> {
    self.read_to_end()
  }
-  async fn read_all_async(self: Rc<Self>) -> FsResult<Vec<u8>> {
+  async fn read_all_async(self: Rc<Self>) -> FsResult<Cow<'static, [u8]>> {
    let inner = (*self).clone();
    tokio::task::spawn_blocking(move || inner.read_to_end()).await?
  }
@ -877,8 +919,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())),
@ -891,26 +934,37 @@ impl FileBackedVfs {
    pos: u64,
    buf: &mut [u8],
  ) -> std::io::Result<usize> {
-    let read_range = self.get_read_range(file, pos, buf.len() as u64)?;
-    buf.copy_from_slice(&self.vfs_data[read_range]);
-    Ok(buf.len())
+    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)
  }

  fn get_read_range(
    &self,
    file: &VirtualFile,
+    sub_data_kind: VfsFileSubDataKind,
    pos: u64,
    len: u64,
  ) -> std::io::Result<Range<usize>> {
-    let data = &self.vfs_data;
-    let start = self.fs_root.start_file_offset + file.offset + pos;
-    let end = start + len;
-    if end > data.len() as u64 {
+    if pos > file.len {
      return Err(std::io::Error::new(
        std::io::ErrorKind::UnexpectedEof,
        "unexpected EOF",
      ));
    }
+    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)
  }

@ -949,7 +1003,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]
@ -962,23 +1022,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(
@ -1149,6 +1226,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/task_runner.rs
+++ b/cli/task_runner.rs
@ -483,20 +483,32 @@ fn resolve_execution_path_from_npx_shim(
  static SCRIPT_PATH_RE: Lazy<Regex> =
    lazy_regex::lazy_regex!(r#""\$basedir\/([^"]+)" "\$@""#);

-  if text.starts_with("#!/usr/bin/env node") {
-    // launch this file itself because it's a JS file
-    Some(file_path)
-  } else {
-    // Search for...
-    // > "$basedir/../next/dist/bin/next" "$@"
-    // ...which is what it will look like on Windows
-    SCRIPT_PATH_RE
-      .captures(text)
-      .and_then(|c| c.get(1))
-      .map(|relative_path| {
-        file_path.parent().unwrap().join(relative_path.as_str())
-      })
+  let maybe_first_line = {
+    let index = text.find("\n")?;
+    Some(&text[0..index])
+  };
+
+  if let Some(first_line) = maybe_first_line {
+    // NOTE(bartlomieju): this is not perfect, but handle two most common scenarios
+    // where Node is run without any args. If there are args then we use `NodeCommand`
+    // struct.
+    if first_line == "#!/usr/bin/env node"
+      || first_line == "#!/usr/bin/env -S node"
+    {
+      // launch this file itself because it's a JS file
+      return Some(file_path);
+    }
  }
+
+  // Search for...
+  // > "$basedir/../next/dist/bin/next" "$@"
+  // ...which is what it will look like on Windows
+  SCRIPT_PATH_RE
+    .captures(text)
+    .and_then(|c| c.get(1))
+    .map(|relative_path| {
+      file_path.parent().unwrap().join(relative_path.as_str())
+    })
 }

 fn resolve_managed_npm_commands(
@ -564,6 +576,16 @@ mod test {
    let unix_shim = r#"#!/usr/bin/env node
 "use strict";
 console.log('Hi!');
+"#;
+    let path = PathBuf::from("/node_modules/.bin/example");
+    assert_eq!(
+      resolve_execution_path_from_npx_shim(path.clone(), unix_shim).unwrap(),
+      path
+    );
+    // example shim on unix
+    let unix_shim = r#"#!/usr/bin/env -S node
+"use strict";
+console.log('Hi!');
 "#;
    let path = PathBuf::from("/node_modules/.bin/example");
    assert_eq!(
--- a/cli/tools/bench/mod.rs
+++ b/cli/tools/bench/mod.rs
@ -486,6 +486,7 @@ pub async fn run_benchmarks_with_watch(
    ),
    move |flags, watcher_communicator, changed_paths| {
      let bench_flags = bench_flags.clone();
+      watcher_communicator.show_path_changed(changed_paths.clone());
      Ok(async move {
        let factory = CliFactory::from_flags_for_watcher(
          flags,
--- a/cli/tools/check.rs
+++ b/cli/tools/check.rs
@ -380,6 +380,11 @@ fn get_check_hash(
        hasher.write_str(module.specifier.as_str());
        hasher.write_str(&module.source);
      }
+      Module::Wasm(module) => {
+        has_file_to_type_check = true;
+        hasher.write_str(module.specifier.as_str());
+        hasher.write_str(&module.source_dts);
+      }
      Module::External(module) => {
        hasher.write_str(module.specifier.as_str());
      }
@ -437,6 +442,7 @@ fn get_tsc_roots(
        | MediaType::SourceMap
        | MediaType::Unknown => None,
      },
+      Module::Wasm(module) => Some((module.specifier.clone(), MediaType::Dmts)),
      Module::External(_)
      | Module::Node(_)
      | Module::Npm(_)
--- a/cli/tools/compile.rs
+++ b/cli/tools/compile.rs
@ -7,6 +7,7 @@ use crate::factory::CliFactory;
 use crate::http_util::HttpClientProvider;
 use crate::standalone::binary::StandaloneRelativeFileBaseUrl;
 use crate::standalone::is_standalone_binary;
+use deno_ast::MediaType;
 use deno_ast::ModuleSpecifier;
 use deno_core::anyhow::bail;
 use deno_core::anyhow::Context;
@ -31,15 +32,12 @@ pub async fn compile(
  let module_graph_creator = factory.module_graph_creator().await?;
  let binary_writer = factory.create_compile_binary_writer().await?;
  let http_client = factory.http_client_provider();
-  let module_specifier = cli_options.resolve_main_module()?;
-  let module_roots = {
-    let mut vec = Vec::with_capacity(compile_flags.include.len() + 1);
-    vec.push(module_specifier.clone());
-    for side_module in &compile_flags.include {
-      vec.push(resolve_url_or_path(side_module, cli_options.initial_cwd())?);
-    }
-    vec
-  };
+  let entrypoint = cli_options.resolve_main_module()?;
+  let (module_roots, include_files) = get_module_roots_and_include_files(
+    entrypoint,
+    &compile_flags,
+    cli_options.initial_cwd(),
+  )?;

  // this is not supported, so show a warning about it, but don't error in order
  // to allow someone to still run `deno compile` when this is in a deno.json
@ -82,18 +80,22 @@ pub async fn compile(
  check_warn_tsconfig(&ts_config_for_emit);
  let root_dir_url = resolve_root_dir_from_specifiers(
    cli_options.workspace().root_dir(),
-    graph.specifiers().map(|(s, _)| s).chain(
-      cli_options
-        .node_modules_dir_path()
-        .and_then(|p| ModuleSpecifier::from_directory_path(p).ok())
-        .iter(),
-    ),
+    graph
+      .specifiers()
+      .map(|(s, _)| s)
+      .chain(
+        cli_options
+          .node_modules_dir_path()
+          .and_then(|p| ModuleSpecifier::from_directory_path(p).ok())
+          .iter(),
+      )
+      .chain(include_files.iter()),
  );
  log::debug!("Binary root dir: {}", root_dir_url);
  log::info!(
    "{} {} to {}",
    colors::green("Compile"),
-    module_specifier.to_string(),
+    entrypoint,
    output_path.display(),
  );
  validate_output_path(&output_path)?;
@ -118,9 +120,9 @@ pub async fn compile(
      file,
      &graph,
      StandaloneRelativeFileBaseUrl::from(&root_dir_url),
-      module_specifier,
+      entrypoint,
+      &include_files,
      &compile_flags,
-      cli_options,
    )
    .await
    .with_context(|| {
@ -212,6 +214,48 @@ fn validate_output_path(output_path: &Path) -> Result<(), AnyError> {
  Ok(())
 }

+fn get_module_roots_and_include_files(
+  entrypoint: &ModuleSpecifier,
+  compile_flags: &CompileFlags,
+  initial_cwd: &Path,
+) -> Result<(Vec<ModuleSpecifier>, Vec<ModuleSpecifier>), AnyError> {
+  fn is_module_graph_module(url: &ModuleSpecifier) -> bool {
+    if url.scheme() != "file" {
+      return true;
+    }
+    let media_type = MediaType::from_specifier(url);
+    match media_type {
+      MediaType::JavaScript
+      | MediaType::Jsx
+      | MediaType::Mjs
+      | MediaType::Cjs
+      | MediaType::TypeScript
+      | MediaType::Mts
+      | MediaType::Cts
+      | MediaType::Dts
+      | MediaType::Dmts
+      | MediaType::Dcts
+      | MediaType::Tsx
+      | MediaType::Json
+      | MediaType::Wasm => true,
+      MediaType::Css | MediaType::SourceMap | MediaType::Unknown => false,
+    }
+  }
+
+  let mut module_roots = Vec::with_capacity(compile_flags.include.len() + 1);
+  let mut include_files = Vec::with_capacity(compile_flags.include.len());
+  module_roots.push(entrypoint.clone());
+  for side_module in &compile_flags.include {
+    let url = resolve_url_or_path(side_module, initial_cwd)?;
+    if is_module_graph_module(&url) {
+      module_roots.push(url);
+    } else {
+      include_files.push(url);
+    }
+  }
+  Ok((module_roots, include_files))
+}
+
 async fn resolve_compile_executable_output_path(
  http_client_provider: &HttpClientProvider,
  compile_flags: &CompileFlags,
--- a/cli/tools/doc.rs
+++ b/cli/tools/doc.rs
@ -21,6 +21,8 @@ use deno_core::error::AnyError;
 use deno_core::serde_json;
 use deno_doc as doc;
 use deno_doc::html::UrlResolveKind;
+use deno_doc::html::UsageComposer;
+use deno_doc::html::UsageComposerEntry;
 use deno_graph::source::NullFileSystem;
 use deno_graph::EsParser;
 use deno_graph::GraphKind;
@ -35,6 +37,9 @@ use std::sync::Arc;

 const JSON_SCHEMA_VERSION: u8 = 1;

+const PRISM_CSS: &str = include_str!("./doc/prism.css");
+const PRISM_JS: &str = include_str!("./doc/prism.js");
+
 async fn generate_doc_nodes_for_builtin_types(
  doc_flags: DocFlags,
  parser: &dyn EsParser,
@ -204,10 +209,14 @@ pub async fn doc(
      Default::default()
    };

+    let mut main_entrypoint = None;
+
    let rewrite_map =
      if let Some(config_file) = cli_options.start_dir.maybe_deno_json() {
        let config = config_file.to_exports_config()?;

+        main_entrypoint = config.get_resolved(".").ok().flatten();
+
        let rewrite_map = config
          .clone()
          .into_map()
@ -235,6 +244,7 @@ pub async fn doc(
      html_options,
      deno_ns,
      rewrite_map,
+      main_entrypoint,
    )
  } else {
    let modules_len = doc_nodes_by_url.len();
@ -312,10 +322,6 @@ impl deno_doc::html::HrefResolver for DocResolver {
    None
  }

-  fn resolve_usage(&self, current_resolve: UrlResolveKind) -> Option<String> {
-    current_resolve.get_file().map(|file| file.path.to_string())
-  }
-
  fn resolve_source(&self, location: &deno_doc::Location) -> Option<String> {
    Some(location.filename.to_string())
  }
@ -350,105 +356,30 @@ impl deno_doc::html::HrefResolver for DocResolver {
  }
 }

-struct DenoDocResolver(bool);
+struct DocComposer;

-impl deno_doc::html::HrefResolver for DenoDocResolver {
-  fn resolve_path(
+impl UsageComposer for DocComposer {
+  fn is_single_mode(&self) -> bool {
+    true
+  }
+
+  fn compose(
    &self,
-    current: UrlResolveKind,
-    target: UrlResolveKind,
-  ) -> String {
-    let path = deno_doc::html::href_path_resolve(current, target);
-    if self.0 {
-      if let Some(path) = path
-        .strip_suffix("index.html")
-        .or_else(|| path.strip_suffix(".html"))
-      {
-        return path.to_owned();
-      }
-    }
-
-    path
-  }
-
-  fn resolve_global_symbol(&self, _symbol: &[String]) -> Option<String> {
-    None
-  }
-
-  fn resolve_import_href(
-    &self,
-    _symbol: &[String],
-    _src: &str,
-  ) -> Option<String> {
-    None
-  }
-
-  fn resolve_usage(&self, _current_resolve: UrlResolveKind) -> Option<String> {
-    None
-  }
-
-  fn resolve_source(&self, _location: &deno_doc::Location) -> Option<String> {
-    None
-  }
-
-  fn resolve_external_jsdoc_module(
-    &self,
-    _module: &str,
-    _symbol: Option<&str>,
-  ) -> Option<(String, String)> {
-    None
-  }
-}
-
-struct NodeDocResolver(bool);
-
-impl deno_doc::html::HrefResolver for NodeDocResolver {
-  fn resolve_path(
-    &self,
-    current: UrlResolveKind,
-    target: UrlResolveKind,
-  ) -> String {
-    let path = deno_doc::html::href_path_resolve(current, target);
-    if self.0 {
-      if let Some(path) = path
-        .strip_suffix("index.html")
-        .or_else(|| path.strip_suffix(".html"))
-      {
-        return path.to_owned();
-      }
-    }
-
-    path
-  }
-
-  fn resolve_global_symbol(&self, _symbol: &[String]) -> Option<String> {
-    None
-  }
-
-  fn resolve_import_href(
-    &self,
-    _symbol: &[String],
-    _src: &str,
-  ) -> Option<String> {
-    None
-  }
-
-  fn resolve_usage(&self, current_resolve: UrlResolveKind) -> Option<String> {
+    current_resolve: UrlResolveKind,
+    usage_to_md: deno_doc::html::UsageToMd,
+  ) -> IndexMap<UsageComposerEntry, String> {
    current_resolve
      .get_file()
-      .map(|file| format!("node:{}", file.path))
-  }
-
-  fn resolve_source(&self, _location: &deno_doc::Location) -> Option<String> {
-    None
-  }
-
-  fn resolve_external_jsdoc_module(
-    &self,
-    _module: &str,
-    _symbol: Option<&str>,
-  ) -> Option<(String, String)> {
-    None
+      .map(|current_file| {
+        IndexMap::from([(
+          UsageComposerEntry {
+            name: "".to_string(),
+            icon: None,
+          },
+          usage_to_md(current_file.path.as_str(), None),
+        )])
+      })
+      .unwrap_or_default()
  }
 }

@ -457,34 +388,15 @@ fn generate_docs_directory(
  html_options: &DocHtmlFlag,
  deno_ns: std::collections::HashMap<Vec<String>, Option<Rc<ShortPath>>>,
  rewrite_map: Option<IndexMap<ModuleSpecifier, String>>,
+  main_entrypoint: Option<ModuleSpecifier>,
 ) -> Result<(), AnyError> {
  let cwd = std::env::current_dir().context("Failed to get CWD")?;
  let output_dir_resolved = cwd.join(&html_options.output);

-  let internal_env = std::env::var("DENO_INTERNAL_HTML_DOCS").ok();
-
-  let href_resolver: Rc<dyn deno_doc::html::HrefResolver> = if internal_env
-    .as_ref()
-    .is_some_and(|internal_html_docs| internal_html_docs == "node")
-  {
-    Rc::new(NodeDocResolver(html_options.strip_trailing_html))
-  } else if internal_env
-    .as_ref()
-    .is_some_and(|internal_html_docs| internal_html_docs == "deno")
-    || deno_ns.is_empty()
-  {
-    Rc::new(DenoDocResolver(html_options.strip_trailing_html))
-  } else {
-    Rc::new(DocResolver {
-      deno_ns,
-      strip_trailing_html: html_options.strip_trailing_html,
-    })
-  };
-
  let category_docs =
    if let Some(category_docs_path) = &html_options.category_docs_path {
      let content = std::fs::read(category_docs_path)?;
-      Some(deno_core::serde_json::from_slice(&content)?)
+      Some(serde_json::from_slice(&content)?)
    } else {
      None
    };
@ -493,7 +405,7 @@ fn generate_docs_directory(
    &html_options.symbol_redirect_map_path
  {
    let content = std::fs::read(symbol_redirect_map_path)?;
-    Some(deno_core::serde_json::from_slice(&content)?)
+    Some(serde_json::from_slice(&content)?)
  } else {
    None
  };
@ -502,26 +414,42 @@ fn generate_docs_directory(
    &html_options.default_symbol_map_path
  {
    let content = std::fs::read(default_symbol_map_path)?;
-    Some(deno_core::serde_json::from_slice(&content)?)
+    Some(serde_json::from_slice(&content)?)
  } else {
    None
  };

  let options = deno_doc::html::GenerateOptions {
    package_name: html_options.name.clone(),
-    main_entrypoint: None,
+    main_entrypoint,
    rewrite_map,
-    href_resolver,
-    usage_composer: None,
+    href_resolver: Rc::new(DocResolver {
+      deno_ns,
+      strip_trailing_html: html_options.strip_trailing_html,
+    }),
+    usage_composer: Rc::new(DocComposer),
    category_docs,
-    disable_search: internal_env.is_some(),
+    disable_search: false,
    symbol_redirect_map,
    default_symbol_map,
+    markdown_renderer: deno_doc::html::comrak::create_renderer(
+      None, None, None,
+    ),
+    markdown_stripper: Rc::new(deno_doc::html::comrak::strip),
+    head_inject: Some(Rc::new(|root| {
+      format!(
+        r#"<link href="{root}{}" rel="stylesheet" /><link href="{root}prism.css" rel="stylesheet" /><script src="{root}prism.js"></script>"#,
+        deno_doc::html::comrak::COMRAK_STYLESHEET_FILENAME
+      )
+    })),
  };

-  let files = deno_doc::html::generate(options, doc_nodes_by_url)
+  let mut files = deno_doc::html::generate(options, doc_nodes_by_url)
    .context("Failed to generate HTML documentation")?;

+  files.insert("prism.js".to_string(), PRISM_JS.to_string());
+  files.insert("prism.css".to_string(), PRISM_CSS.to_string());
+
  let path = &output_dir_resolved;
  let _ = std::fs::remove_dir_all(path);
  std::fs::create_dir(path)
--- a/cli/tools/doc/prism.css
+++ b/cli/tools/doc/prism.css
@ -0,0 +1,3 @@
+/* PrismJS 1.29.0
+https://prismjs.com/download.html#themes=prism&languages=markup+css+clike+javascript+bash+json+markdown+regex+rust+typescript */
+code[class*=language-],pre[class*=language-]{color:#000;background:0 0;text-shadow:0 1px #fff;font-family:Consolas,Monaco,'Andale Mono','Ubuntu Mono',monospace;font-size:1em;text-align:left;white-space:pre;word-spacing:normal;word-break:normal;word-wrap:normal;line-height:1.5;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-hyphens:none;-moz-hyphens:none;-ms-hyphens:none;hyphens:none}code[class*=language-] ::-moz-selection,code[class*=language-]::-moz-selection,pre[class*=language-] ::-moz-selection,pre[class*=language-]::-moz-selection{text-shadow:none;background:#b3d4fc}code[class*=language-] ::selection,code[class*=language-]::selection,pre[class*=language-] ::selection,pre[class*=language-]::selection{text-shadow:none;background:#b3d4fc}@media print{code[class*=language-],pre[class*=language-]{text-shadow:none}}pre[class*=language-]{overflow:auto}:not(pre)>code[class*=language-],pre[class*=language-]{background:#f5f2f0}:not(pre)>code[class*=language-]{padding:.1em;border-radius:.3em;white-space:normal}.token.cdata,.token.comment,.token.doctype,.token.prolog{color:#708090}.token.punctuation{color:#999}.token.namespace{opacity:.7}.token.boolean,.token.constant,.token.deleted,.token.number,.token.property,.token.symbol,.token.tag{color:#905}.token.attr-name,.token.builtin,.token.char,.token.inserted,.token.selector,.token.string{color:#690}.language-css .token.string,.style .token.string,.token.entity,.token.operator,.token.url{color:#9a6e3a;background:hsla(0,0%,100%,.5)}.token.atrule,.token.attr-value,.token.keyword{color:#07a}.token.class-name,.token.function{color:#dd4a68}.token.important,.token.regex,.token.variable{color:#e90}.token.bold,.token.important{font-weight:700}.token.italic{font-style:italic}.token.entity{cursor:help}
--- a/cli/tools/doc/prism.js
+++ b/cli/tools/doc/prism.js
--- a/cli/tools/fmt.rs
+++ b/cli/tools/fmt.rs
@ -83,6 +83,7 @@ pub async fn format(
      file_watcher::PrintConfig::new("Fmt", !watch_flags.no_clear_screen),
      move |flags, watcher_communicator, changed_paths| {
        let fmt_flags = fmt_flags.clone();
+        watcher_communicator.show_path_changed(changed_paths.clone());
        Ok(async move {
          let factory = CliFactory::from_flags(flags);
          let cli_options = factory.cli_options()?;
@ -227,6 +228,7 @@ fn collect_fmt_files(
  })
  .ignore_git_folder()
  .ignore_node_modules()
+  .use_gitignore()
  .set_vendor_folder(cli_options.vendor_dir_path().map(ToOwned::to_owned))
  .collect_file_patterns(&deno_config::fs::RealDenoConfigFs, files)
 }
@ -270,6 +272,7 @@ fn format_markdown(
          | "njk"
          | "yml"
          | "yaml"
+          | "sql"
      ) {
        // It's important to tell dprint proper file extension, otherwise
        // it might parse the file twice.
@ -299,6 +302,13 @@ fn format_markdown(
            }
          }
          "yml" | "yaml" => format_yaml(text, fmt_options),
+          "sql" => {
+            if unstable_options.sql {
+              format_sql(text, fmt_options)
+            } else {
+              Ok(None)
+            }
+          }
          _ => {
            let mut codeblock_config =
              get_resolved_typescript_config(fmt_options);
@ -501,7 +511,52 @@ pub fn format_html(
  })
 }

-/// Formats a single TS, TSX, JS, JSX, JSONC, JSON, MD, or IPYNB file.
+pub fn format_sql(
+  file_text: &str,
+  fmt_options: &FmtOptionsConfig,
+) -> Result<Option<String>, AnyError> {
+  let ignore_file = file_text
+    .lines()
+    .take_while(|line| line.starts_with("--"))
+    .any(|line| {
+      line
+        .strip_prefix("--")
+        .unwrap()
+        .trim()
+        .starts_with("deno-fmt-ignore-file")
+    });
+
+  if ignore_file {
+    return Ok(None);
+  }
+
+  let mut formatted_str = sqlformat::format(
+    file_text,
+    &sqlformat::QueryParams::None,
+    &sqlformat::FormatOptions {
+      ignore_case_convert: None,
+      indent: if fmt_options.use_tabs.unwrap_or_default() {
+        sqlformat::Indent::Tabs
+      } else {
+        sqlformat::Indent::Spaces(fmt_options.indent_width.unwrap_or(2))
+      },
+      // leave one blank line between queries.
+      lines_between_queries: 2,
+      uppercase: Some(true),
+    },
+  );
+
+  // Add single new line to the end of file.
+  formatted_str.push('\n');
+
+  Ok(if formatted_str == file_text {
+    None
+  } else {
+    Some(formatted_str)
+  })
+}
+
+/// Formats a single TS, TSX, JS, JSX, JSONC, JSON, MD, IPYNB or SQL file.
 pub fn format_file(
  file_path: &Path,
  file_text: &str,
@ -536,6 +591,13 @@ pub fn format_file(
        format_file(file_path, &file_text, fmt_options, unstable_options, None)
      },
    ),
+    "sql" => {
+      if unstable_options.sql {
+        format_sql(file_text, fmt_options)
+      } else {
+        Ok(None)
+      }
+    }
    _ => {
      let config = get_resolved_typescript_config(fmt_options);
      dprint_plugin_typescript::format_text(
@ -1207,6 +1269,7 @@ fn is_supported_ext_fmt(path: &Path) -> bool {
        | "yml"
        | "yaml"
        | "ipynb"
+        | "sql"
    )
  })
 }
@ -1267,6 +1330,11 @@ mod test {
    assert!(is_supported_ext_fmt(Path::new("foo.yaml")));
    assert!(is_supported_ext_fmt(Path::new("foo.YaML")));
    assert!(is_supported_ext_fmt(Path::new("foo.ipynb")));
+    assert!(is_supported_ext_fmt(Path::new("foo.sql")));
+    assert!(is_supported_ext_fmt(Path::new("foo.Sql")));
+    assert!(is_supported_ext_fmt(Path::new("foo.sQl")));
+    assert!(is_supported_ext_fmt(Path::new("foo.sqL")));
+    assert!(is_supported_ext_fmt(Path::new("foo.SQL")));
  }

  #[test]
--- a/cli/tools/info.rs
+++ b/cli/tools/info.rs
@ -49,19 +49,67 @@ pub async fn info(
    let module_graph_creator = factory.module_graph_creator().await?;
    let npm_resolver = factory.npm_resolver().await?;
    let maybe_lockfile = cli_options.maybe_lockfile();
+    let resolver = factory.workspace_resolver().await?.clone();
    let npmrc = cli_options.npmrc();
-    let resolver = factory.workspace_resolver().await?;
+    let node_resolver = factory.node_resolver().await?;

    let cwd_url =
      url::Url::from_directory_path(cli_options.initial_cwd()).unwrap();

-    let maybe_import_specifier = if let Some(import_map) =
-      resolver.maybe_import_map()
+    let maybe_import_specifier = if let Ok(resolved) =
+      resolver.resolve(&specifier, &cwd_url)
    {
-      if let Ok(imports_specifier) = import_map.resolve(&specifier, &cwd_url) {
-        Some(imports_specifier)
-      } else {
-        None
+      match resolved {
+        deno_config::workspace::MappedResolution::Normal {
+          specifier, ..
+        }
+        | deno_config::workspace::MappedResolution::ImportMap {
+          specifier,
+          ..
+        }
+        | deno_config::workspace::MappedResolution::WorkspaceJsrPackage {
+          specifier,
+          ..
+        } => Some(specifier),
+        deno_config::workspace::MappedResolution::WorkspaceNpmPackage {
+          target_pkg_json,
+          sub_path,
+          ..
+        } => Some(node_resolver.resolve_package_subpath_from_deno_module(
+          target_pkg_json.clone().dir_path(),
+          sub_path.as_deref(),
+          Some(&cwd_url),
+          node_resolver::ResolutionMode::Import,
+          node_resolver::NodeResolutionKind::Execution,
+        )?),
+        deno_config::workspace::MappedResolution::PackageJson {
+          alias,
+          sub_path,
+          dep_result,
+          ..
+        } => match dep_result.as_ref().map_err(|e| e.clone())? {
+          deno_package_json::PackageJsonDepValue::Workspace(version_req) => {
+            let pkg_folder = resolver
+              .resolve_workspace_pkg_json_folder_for_pkg_json_dep(
+                alias,
+                version_req,
+              )?;
+            Some(node_resolver.resolve_package_subpath_from_deno_module(
+              pkg_folder,
+              sub_path.as_deref(),
+              Some(&cwd_url),
+              node_resolver::ResolutionMode::Import,
+              node_resolver::NodeResolutionKind::Execution,
+            )?)
+          }
+          deno_package_json::PackageJsonDepValue::Req(req) => {
+            Some(ModuleSpecifier::parse(&format!(
+              "npm:{}{}",
+              req,
+              sub_path.map(|s| format!("/{}", s)).unwrap_or_default()
+            ))?)
+          }
+        },
      }
    } else {
      None
@ -126,6 +174,7 @@ fn print_cache_info(
  let registry_cache = dir.registries_folder_path();
  let mut origin_dir = dir.origin_data_folder_path();
  let deno_dir = dir.root_path_for_display().to_string();
+  let web_cache_dir = crate::worker::get_cache_storage_dir();

  if let Some(location) = &location {
    origin_dir =
@ -143,6 +192,7 @@ fn print_cache_info(
      "typescriptCache": typescript_cache,
      "registryCache": registry_cache,
      "originStorage": origin_dir,
+      "webCacheStorage": web_cache_dir,
    });

    if location.is_some() {
@ -177,6 +227,11 @@ fn print_cache_info(
      colors::bold("Origin storage:"),
      origin_dir.display()
    );
+    println!(
+      "{} {}",
+      colors::bold("Web cache storage:"),
+      web_cache_dir.display()
+    );
    if location.is_some() {
      println!(
        "{} {}",
@ -228,22 +283,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() {
-          if let serde_json::Value::Object(dep) = dep {
-            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(pkg) =
-                  snapshot.resolve_pkg_from_pkg_req(npm_ref.req())
-                {
-                  dep.insert(
-                    "npmPackage".to_string(),
-                    pkg.id.as_serialized().into(),
-                  );
-                }
+        for dep in dependencies.iter_mut().flat_map(|d| d.as_object_mut()) {
+          if let Some(specifier) = dep.get("specifier").and_then(|s| s.as_str())
+          {
+            if let Ok(npm_ref) = NpmPackageReqReference::from_str(specifier) {
+              if let Ok(pkg) = snapshot.resolve_pkg_from_pkg_req(npm_ref.req())
+              {
+                dep.insert(
+                  "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");
+          }
        }
      }
    }
@ -446,6 +510,7 @@ impl<'a> GraphDisplayContext<'a> {
        let maybe_cache_info = match root {
          Module::Js(module) => module.maybe_cache_info.as_ref(),
          Module::Json(module) => module.maybe_cache_info.as_ref(),
+          Module::Wasm(module) => module.maybe_cache_info.as_ref(),
          Module::Node(_) | Module::Npm(_) | Module::External(_) => None,
        };
        if let Some(cache_info) = maybe_cache_info {
@ -468,6 +533,7 @@ impl<'a> GraphDisplayContext<'a> {
            let size = match m {
              Module::Js(module) => module.size(),
              Module::Json(module) => module.size(),
+              Module::Wasm(module) => module.size(),
              Module::Node(_) | Module::Npm(_) | Module::External(_) => 0,
            };
            size as f64
@ -567,6 +633,7 @@ impl<'a> GraphDisplayContext<'a> {
        Specifier(_) => match module {
          Module::Js(module) => Some(module.size() as u64),
          Module::Json(module) => Some(module.size() as u64),
+          Module::Wasm(module) => Some(module.size() as u64),
          Module::Node(_) | Module::Npm(_) | Module::External(_) => None,
        },
      };
@ -580,8 +647,8 @@ impl<'a> GraphDisplayContext<'a> {
        Package(package) => {
          tree_node.children.extend(self.build_npm_deps(package));
        }
-        Specifier(_) => {
-          if let Some(module) = module.js() {
+        Specifier(_) => match module {
+          Module::Js(module) => {
            if let Some(types_dep) = &module.maybe_types_dependency {
              if let Some(child) =
                self.build_resolved_info(&types_dep.dependency, true)
@ -593,7 +660,16 @@ impl<'a> GraphDisplayContext<'a> {
              tree_node.children.extend(self.build_dep_info(dep));
            }
          }
-        }
+          Module::Wasm(module) => {
+            for dep in module.dependencies.values() {
+              tree_node.children.extend(self.build_dep_info(dep));
+            }
+          }
+          Module::Json(_)
+          | Module::Npm(_)
+          | Module::Node(_)
+          | Module::External(_) => {}
+        },
      }
    }
    tree_node
@ -658,7 +734,7 @@ impl<'a> GraphDisplayContext<'a> {
        };
        self.build_error_msg(specifier, message.as_ref())
      }
-      ModuleError::ParseErr(_, _) => {
+      ModuleError::ParseErr(_, _) | ModuleError::WasmParseErr(_, _) => {
        self.build_error_msg(specifier, "(parsing error)")
      }
      ModuleError::UnsupportedImportAttributeType { .. } => {
--- a/cli/tools/init/mod.rs
+++ b/cli/tools/init/mod.rs
@ -1,15 +1,29 @@
 // Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.

+use crate::args::DenoSubcommand;
+use crate::args::Flags;
 use crate::args::InitFlags;
+use crate::args::PackagesAllowedScripts;
+use crate::args::PermissionFlags;
+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;
+use deno_runtime::WorkerExecutionMode;
 use log::info;
+use std::io::IsTerminal;
 use std::io::Write;
 use std::path::Path;

-pub fn init_project(init_flags: InitFlags) -> Result<(), AnyError> {
+pub async fn init_project(init_flags: InitFlags) -> Result<i32, AnyError> {
+  if let Some(package) = &init_flags.package {
+    return init_npm(package, init_flags.package_args).await;
+  }
+
  let cwd =
    std::env::current_dir().context("Can't read current working directory.")?;
  let dir = if let Some(dir) = &init_flags.dir {
@ -235,7 +249,97 @@ Deno.test(function addTest() {
    info!("  {}", colors::gray("# Run the tests"));
    info!("  deno test");
  }
-  Ok(())
+  Ok(0)
+}
+
+fn npm_name_to_create_package(name: &str) -> String {
+  let mut s = "npm:".to_string();
+
+  let mut scoped = false;
+  let mut create = false;
+
+  for (i, ch) in name.char_indices() {
+    if i == 0 {
+      if ch == '@' {
+        scoped = true;
+      } else {
+        create = true;
+        s.push_str("create-");
+      }
+    } else if scoped {
+      if ch == '/' {
+        scoped = false;
+        create = true;
+        s.push_str("/create-");
+        continue;
+      } else if ch == '@' && !create {
+        scoped = false;
+        create = true;
+        s.push_str("/create@");
+        continue;
+      }
+    }
+
+    s.push(ch);
+  }
+
+  if !create {
+    s.push_str("/create");
+  }
+
+  s
+}
+
+async fn init_npm(name: &str, args: Vec<String>) -> Result<i32, AnyError> {
+  let script_name = npm_name_to_create_package(name);
+
+  fn print_manual_usage(script_name: &str, args: &[String]) -> i32 {
+    log::info!("{}", cformat!("You can initialize project manually by running <u>deno run {} {}</> and applying desired permissions.", script_name, args.join(" ")));
+    1
+  }
+
+  if std::io::stdin().is_terminal() {
+    log::info!(
+      cstr!("⚠️ Do you fully trust <y>{}</> package? Deno will invoke code from it with all permissions. Do you want to continue? <p(245)>[y/n]</>"),
+      script_name
+    );
+    loop {
+      let _ = std::io::stdout().write(b"> ")?;
+      std::io::stdout().flush()?;
+      let mut answer = String::new();
+      if std::io::stdin().read_line(&mut answer).is_ok() {
+        let answer = answer.trim().to_ascii_lowercase();
+        if answer != "y" {
+          return Ok(print_manual_usage(&script_name, &args));
+        } else {
+          break;
+        }
+      }
+    }
+  } else {
+    return Ok(print_manual_usage(&script_name, &args));
+  }
+
+  let new_flags = Flags {
+    permissions: PermissionFlags {
+      allow_all: true,
+      ..Default::default()
+    },
+    allow_scripts: PackagesAllowedScripts::All,
+    argv: args,
+    node_modules_dir: Some(NodeModulesDirMode::Auto),
+    subcommand: DenoSubcommand::Run(RunFlags {
+      script: script_name,
+      ..Default::default()
+    }),
+    ..Default::default()
+  };
+  crate::tools::run::run_script(
+    WorkerExecutionMode::Run,
+    new_flags.into(),
+    None,
+  )
+  .await
 }

 fn create_json_file(
@ -270,3 +374,37 @@ fn create_file(
    Ok(())
  }
 }
+
+#[cfg(test)]
+mod test {
+  use crate::tools::init::npm_name_to_create_package;
+
+  #[test]
+  fn npm_name_to_create_package_test() {
+    // See https://docs.npmjs.com/cli/v8/commands/npm-init#description
+    assert_eq!(
+      npm_name_to_create_package("foo"),
+      "npm:create-foo".to_string()
+    );
+    assert_eq!(
+      npm_name_to_create_package("foo@1.0.0"),
+      "npm:create-foo@1.0.0".to_string()
+    );
+    assert_eq!(
+      npm_name_to_create_package("@foo"),
+      "npm:@foo/create".to_string()
+    );
+    assert_eq!(
+      npm_name_to_create_package("@foo@1.0.0"),
+      "npm:@foo/create@1.0.0".to_string()
+    );
+    assert_eq!(
+      npm_name_to_create_package("@foo/bar"),
+      "npm:@foo/create-bar".to_string()
+    );
+    assert_eq!(
+      npm_name_to_create_package("@foo/bar@1.0.0"),
+      "npm:@foo/create-bar@1.0.0".to_string()
+    );
+  }
+}
--- a/cli/tools/installer.rs
+++ b/cli/tools/installer.rs
@ -3,6 +3,7 @@
 use crate::args::resolve_no_prompt;
 use crate::args::AddFlags;
 use crate::args::CaData;
+use crate::args::CacheSetting;
 use crate::args::ConfigFlag;
 use crate::args::Flags;
 use crate::args::InstallFlags;
@ -13,8 +14,11 @@ use crate::args::TypeCheckMode;
 use crate::args::UninstallFlags;
 use crate::args::UninstallKind;
 use crate::factory::CliFactory;
+use crate::file_fetcher::FileFetcher;
 use crate::graph_container::ModuleGraphContainer;
 use crate::http_util::HttpClientProvider;
+use crate::jsr::JsrFetchResolver;
+use crate::npm::NpmFetchResolver;
 use crate::util::fs::canonicalize_path_maybe_not_exists;

 use deno_core::anyhow::bail;
@ -354,12 +358,54 @@ async fn install_global(
 ) -> Result<(), AnyError> {
  // ensure the module is cached
  let factory = CliFactory::from_flags(flags.clone());
+
+  let cli_options = factory.cli_options()?;
+  let http_client = factory.http_client_provider();
+  let deps_http_cache = factory.global_http_cache()?;
+  let mut deps_file_fetcher = FileFetcher::new(
+    deps_http_cache.clone(),
+    CacheSetting::ReloadAll,
+    true,
+    http_client.clone(),
+    Default::default(),
+    None,
+  );
+
+  let npmrc = factory.cli_options().unwrap().npmrc();
+
+  deps_file_fetcher.set_download_log_level(log::Level::Trace);
+  let deps_file_fetcher = Arc::new(deps_file_fetcher);
+  let jsr_resolver = Arc::new(JsrFetchResolver::new(deps_file_fetcher.clone()));
+  let npm_resolver = Arc::new(NpmFetchResolver::new(
+    deps_file_fetcher.clone(),
+    npmrc.clone(),
+  ));
+
+  let entry_text = install_flags_global.module_url.as_str();
+  if !cli_options.initial_cwd().join(entry_text).exists() {
+    // check for package requirement missing prefix
+    if let Ok(Err(package_req)) =
+      super::registry::AddRmPackageReq::parse(entry_text)
+    {
+      if jsr_resolver.req_to_nv(&package_req).await.is_some() {
+        bail!(
+          "{entry_text} is missing a prefix. Did you mean `{}`?",
+          crate::colors::yellow(format!("deno install -g jsr:{package_req}"))
+        );
+      } else if npm_resolver.req_to_nv(&package_req).await.is_some() {
+        bail!(
+          "{entry_text} is missing a prefix. Did you mean `{}`?",
+          crate::colors::yellow(format!("deno install -g npm:{package_req}"))
+        );
+      }
+    }
+  }
+
  factory
    .main_module_graph_container()
    .await?
    .load_and_type_check_files(&[install_flags_global.module_url.clone()])
    .await?;
-  let http_client = factory.http_client_provider();

  // create the install shim
  create_install_shim(http_client, &flags, install_flags_global).await
--- a/cli/tools/lint/mod.rs
+++ b/cli/tools/lint/mod.rs
@ -80,6 +80,7 @@ pub async fn lint(
      file_watcher::PrintConfig::new("Lint", !watch_flags.no_clear_screen),
      move |flags, watcher_communicator, changed_paths| {
        let lint_flags = lint_flags.clone();
+        watcher_communicator.show_path_changed(changed_paths.clone());
        Ok(async move {
          let factory = CliFactory::from_flags(flags);
          let cli_options = factory.cli_options()?;
@ -435,6 +436,7 @@ fn collect_lint_files(
  })
  .ignore_git_folder()
  .ignore_node_modules()
+  .use_gitignore()
  .set_vendor_folder(cli_options.vendor_dir_path().map(ToOwned::to_owned))
  .collect_file_patterns(&deno_config::fs::RealDenoConfigFs, files)
 }
--- a/cli/tools/lint/reporters.rs
+++ b/cli/tools/lint/reporters.rs
@ -175,6 +175,7 @@ struct JsonLintReporter {
  version: u8,
  diagnostics: Vec<JsonLintDiagnostic>,
  errors: Vec<LintError>,
+  checked_files: Vec<String>,
 }

 impl JsonLintReporter {
@ -183,6 +184,7 @@ impl JsonLintReporter {
      version: JSON_SCHEMA_VERSION,
      diagnostics: Vec::new(),
      errors: Vec::new(),
+      checked_files: Vec::new(),
    }
  }
 }
@ -209,6 +211,17 @@ impl LintReporter for JsonLintReporter {
      code: d.code().to_string(),
      hint: d.hint().map(|h| h.to_string()),
    });
+
+    let file_path = d
+      .specifier
+      .to_file_path()
+      .unwrap()
+      .to_string_lossy()
+      .to_string();
+
+    if !self.checked_files.contains(&file_path) {
+      self.checked_files.push(file_path);
+    }
  }

  fn visit_error(&mut self, file_path: &str, err: &AnyError) {
@ -216,10 +229,15 @@ impl LintReporter for JsonLintReporter {
      file_path: file_path.to_string(),
      message: err.to_string(),
    });
+
+    if !self.checked_files.contains(&file_path.to_string()) {
+      self.checked_files.push(file_path.to_string());
+    }
  }

  fn close(&mut self, _check_count: usize) {
    sort_diagnostics(&mut self.diagnostics);
+    self.checked_files.sort();
    let json = serde_json::to_string_pretty(&self);
    #[allow(clippy::print_stdout)]
    {
--- 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,
-          column_index: range.start.character,
+          line_index: referrer.range.start.line,
+          column_index: referrer.range.start.character,
        });
      let end_range =
        context.text_info().loc_to_source_pos(LineAndColumnIndex {
-          line_index: range.end.line,
-          column_index: range.end.character,
+          line_index: referrer.range.end.line,
+          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 {
-          ResolutionMode::Execution => SloppyImportsResolutionMode::Execution,
-          ResolutionMode::Types => SloppyImportsResolutionMode::Types,
+        match resolution_kind {
+          ResolutionKind::Execution => SloppyImportsResolutionKind::Execution,
+          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,
-          column: referrer.start.character,
+          line: referrer.range.start.line,
+          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,
-              column: referrer.start.character,
+              line: referrer.range.start.line,
+              column: referrer.range.start.character,
            },
            end: DiagnosticSourcePos::LineAndCol {
-              line: referrer.end.line,
-              column: referrer.end.character,
+              line: referrer.range.end.line,
+              column: referrer.range.end.character,
            },
          },
          description: Some("the specifier".into()),
@ -476,7 +476,7 @@ impl Diagnostic for PublishDiagnostic {
      InvalidExternalImport { imported, .. } => Cow::Owned(vec![
        Cow::Owned(format!("the import was resolved to '{}'", imported)),
        Cow::Borrowed("this specifier is not allowed to be imported on jsr"),
-        Cow::Borrowed("jsr only supports importing `jsr:`, `npm:`, and `data:` specifiers"),
+        Cow::Borrowed("jsr only supports importing `jsr:`, `npm:`, `data:`, `bun:`, and `node:` specifiers"),
      ]),
      UnsupportedJsxTsx { .. } => Cow::Owned(vec![
        Cow::Borrowed("follow https://github.com/jsr-io/jsr/issues/24 for updates"),
--- a/cli/tools/registry/graph.rs
+++ b/cli/tools/registry/graph.rs
@ -47,7 +47,7 @@ impl GraphDiagnosticsCollector {
       resolution: &ResolutionResolved| {
        if visited.insert(resolution.specifier.clone()) {
          match resolution.specifier.scheme() {
-            "file" | "data" | "node" => {}
+            "file" | "data" | "node" | "bun" => {}
            "jsr" => {
              skip_specifiers.insert(resolution.specifier.clone());

--- a/cli/tools/registry/mod.rs
+++ b/cli/tools/registry/mod.rs
@ -12,6 +12,7 @@ use std::sync::Arc;
 use base64::prelude::BASE64_STANDARD;
 use base64::Engine;
 use deno_ast::ModuleSpecifier;
+use deno_config::deno_json::ConfigFile;
 use deno_config::workspace::JsrPackageConfig;
 use deno_config::workspace::PackageJsonDepResolution;
 use deno_config::workspace::Workspace;
@ -67,8 +68,10 @@ use auth::get_auth_method;
 use auth::AuthMethod;
 pub use pm::add;
 pub use pm::cache_top_level_deps;
+pub use pm::outdated;
 pub use pm::remove;
 pub use pm::AddCommandName;
+pub use pm::AddRmPackageReq;
 use publish_order::PublishOrderGraph;
 use unfurl::SpecifierUnfurler;

@ -89,15 +92,15 @@ pub async fn publish(

  let cli_options = cli_factory.cli_options()?;
  let directory_path = cli_options.initial_cwd();
-  let publish_configs = cli_options.start_dir.jsr_packages_for_publish();
+  let mut publish_configs = cli_options.start_dir.jsr_packages_for_publish();
  if publish_configs.is_empty() {
    match cli_options.start_dir.maybe_deno_json() {
      Some(deno_json) => {
        debug_assert!(!deno_json.is_package());
-        bail!(
-          "Missing 'name', 'version' and 'exports' field in '{}'.",
-          deno_json.specifier
-        );
+        if deno_json.json.name.is_none() {
+          bail!("Missing 'name' field in '{}'.", deno_json.specifier);
+        }
+        error_missing_exports_field(deno_json)?;
      }
      None => {
        bail!(
@ -107,6 +110,18 @@ pub async fn publish(
      }
    }
  }
+
+  if let Some(version) = &publish_flags.set_version {
+    if publish_configs.len() > 1 {
+      bail!("Cannot use --set-version when publishing a workspace. Change your cwd to an individual package instead.");
+    }
+    if let Some(publish_config) = publish_configs.get_mut(0) {
+      let mut config_file = publish_config.config_file.as_ref().clone();
+      config_file.json.version = Some(version.clone());
+      publish_config.config_file = Arc::new(config_file);
+    }
+  }
+
  let specifier_unfurler = Arc::new(SpecifierUnfurler::new(
    if cli_options.unstable_sloppy_imports() {
      Some(CliSloppyImportsResolver::new(SloppyImportsCachedFs::new(
@ -403,43 +418,15 @@ impl PublishPreparer {
    graph: Arc<deno_graph::ModuleGraph>,
    diagnostics_collector: &PublishDiagnosticsCollector,
  ) -> Result<Rc<PreparedPublishPackage>, AnyError> {
-    static SUGGESTED_ENTRYPOINTS: [&str; 4] =
-      ["mod.ts", "mod.js", "index.ts", "index.js"];
-
    let deno_json = &package.config_file;
    let config_path = deno_json.specifier.to_file_path().unwrap();
    let root_dir = config_path.parent().unwrap().to_path_buf();
-    let Some(version) = deno_json.json.version.clone() else {
-      bail!("{} is missing 'version' field", deno_json.specifier);
-    };
-    if deno_json.json.exports.is_none() {
-      let mut suggested_entrypoint = None;
-
-      for entrypoint in SUGGESTED_ENTRYPOINTS {
-        if root_dir.join(entrypoint).exists() {
-          suggested_entrypoint = Some(entrypoint);
-          break;
-        }
-      }
-
-      let exports_content = format!(
-        r#"{{
-  "name": "{}",
-  "version": "{}",
-  "exports": "{}"
-}}"#,
-        package.name,
-        version,
-        suggested_entrypoint.unwrap_or("<path_to_entrypoint>")
-      );
-
-      bail!(
-      "You did not specify an entrypoint to \"{}\" package in {}. Add `exports` mapping in the configuration file, eg:\n{}",
-      package.name,
-      deno_json.specifier,
-      exports_content
-    );
-    }
+    let version = deno_json.json.version.clone().ok_or_else(|| {
+      deno_core::anyhow::anyhow!(
+        "{} is missing 'version' field",
+        deno_json.specifier
+      )
+    })?;
    let Some(name_no_at) = package.name.strip_prefix('@') else {
      bail!("Invalid package name, use '@<scope_name>/<package_name> format");
    };
@ -1106,9 +1093,9 @@ fn collect_excluded_module_diagnostics(
  let graph_specifiers = graph
    .modules()
    .filter_map(|m| match m {
-      deno_graph::Module::Js(_) | deno_graph::Module::Json(_) => {
-        Some(m.specifier())
-      }
+      deno_graph::Module::Js(_)
+      | deno_graph::Module::Json(_)
+      | deno_graph::Module::Wasm(_) => Some(m.specifier()),
      deno_graph::Module::Npm(_)
      | deno_graph::Module::Node(_)
      | deno_graph::Module::External(_) => None,
@ -1271,6 +1258,36 @@ fn has_license_file<'a>(
  })
 }

+fn error_missing_exports_field(deno_json: &ConfigFile) -> Result<(), AnyError> {
+  static SUGGESTED_ENTRYPOINTS: [&str; 4] =
+    ["mod.ts", "mod.js", "index.ts", "index.js"];
+  let mut suggested_entrypoint = None;
+
+  for entrypoint in SUGGESTED_ENTRYPOINTS {
+    if deno_json.dir_path().join(entrypoint).exists() {
+      suggested_entrypoint = Some(entrypoint);
+      break;
+    }
+  }
+
+  let exports_content = format!(
+    r#"{{
+  "name": "{}",
+  "version": "{}",
+  "exports": "{}"
+}}"#,
+    deno_json.json.name.as_deref().unwrap_or("@scope/name"),
+    deno_json.json.name.as_deref().unwrap_or("0.0.0"),
+    suggested_entrypoint.unwrap_or("<path_to_entrypoint>")
+  );
+
+  bail!(
+    "You did not specify an entrypoint in {}. Add `exports` mapping in the configuration file, eg:\n{}",
+    deno_json.specifier,
+    exports_content
+  );
+}
+
 #[allow(clippy::print_stderr)]
 fn ring_bell() {
  // ASCII code for the bell character.
--- a/cli/tools/registry/pm.rs
+++ b/cli/tools/registry/pm.rs
@ -16,6 +16,7 @@ use deno_semver::package::PackageNv;
 use deno_semver::package::PackageReq;
 use deno_semver::Version;
 use deno_semver::VersionReq;
+use deps::KeyPath;
 use jsonc_parser::cst::CstObject;
 use jsonc_parser::cst::CstObjectProp;
 use jsonc_parser::cst::CstRootNode;
@ -32,10 +33,13 @@ use crate::jsr::JsrFetchResolver;
 use crate::npm::NpmFetchResolver;

 mod cache_deps;
+pub(crate) mod deps;
+mod outdated;

 pub use cache_deps::cache_top_level_deps;
+pub use outdated::outdated;

-#[derive(Debug, Copy, Clone)]
+#[derive(Debug, Copy, Clone, Hash)]
 enum ConfigKind {
  DenoJson,
  PackageJson,
@ -86,6 +90,28 @@ impl ConfigUpdater {
    self.cst.to_string()
  }

+  fn get_property_for_mutation(
+    &mut self,
+    key_path: &KeyPath,
+  ) -> Option<CstObjectProp> {
+    let mut current_node = self.root_object.clone();
+
+    self.modified = true;
+
+    for (i, part) in key_path.parts.iter().enumerate() {
+      let s = part.as_str();
+      if i < key_path.parts.len().saturating_sub(1) {
+        let object = current_node.object_value(s)?;
+        current_node = object;
+      } else {
+        // last part
+        return current_node.get(s);
+      }
+    }
+
+    None
+  }
+
  fn add(&mut self, selected: SelectedPackage, dev: bool) {
    fn insert_index(object: &CstObject, searching_name: &str) -> usize {
      object
@ -679,7 +705,7 @@ enum AddRmPackageReqValue {
 }

 #[derive(Debug, PartialEq, Eq)]
-struct AddRmPackageReq {
+pub struct AddRmPackageReq {
  alias: String,
  value: AddRmPackageReqValue,
 }
@ -824,7 +850,7 @@ async fn npm_install_after_modification(
  flags: Arc<Flags>,
  // explicitly provided to prevent redownloading
  jsr_resolver: Option<Arc<crate::jsr::JsrFetchResolver>>,
-) -> Result<(), AnyError> {
+) -> Result<CliFactory, AnyError> {
  // clear the previously cached package.json from memory before reloading it
  node_resolver::PackageJsonThreadLocalCache::clear();

@ -842,7 +868,7 @@ async fn npm_install_after_modification(
    lockfile.write_if_changed()?;
  }

-  Ok(())
+  Ok(cli_factory)
 }

 #[cfg(test)]
--- a/cli/tools/registry/pm/cache_deps.rs
+++ b/cli/tools/registry/pm/cache_deps.rs
@ -8,7 +8,7 @@ use crate::graph_container::ModuleGraphUpdatePermit;
 use deno_core::error::AnyError;
 use deno_core::futures::stream::FuturesUnordered;
 use deno_core::futures::StreamExt;
-use deno_semver::package::PackageReq;
+use deno_semver::jsr::JsrPackageReqReference;

 pub async fn cache_top_level_deps(
  // todo(dsherret): don't pass the factory into this function. Instead use ctor deps
@ -56,15 +56,20 @@ pub async fn cache_top_level_deps(
      match specifier.scheme() {
        "jsr" => {
          let specifier_str = specifier.as_str();
-          let specifier_str =
-            specifier_str.strip_prefix("jsr:").unwrap_or(specifier_str);
-          if let Ok(req) = PackageReq::from_str(specifier_str) {
-            if !seen_reqs.insert(req.clone()) {
+          if let Ok(req) = JsrPackageReqReference::from_str(specifier_str) {
+            if let Some(sub_path) = req.sub_path() {
+              if sub_path.ends_with('/') {
+                continue;
+              }
+              roots.push(specifier.clone());
+              continue;
+            }
+            if !seen_reqs.insert(req.req().clone()) {
              continue;
            }
            let jsr_resolver = jsr_resolver.clone();
            info_futures.push(async move {
-              if let Some(nv) = jsr_resolver.req_to_nv(&req).await {
+              if let Some(nv) = jsr_resolver.req_to_nv(req.req()).await {
                if let Some(info) = jsr_resolver.package_version_info(&nv).await
                {
                  return Some((specifier.clone(), info));
--- a/cli/tools/registry/pm/deps.rs
+++ b/cli/tools/registry/pm/deps.rs
@ -0,0 +1,964 @@
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+
+use std::borrow::Cow;
+use std::collections::HashMap;
+use std::sync::atomic::AtomicBool;
+use std::sync::Arc;
+
+use deno_ast::ModuleSpecifier;
+use deno_config::deno_json::ConfigFile;
+use deno_config::deno_json::ConfigFileRc;
+use deno_config::workspace::Workspace;
+use deno_config::workspace::WorkspaceDirectory;
+use deno_core::anyhow::bail;
+use deno_core::error::AnyError;
+use deno_core::futures::future::try_join;
+use deno_core::futures::stream::FuturesOrdered;
+use deno_core::futures::stream::FuturesUnordered;
+use deno_core::futures::FutureExt;
+use deno_core::futures::StreamExt;
+use deno_core::serde_json;
+use deno_graph::FillFromLockfileOptions;
+use deno_package_json::PackageJsonDepValue;
+use deno_package_json::PackageJsonDepValueParseError;
+use deno_package_json::PackageJsonRc;
+use deno_runtime::deno_permissions::PermissionsContainer;
+use deno_semver::jsr::JsrPackageReqReference;
+use deno_semver::npm::NpmPackageReqReference;
+use deno_semver::package::PackageNv;
+use deno_semver::package::PackageReq;
+use deno_semver::package::PackageReqReference;
+use deno_semver::VersionReq;
+use import_map::ImportMap;
+use import_map::ImportMapWithDiagnostics;
+use import_map::SpecifierMapEntry;
+use indexmap::IndexMap;
+use tokio::sync::Semaphore;
+
+use crate::args::CliLockfile;
+use crate::graph_container::MainModuleGraphContainer;
+use crate::graph_container::ModuleGraphContainer;
+use crate::graph_container::ModuleGraphUpdatePermit;
+use crate::jsr::JsrFetchResolver;
+use crate::module_loader::ModuleLoadPreparer;
+use crate::npm::CliNpmResolver;
+use crate::npm::NpmFetchResolver;
+
+use super::ConfigUpdater;
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum ImportMapKind {
+  Inline,
+  Outline,
+}
+
+#[derive(Clone)]
+pub enum DepLocation {
+  DenoJson(ConfigFileRc, KeyPath, ImportMapKind),
+  PackageJson(PackageJsonRc, KeyPath),
+}
+
+impl DepLocation {
+  pub fn is_deno_json(&self) -> bool {
+    matches!(self, DepLocation::DenoJson(..))
+  }
+
+  pub fn file_path(&self) -> Cow<std::path::Path> {
+    match self {
+      DepLocation::DenoJson(arc, _, _) => {
+        Cow::Owned(arc.specifier.to_file_path().unwrap())
+      }
+      DepLocation::PackageJson(arc, _) => Cow::Borrowed(arc.path.as_ref()),
+    }
+  }
+  fn config_kind(&self) -> super::ConfigKind {
+    match self {
+      DepLocation::DenoJson(_, _, _) => super::ConfigKind::DenoJson,
+      DepLocation::PackageJson(_, _) => super::ConfigKind::PackageJson,
+    }
+  }
+}
+
+struct DebugAdapter<T>(T);
+
+impl<'a> std::fmt::Debug for DebugAdapter<&'a ConfigFileRc> {
+  fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+    f.debug_struct("ConfigFile")
+      .field("specifier", &self.0.specifier)
+      .finish()
+  }
+}
+impl<'a> std::fmt::Debug for DebugAdapter<&'a PackageJsonRc> {
+  fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+    f.debug_struct("PackageJson")
+      .field("path", &self.0.path)
+      .finish()
+  }
+}
+
+impl std::fmt::Debug for DepLocation {
+  fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+    match self {
+      DepLocation::DenoJson(arc, key_path, kind) => {
+        let mut debug = f.debug_tuple("DenoJson");
+        debug
+          .field(&DebugAdapter(arc))
+          .field(key_path)
+          .field(kind)
+          .finish()
+      }
+      DepLocation::PackageJson(arc, key_path) => {
+        let mut debug = f.debug_tuple("PackageJson");
+        debug.field(&DebugAdapter(arc)).field(key_path).finish()
+      }
+    }
+  }
+}
+
+#[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord)]
+pub enum DepKind {
+  Jsr,
+  Npm,
+}
+
+impl DepKind {
+  pub fn scheme(&self) -> &'static str {
+    match self {
+      DepKind::Npm => "npm",
+      DepKind::Jsr => "jsr",
+    }
+  }
+}
+
+#[derive(Clone, Debug)]
+pub enum KeyPart {
+  Imports,
+  Scopes,
+  Dependencies,
+  DevDependencies,
+  String(String),
+}
+
+impl From<String> for KeyPart {
+  fn from(value: String) -> Self {
+    KeyPart::String(value)
+  }
+}
+
+impl From<PackageJsonDepKind> for KeyPart {
+  fn from(value: PackageJsonDepKind) -> Self {
+    match value {
+      PackageJsonDepKind::Normal => Self::Dependencies,
+      PackageJsonDepKind::Dev => Self::DevDependencies,
+    }
+  }
+}
+
+impl KeyPart {
+  pub fn as_str(&self) -> &str {
+    match self {
+      KeyPart::Imports => "imports",
+      KeyPart::Scopes => "scopes",
+      KeyPart::Dependencies => "dependencies",
+      KeyPart::DevDependencies => "devDependencies",
+      KeyPart::String(s) => s,
+    }
+  }
+}
+
+#[derive(Clone, Debug)]
+pub struct KeyPath {
+  pub parts: Vec<KeyPart>,
+}
+
+impl KeyPath {
+  fn from_parts(parts: impl IntoIterator<Item = KeyPart>) -> Self {
+    Self {
+      parts: parts.into_iter().collect(),
+    }
+  }
+  fn last(&self) -> Option<&KeyPart> {
+    self.parts.last()
+  }
+  fn push(&mut self, part: KeyPart) {
+    self.parts.push(part)
+  }
+}
+
+#[derive(Clone, Debug)]
+pub struct Dep {
+  pub req: PackageReq,
+  pub kind: DepKind,
+  pub location: DepLocation,
+  #[allow(dead_code)]
+  pub id: DepId,
+  #[allow(dead_code)]
+  pub alias: Option<String>,
+}
+
+fn import_map_entries(
+  import_map: &ImportMap,
+) -> impl Iterator<Item = (KeyPath, SpecifierMapEntry<'_>)> {
+  import_map
+    .imports()
+    .entries()
+    .map(|entry| {
+      (
+        KeyPath::from_parts([
+          KeyPart::Imports,
+          KeyPart::String(entry.raw_key.into()),
+        ]),
+        entry,
+      )
+    })
+    .chain(import_map.scopes().flat_map(|scope| {
+      let path = KeyPath::from_parts([
+        KeyPart::Scopes,
+        scope.raw_key.to_string().into(),
+      ]);
+
+      scope.imports.entries().map(move |entry| {
+        let mut full_path = path.clone();
+        full_path.push(KeyPart::String(entry.raw_key.to_string()));
+        (full_path, entry)
+      })
+    }))
+}
+
+fn to_import_map_value_from_imports(
+  deno_json: &ConfigFile,
+) -> serde_json::Value {
+  let mut value = serde_json::Map::with_capacity(2);
+  if let Some(imports) = &deno_json.json.imports {
+    value.insert("imports".to_string(), imports.clone());
+  }
+  if let Some(scopes) = &deno_json.json.scopes {
+    value.insert("scopes".to_string(), scopes.clone());
+  }
+  serde_json::Value::Object(value)
+}
+
+fn deno_json_import_map(
+  deno_json: &ConfigFile,
+) -> Result<Option<(ImportMapWithDiagnostics, ImportMapKind)>, AnyError> {
+  let (value, kind) =
+    if deno_json.json.imports.is_some() || deno_json.json.scopes.is_some() {
+      (
+        to_import_map_value_from_imports(deno_json),
+        ImportMapKind::Inline,
+      )
+    } else {
+      match deno_json.to_import_map_path()? {
+        Some(path) => {
+          let text = std::fs::read_to_string(&path)?;
+          let value = serde_json::from_str(&text)?;
+          (value, ImportMapKind::Outline)
+        }
+        None => return Ok(None),
+      }
+    };
+
+  import_map::parse_from_value(deno_json.specifier.clone(), value)
+    .map_err(Into::into)
+    .map(|import_map| Some((import_map, kind)))
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+enum PackageJsonDepKind {
+  Normal,
+  Dev,
+}
+
+type PackageJsonDeps = IndexMap<
+  String,
+  Result<
+    (PackageJsonDepKind, PackageJsonDepValue),
+    PackageJsonDepValueParseError,
+  >,
+>;
+
+/// Resolve the package.json's dependencies.
+// TODO(nathanwhit): Remove once we update deno_package_json with dev deps split out
+fn resolve_local_package_json_deps(
+  package_json: &PackageJsonRc,
+) -> PackageJsonDeps {
+  /// Gets the name and raw version constraint for a registry info or
+  /// package.json dependency entry taking into account npm package aliases.
+  fn parse_dep_entry_name_and_raw_version<'a>(
+    key: &'a str,
+    value: &'a str,
+  ) -> (&'a str, &'a str) {
+    if let Some(package_and_version) = value.strip_prefix("npm:") {
+      if let Some((name, version)) = package_and_version.rsplit_once('@') {
+        // if empty, then the name was scoped and there's no version
+        if name.is_empty() {
+          (package_and_version, "*")
+        } else {
+          (name, version)
+        }
+      } else {
+        (package_and_version, "*")
+      }
+    } else {
+      (key, value)
+    }
+  }
+
+  fn parse_entry(
+    key: &str,
+    value: &str,
+  ) -> Result<PackageJsonDepValue, PackageJsonDepValueParseError> {
+    if let Some(workspace_key) = value.strip_prefix("workspace:") {
+      let version_req = VersionReq::parse_from_npm(workspace_key)?;
+      return Ok(PackageJsonDepValue::Workspace(version_req));
+    }
+    if value.starts_with("file:")
+      || value.starts_with("git:")
+      || value.starts_with("http:")
+      || value.starts_with("https:")
+    {
+      return Err(PackageJsonDepValueParseError::Unsupported {
+        scheme: value.split(':').next().unwrap().to_string(),
+      });
+    }
+    let (name, version_req) = parse_dep_entry_name_and_raw_version(key, value);
+    let result = VersionReq::parse_from_npm(version_req);
+    match result {
+      Ok(version_req) => Ok(PackageJsonDepValue::Req(PackageReq {
+        name: name.to_string(),
+        version_req,
+      })),
+      Err(err) => Err(PackageJsonDepValueParseError::VersionReq(err)),
+    }
+  }
+
+  fn insert_deps(
+    deps: Option<&IndexMap<String, String>>,
+    result: &mut PackageJsonDeps,
+    kind: PackageJsonDepKind,
+  ) {
+    if let Some(deps) = deps {
+      for (key, value) in deps {
+        result.entry(key.to_string()).or_insert_with(|| {
+          parse_entry(key, value).map(|entry| (kind, entry))
+        });
+      }
+    }
+  }
+
+  let deps = package_json.dependencies.as_ref();
+  let dev_deps = package_json.dev_dependencies.as_ref();
+  let mut result = IndexMap::new();
+
+  // favors the deps over dev_deps
+  insert_deps(deps, &mut result, PackageJsonDepKind::Normal);
+  insert_deps(dev_deps, &mut result, PackageJsonDepKind::Dev);
+
+  result
+}
+
+fn add_deps_from_deno_json(
+  deno_json: &Arc<ConfigFile>,
+  mut filter: impl DepFilter,
+  deps: &mut Vec<Dep>,
+) {
+  let (import_map, import_map_kind) = match deno_json_import_map(deno_json) {
+    Ok(Some((import_map, import_map_kind))) => (import_map, import_map_kind),
+    Ok(None) => return,
+    Err(e) => {
+      log::warn!("failed to parse imports from {}: {e}", &deno_json.specifier);
+      return;
+    }
+  };
+  for (key_path, entry) in import_map_entries(&import_map.import_map) {
+    let Some(value) = entry.value else { continue };
+    let kind = match value.scheme() {
+      "npm" => DepKind::Npm,
+      "jsr" => DepKind::Jsr,
+      _ => continue,
+    };
+    let req = match parse_req_reference(value.as_str(), kind) {
+      Ok(req) => req.req.clone(),
+      Err(err) => {
+        log::warn!("failed to parse package req \"{}\": {err}", value.as_str());
+        continue;
+      }
+    };
+    let alias: &str = key_path.last().unwrap().as_str().trim_end_matches('/');
+    let alias = (alias != req.name).then(|| alias.to_string());
+    if !filter.should_include(alias.as_deref(), &req, kind) {
+      continue;
+    }
+    let id = DepId(deps.len());
+    deps.push(Dep {
+      location: DepLocation::DenoJson(
+        deno_json.clone(),
+        key_path,
+        import_map_kind,
+      ),
+      kind,
+      req,
+      id,
+      alias,
+    });
+  }
+}
+
+fn add_deps_from_package_json(
+  package_json: &PackageJsonRc,
+  mut filter: impl DepFilter,
+  deps: &mut Vec<Dep>,
+) {
+  let package_json_deps = resolve_local_package_json_deps(package_json);
+  for (k, v) in package_json_deps {
+    let (package_dep_kind, v) = match v {
+      Ok((k, v)) => (k, v),
+      Err(e) => {
+        log::warn!("bad package json dep value: {e}");
+        continue;
+      }
+    };
+    match v {
+      deno_package_json::PackageJsonDepValue::Req(req) => {
+        let alias = k.as_str();
+        let alias = (alias != req.name).then(|| alias.to_string());
+        if !filter.should_include(alias.as_deref(), &req, DepKind::Npm) {
+          continue;
+        }
+        let id = DepId(deps.len());
+        deps.push(Dep {
+          id,
+          kind: DepKind::Npm,
+          location: DepLocation::PackageJson(
+            package_json.clone(),
+            KeyPath::from_parts([package_dep_kind.into(), k.into()]),
+          ),
+          req,
+          alias,
+        })
+      }
+      deno_package_json::PackageJsonDepValue::Workspace(_) => continue,
+    }
+  }
+}
+
+fn deps_from_workspace(
+  workspace: &Arc<Workspace>,
+  dep_filter: impl DepFilter,
+) -> Result<Vec<Dep>, AnyError> {
+  let mut deps = Vec::with_capacity(256);
+  for deno_json in workspace.deno_jsons() {
+    add_deps_from_deno_json(deno_json, dep_filter, &mut deps);
+  }
+  for package_json in workspace.package_jsons() {
+    add_deps_from_package_json(package_json, dep_filter, &mut deps);
+  }
+
+  Ok(deps)
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
+pub struct DepId(usize);
+
+#[derive(Debug, Clone)]
+pub enum Change {
+  Update(DepId, VersionReq),
+}
+
+pub trait DepFilter: Copy {
+  fn should_include(
+    &mut self,
+    alias: Option<&str>,
+    package_req: &PackageReq,
+    dep_kind: DepKind,
+  ) -> bool;
+}
+
+impl<T> DepFilter for T
+where
+  T: FnMut(Option<&str>, &PackageReq, DepKind) -> bool + Copy,
+{
+  fn should_include<'a>(
+    &mut self,
+    alias: Option<&'a str>,
+    package_req: &'a PackageReq,
+    dep_kind: DepKind,
+  ) -> bool {
+    (*self)(alias, package_req, dep_kind)
+  }
+}
+
+#[derive(Clone, Debug)]
+pub struct PackageLatestVersion {
+  pub semver_compatible: Option<PackageNv>,
+  pub latest: Option<PackageNv>,
+}
+
+pub struct DepManager {
+  deps: Vec<Dep>,
+  resolved_versions: Vec<Option<PackageNv>>,
+  latest_versions: Vec<PackageLatestVersion>,
+
+  pending_changes: Vec<Change>,
+
+  dependencies_resolved: AtomicBool,
+  module_load_preparer: Arc<ModuleLoadPreparer>,
+  // TODO(nathanwhit): probably shouldn't be pub
+  pub(crate) jsr_fetch_resolver: Arc<JsrFetchResolver>,
+  pub(crate) npm_fetch_resolver: Arc<NpmFetchResolver>,
+  npm_resolver: Arc<dyn CliNpmResolver>,
+  permissions_container: PermissionsContainer,
+  main_module_graph_container: Arc<MainModuleGraphContainer>,
+  lockfile: Option<Arc<CliLockfile>>,
+}
+
+pub struct DepManagerArgs {
+  pub module_load_preparer: Arc<ModuleLoadPreparer>,
+  pub jsr_fetch_resolver: Arc<JsrFetchResolver>,
+  pub npm_fetch_resolver: Arc<NpmFetchResolver>,
+  pub npm_resolver: Arc<dyn CliNpmResolver>,
+  pub permissions_container: PermissionsContainer,
+  pub main_module_graph_container: Arc<MainModuleGraphContainer>,
+  pub lockfile: Option<Arc<CliLockfile>>,
+}
+
+impl DepManager {
+  pub fn reloaded_after_modification(self, args: DepManagerArgs) -> Self {
+    let mut new = Self::with_deps_args(self.deps, args);
+    new.latest_versions = self.latest_versions;
+    new
+  }
+  fn with_deps_args(deps: Vec<Dep>, args: DepManagerArgs) -> Self {
+    let DepManagerArgs {
+      module_load_preparer,
+      jsr_fetch_resolver,
+      npm_fetch_resolver,
+      npm_resolver,
+      permissions_container,
+      main_module_graph_container,
+      lockfile,
+    } = args;
+    Self {
+      deps,
+      resolved_versions: Vec::new(),
+      latest_versions: Vec::new(),
+      jsr_fetch_resolver,
+      dependencies_resolved: AtomicBool::new(false),
+      module_load_preparer,
+      npm_fetch_resolver,
+      npm_resolver,
+      permissions_container,
+      main_module_graph_container,
+      lockfile,
+      pending_changes: Vec::new(),
+    }
+  }
+  pub fn from_workspace_dir(
+    workspace_dir: &Arc<WorkspaceDirectory>,
+    dep_filter: impl DepFilter,
+    args: DepManagerArgs,
+  ) -> Result<Self, AnyError> {
+    let mut deps = Vec::with_capacity(256);
+    if let Some(deno_json) = workspace_dir.maybe_deno_json() {
+      if deno_json.specifier.scheme() != "file" {
+        bail!("remote deno.json files are not supported");
+      }
+      let path = deno_json.specifier.to_file_path().unwrap();
+      if path.parent().unwrap() == workspace_dir.dir_path() {
+        add_deps_from_deno_json(deno_json, dep_filter, &mut deps);
+      }
+    }
+    if let Some(package_json) = workspace_dir.maybe_pkg_json() {
+      add_deps_from_package_json(package_json, dep_filter, &mut deps);
+    }
+
+    Ok(Self::with_deps_args(deps, args))
+  }
+  pub fn from_workspace(
+    workspace: &Arc<Workspace>,
+    dep_filter: impl DepFilter,
+    args: DepManagerArgs,
+  ) -> Result<Self, AnyError> {
+    let deps = deps_from_workspace(workspace, dep_filter)?;
+    Ok(Self::with_deps_args(deps, args))
+  }
+
+  async fn run_dependency_resolution(&self) -> Result<(), AnyError> {
+    if self
+      .dependencies_resolved
+      .load(std::sync::atomic::Ordering::Relaxed)
+    {
+      return Ok(());
+    }
+
+    let mut graph_permit = self
+      .main_module_graph_container
+      .acquire_update_permit()
+      .await;
+    let graph = graph_permit.graph_mut();
+    // populate the information from the lockfile
+    if let Some(lockfile) = &self.lockfile {
+      let lockfile = lockfile.lock();
+      graph.fill_from_lockfile(FillFromLockfileOptions {
+        redirects: lockfile
+          .content
+          .redirects
+          .iter()
+          .map(|(from, to)| (from.as_str(), to.as_str())),
+        package_specifiers: lockfile
+          .content
+          .packages
+          .specifiers
+          .iter()
+          .map(|(dep, id)| (dep, id.as_str())),
+      });
+    }
+
+    let npm_resolver = self.npm_resolver.as_managed().unwrap();
+    if self.deps.iter().all(|dep| match dep.kind {
+      DepKind::Npm => {
+        npm_resolver.resolve_pkg_id_from_pkg_req(&dep.req).is_ok()
+      }
+      DepKind::Jsr => graph.packages.mappings().contains_key(&dep.req),
+    }) {
+      self
+        .dependencies_resolved
+        .store(true, std::sync::atomic::Ordering::Relaxed);
+      graph_permit.commit();
+      return Ok(());
+    }
+
+    npm_resolver.ensure_top_level_package_json_install().await?;
+    let mut roots = Vec::new();
+    let mut info_futures = FuturesUnordered::new();
+    for dep in &self.deps {
+      if dep.location.is_deno_json() {
+        match dep.kind {
+          DepKind::Npm => roots.push(
+            ModuleSpecifier::parse(&format!("npm:/{}/", dep.req)).unwrap(),
+          ),
+          DepKind::Jsr => info_futures.push(async {
+            if let Some(nv) = self.jsr_fetch_resolver.req_to_nv(&dep.req).await
+            {
+              if let Some(info) =
+                self.jsr_fetch_resolver.package_version_info(&nv).await
+              {
+                let specifier =
+                  ModuleSpecifier::parse(&format!("jsr:/{}/", dep.req))
+                    .unwrap();
+                return Some((specifier, info));
+              }
+            }
+            None
+          }),
+        }
+      }
+    }
+
+    while let Some(info_future) = info_futures.next().await {
+      if let Some((specifier, info)) = info_future {
+        let exports = info.exports();
+        for (k, _) in exports {
+          if let Ok(spec) = specifier.join(k) {
+            roots.push(spec);
+          }
+        }
+      }
+    }
+
+    self
+      .module_load_preparer
+      .prepare_module_load(
+        graph,
+        &roots,
+        false,
+        deno_config::deno_json::TsTypeLib::DenoWindow,
+        self.permissions_container.clone(),
+        None,
+      )
+      .await?;
+
+    graph_permit.commit();
+
+    Ok(())
+  }
+
+  pub fn resolved_version(&self, id: DepId) -> Option<&PackageNv> {
+    self.resolved_versions[id.0].as_ref()
+  }
+
+  pub async fn resolve_current_versions(&mut self) -> Result<(), AnyError> {
+    self.run_dependency_resolution().await?;
+
+    let graph = self.main_module_graph_container.graph();
+
+    let mut resolved = Vec::with_capacity(self.deps.len());
+    let snapshot = self.npm_resolver.as_managed().unwrap().snapshot();
+    let resolved_npm = snapshot.package_reqs();
+    let resolved_jsr = graph.packages.mappings();
+    for dep in &self.deps {
+      match dep.kind {
+        DepKind::Npm => {
+          let resolved_version = resolved_npm.get(&dep.req).cloned();
+          resolved.push(resolved_version);
+        }
+        DepKind::Jsr => {
+          let resolved_version = resolved_jsr.get(&dep.req).cloned();
+          resolved.push(resolved_version)
+        }
+      }
+    }
+
+    self.resolved_versions = resolved;
+
+    Ok(())
+  }
+
+  async fn load_latest_versions(
+    &self,
+  ) -> Result<Vec<PackageLatestVersion>, AnyError> {
+    if self.latest_versions.len() == self.deps.len() {
+      return Ok(self.latest_versions.clone());
+    }
+    let latest_tag_req = deno_semver::VersionReq::from_raw_text_and_inner(
+      "latest".into(),
+      deno_semver::RangeSetOrTag::Tag("latest".into()),
+    );
+    let mut latest_versions = Vec::with_capacity(self.deps.len());
+
+    let npm_sema = Semaphore::new(32);
+    let jsr_sema = Semaphore::new(32);
+    let mut futs = FuturesOrdered::new();
+
+    for dep in &self.deps {
+      match dep.kind {
+        DepKind::Npm => futs.push_back(
+          async {
+            let semver_req = &dep.req;
+            let latest_req = PackageReq {
+              name: dep.req.name.clone(),
+              version_req: latest_tag_req.clone(),
+            };
+            let _permit = npm_sema.acquire().await;
+            let semver_compatible =
+              self.npm_fetch_resolver.req_to_nv(semver_req).await;
+            let latest = self.npm_fetch_resolver.req_to_nv(&latest_req).await;
+            PackageLatestVersion {
+              latest,
+              semver_compatible,
+            }
+          }
+          .boxed_local(),
+        ),
+        DepKind::Jsr => futs.push_back(
+          async {
+            let semver_req = &dep.req;
+            let latest_req = PackageReq {
+              name: dep.req.name.clone(),
+              version_req: deno_semver::WILDCARD_VERSION_REQ.clone(),
+            };
+            let _permit = jsr_sema.acquire().await;
+            let semver_compatible =
+              self.jsr_fetch_resolver.req_to_nv(semver_req).await;
+            let latest = self.jsr_fetch_resolver.req_to_nv(&latest_req).await;
+            PackageLatestVersion {
+              latest,
+              semver_compatible,
+            }
+          }
+          .boxed_local(),
+        ),
+      }
+    }
+    while let Some(nv) = futs.next().await {
+      latest_versions.push(nv);
+    }
+
+    Ok(latest_versions)
+  }
+
+  pub async fn resolve_versions(&mut self) -> Result<(), AnyError> {
+    let (_, latest_versions) = try_join(
+      self.run_dependency_resolution(),
+      self.load_latest_versions(),
+    )
+    .await?;
+
+    self.latest_versions = latest_versions;
+
+    self.resolve_current_versions().await?;
+
+    Ok(())
+  }
+
+  pub fn deps_with_resolved_latest_versions(
+    &self,
+  ) -> impl IntoIterator<Item = (DepId, Option<PackageNv>, PackageLatestVersion)> + '_
+  {
+    self
+      .resolved_versions
+      .iter()
+      .zip(self.latest_versions.iter())
+      .enumerate()
+      .map(|(i, (resolved, latest))| {
+        (DepId(i), resolved.clone(), latest.clone())
+      })
+  }
+
+  pub fn get_dep(&self, id: DepId) -> &Dep {
+    &self.deps[id.0]
+  }
+
+  pub fn update_dep(&mut self, dep_id: DepId, new_version_req: VersionReq) {
+    self
+      .pending_changes
+      .push(Change::Update(dep_id, new_version_req));
+  }
+
+  pub fn commit_changes(&mut self) -> Result<(), AnyError> {
+    let changes = std::mem::take(&mut self.pending_changes);
+    let mut config_updaters = HashMap::new();
+    for change in changes {
+      match change {
+        Change::Update(dep_id, version_req) => {
+          // TODO: move most of this to ConfigUpdater
+          let dep = &mut self.deps[dep_id.0];
+          dep.req.version_req = version_req.clone();
+          match &dep.location {
+            DepLocation::DenoJson(arc, key_path, import_map_kind) => {
+              if matches!(import_map_kind, ImportMapKind::Outline) {
+                // not supported
+                continue;
+              }
+              let updater =
+                get_or_create_updater(&mut config_updaters, &dep.location)?;
+
+              let Some(property) = updater.get_property_for_mutation(key_path)
+              else {
+                log::warn!(
+                  "failed to find property at path {key_path:?} for file {}",
+                  arc.specifier
+                );
+                continue;
+              };
+              let Some(string_value) = cst_string_literal(&property) else {
+                continue;
+              };
+              let mut req_reference = match dep.kind {
+                DepKind::Npm => NpmPackageReqReference::from_str(&string_value)
+                  .unwrap()
+                  .into_inner(),
+                DepKind::Jsr => JsrPackageReqReference::from_str(&string_value)
+                  .unwrap()
+                  .into_inner(),
+              };
+              req_reference.req.version_req = version_req;
+              let mut new_value =
+                format!("{}:{}", dep.kind.scheme(), req_reference);
+              if string_value.ends_with('/') && !new_value.ends_with('/') {
+                // the display impl for PackageReqReference maps `/` to the root
+                // subpath, but for the import map the trailing `/` is significant
+                new_value.push('/');
+              }
+              if string_value
+                .trim_start_matches(format!("{}:", dep.kind.scheme()).as_str())
+                .starts_with('/')
+              {
+                // this is gross
+                new_value = new_value.replace(':', ":/");
+              }
+              property
+                .set_value(jsonc_parser::cst::CstInputValue::String(new_value));
+            }
+            DepLocation::PackageJson(arc, key_path) => {
+              let updater =
+                get_or_create_updater(&mut config_updaters, &dep.location)?;
+              let Some(property) = updater.get_property_for_mutation(key_path)
+              else {
+                log::warn!(
+                  "failed to find property at path {key_path:?} for file {}",
+                  arc.path.display()
+                );
+                continue;
+              };
+              let Some(string_value) = cst_string_literal(&property) else {
+                continue;
+              };
+              let new_value = if string_value.starts_with("npm:") {
+                // aliased
+                let rest = string_value.trim_start_matches("npm:");
+                let mut parts = rest.split('@');
+                let first = parts.next().unwrap();
+                if first.is_empty() {
+                  let scope_and_name = parts.next().unwrap();
+                  format!("npm:@{scope_and_name}@{version_req}")
+                } else {
+                  format!("npm:{first}@{version_req}")
+                }
+              } else if string_value.contains(":") {
+                bail!("Unexpected package json dependency string: \"{string_value}\" in {}", arc.path.display());
+              } else {
+                version_req.to_string()
+              };
+              property
+                .set_value(jsonc_parser::cst::CstInputValue::String(new_value));
+            }
+          }
+        }
+      }
+    }
+
+    for (_, updater) in config_updaters {
+      updater.commit()?;
+    }
+
+    Ok(())
+  }
+}
+
+fn get_or_create_updater<'a>(
+  config_updaters: &'a mut HashMap<std::path::PathBuf, ConfigUpdater>,
+  location: &DepLocation,
+) -> Result<&'a mut ConfigUpdater, AnyError> {
+  match config_updaters.entry(location.file_path().into_owned()) {
+    std::collections::hash_map::Entry::Occupied(occupied_entry) => {
+      Ok(occupied_entry.into_mut())
+    }
+    std::collections::hash_map::Entry::Vacant(vacant_entry) => {
+      let updater = ConfigUpdater::new(
+        location.config_kind(),
+        location.file_path().into_owned(),
+      )?;
+      Ok(vacant_entry.insert(updater))
+    }
+  }
+}
+
+fn cst_string_literal(
+  property: &jsonc_parser::cst::CstObjectProp,
+) -> Option<String> {
+  // TODO(nathanwhit): ensure this unwrap is safe
+  let value = property.value().unwrap();
+  let Some(string) = value.as_string_lit() else {
+    log::warn!("malformed entry");
+    return None;
+  };
+  let Ok(string_value) = string.decoded_value() else {
+    log::warn!("malformed string: {string:?}");
+    return None;
+  };
+  Some(string_value)
+}
+
+fn parse_req_reference(
+  input: &str,
+  kind: DepKind,
+) -> Result<
+  PackageReqReference,
+  deno_semver::package::PackageReqReferenceParseError,
+> {
+  Ok(match kind {
+    DepKind::Npm => NpmPackageReqReference::from_str(input)?.into_inner(),
+    DepKind::Jsr => JsrPackageReqReference::from_str(input)?.into_inner(),
+  })
+}
--- a/cli/tools/registry/pm/outdated.rs
+++ b/cli/tools/registry/pm/outdated.rs
@ -0,0 +1,661 @@
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+
+use std::collections::HashSet;
+use std::sync::Arc;
+
+use deno_core::error::AnyError;
+use deno_semver::package::PackageNv;
+use deno_semver::package::PackageReq;
+use deno_semver::VersionReq;
+use deno_terminal::colors;
+
+use crate::args::CacheSetting;
+use crate::args::CliOptions;
+use crate::args::Flags;
+use crate::args::OutdatedFlags;
+use crate::factory::CliFactory;
+use crate::file_fetcher::FileFetcher;
+use crate::jsr::JsrFetchResolver;
+use crate::npm::NpmFetchResolver;
+use crate::tools::registry::pm::deps::DepKind;
+
+use super::deps::Dep;
+use super::deps::DepManager;
+use super::deps::DepManagerArgs;
+use super::deps::PackageLatestVersion;
+
+#[derive(Debug, PartialEq, Eq, PartialOrd, Ord)]
+struct OutdatedPackage {
+  kind: DepKind,
+  latest: String,
+  semver_compatible: String,
+  current: String,
+  name: String,
+}
+
+#[allow(clippy::print_stdout)]
+fn print_outdated_table(packages: &[OutdatedPackage]) {
+  const HEADINGS: &[&str] = &["Package", "Current", "Update", "Latest"];
+
+  let mut longest_package = 0;
+  let mut longest_current = 0;
+  let mut longest_update = 0;
+  let mut longest_latest = 0;
+
+  for package in packages {
+    let name_len = package.kind.scheme().len() + 1 + package.name.len();
+    longest_package = longest_package.max(name_len);
+    longest_current = longest_current.max(package.current.len());
+    longest_update = longest_update.max(package.semver_compatible.len());
+    longest_latest = longest_latest.max(package.latest.len());
+  }
+
+  let package_column_width = longest_package.max(HEADINGS[0].len()) + 2;
+  let current_column_width = longest_current.max(HEADINGS[1].len()) + 2;
+  let update_column_width = longest_update.max(HEADINGS[2].len()) + 2;
+  let latest_column_width = longest_latest.max(HEADINGS[3].len()) + 2;
+
+  let package_fill = "─".repeat(package_column_width);
+  let current_fill = "─".repeat(current_column_width);
+  let update_fill = "─".repeat(update_column_width);
+  let latest_fill = "─".repeat(latest_column_width);
+
+  println!("┌{package_fill}┬{current_fill}┬{update_fill}┬{latest_fill}┐");
+  println!(
+    "│ {}{} │ {}{} │ {}{} │ {}{} │",
+    colors::intense_blue(HEADINGS[0]),
+    " ".repeat(package_column_width - 2 - HEADINGS[0].len()),
+    colors::intense_blue(HEADINGS[1]),
+    " ".repeat(current_column_width - 2 - HEADINGS[1].len()),
+    colors::intense_blue(HEADINGS[2]),
+    " ".repeat(update_column_width - 2 - HEADINGS[2].len()),
+    colors::intense_blue(HEADINGS[3]),
+    " ".repeat(latest_column_width - 2 - HEADINGS[3].len())
+  );
+  for package in packages {
+    println!("├{package_fill}┼{current_fill}┼{update_fill}┼{latest_fill}┤",);
+
+    print!(
+      "│ {:<package_column_width$} ",
+      format!("{}:{}", package.kind.scheme(), package.name),
+      package_column_width = package_column_width - 2
+    );
+    print!(
+      "│ {:<current_column_width$} ",
+      package.current,
+      current_column_width = current_column_width - 2
+    );
+    print!(
+      "│ {:<update_column_width$} ",
+      package.semver_compatible,
+      update_column_width = update_column_width - 2
+    );
+    println!(
+      "│ {:<latest_column_width$} │",
+      package.latest,
+      latest_column_width = latest_column_width - 2
+    );
+  }
+
+  println!("└{package_fill}┴{current_fill}┴{update_fill}┴{latest_fill}┘",);
+}
+
+fn print_outdated(
+  deps: &mut DepManager,
+  compatible: bool,
+) -> Result<(), AnyError> {
+  let mut outdated = Vec::new();
+  let mut seen = std::collections::BTreeSet::new();
+  for (dep_id, resolved, latest_versions) in
+    deps.deps_with_resolved_latest_versions()
+  {
+    let dep = deps.get_dep(dep_id);
+
+    let Some(resolved) = resolved else { continue };
+
+    let latest = {
+      let preferred = if compatible {
+        &latest_versions.semver_compatible
+      } else {
+        &latest_versions.latest
+      };
+      if let Some(v) = preferred {
+        v
+      } else {
+        continue;
+      }
+    };
+
+    if latest > &resolved
+      && seen.insert((dep.kind, dep.req.name.clone(), resolved.version.clone()))
+    {
+      outdated.push(OutdatedPackage {
+        kind: dep.kind,
+        name: dep.req.name.clone(),
+        current: resolved.version.to_string(),
+        latest: latest_versions
+          .latest
+          .map(|l| l.version.to_string())
+          .unwrap_or_default(),
+        semver_compatible: latest_versions
+          .semver_compatible
+          .map(|l| l.version.to_string())
+          .unwrap_or_default(),
+      })
+    }
+  }
+
+  if !outdated.is_empty() {
+    outdated.sort();
+    print_outdated_table(&outdated);
+  }
+
+  Ok(())
+}
+
+pub async fn outdated(
+  flags: Arc<Flags>,
+  update_flags: OutdatedFlags,
+) -> Result<(), AnyError> {
+  let factory = CliFactory::from_flags(flags.clone());
+  let cli_options = factory.cli_options()?;
+  let workspace = cli_options.workspace();
+  let http_client = factory.http_client_provider();
+  let deps_http_cache = factory.global_http_cache()?;
+  let mut file_fetcher = FileFetcher::new(
+    deps_http_cache.clone(),
+    CacheSetting::RespectHeaders,
+    true,
+    http_client.clone(),
+    Default::default(),
+    None,
+  );
+  file_fetcher.set_download_log_level(log::Level::Trace);
+  let file_fetcher = Arc::new(file_fetcher);
+  let npm_fetch_resolver = Arc::new(NpmFetchResolver::new(
+    file_fetcher.clone(),
+    cli_options.npmrc().clone(),
+  ));
+  let jsr_fetch_resolver =
+    Arc::new(JsrFetchResolver::new(file_fetcher.clone()));
+
+  let args = dep_manager_args(
+    &factory,
+    cli_options,
+    npm_fetch_resolver.clone(),
+    jsr_fetch_resolver.clone(),
+  )
+  .await?;
+
+  let filter_set = filter::FilterSet::from_filter_strings(
+    update_flags.filters.iter().map(|s| s.as_str()),
+  )?;
+
+  let filter_fn = |alias: Option<&str>, req: &PackageReq, _: DepKind| {
+    if filter_set.is_empty() {
+      return true;
+    }
+    let name = alias.unwrap_or(&req.name);
+    filter_set.matches(name)
+  };
+  let mut deps = if update_flags.recursive {
+    super::deps::DepManager::from_workspace(workspace, filter_fn, args)?
+  } else {
+    super::deps::DepManager::from_workspace_dir(
+      &cli_options.start_dir,
+      filter_fn,
+      args,
+    )?
+  };
+
+  deps.resolve_versions().await?;
+
+  match update_flags.kind {
+    crate::args::OutdatedKind::Update { latest } => {
+      update(deps, latest, &filter_set, flags).await?;
+    }
+    crate::args::OutdatedKind::PrintOutdated { compatible } => {
+      print_outdated(&mut deps, compatible)?;
+    }
+  }
+
+  Ok(())
+}
+
+fn choose_new_version_req(
+  dep: &Dep,
+  resolved: Option<&PackageNv>,
+  latest_versions: &PackageLatestVersion,
+  update_to_latest: bool,
+  filter_set: &filter::FilterSet,
+) -> Option<VersionReq> {
+  let explicit_version_req = filter_set
+    .matching_filter(dep.alias.as_deref().unwrap_or(&dep.req.name))
+    .version_spec()
+    .cloned();
+
+  if let Some(version_req) = explicit_version_req {
+    if let Some(resolved) = resolved {
+      // todo(nathanwhit): handle tag
+      if version_req.tag().is_none() && version_req.matches(&resolved.version) {
+        return None;
+      }
+    }
+    Some(version_req)
+  } else {
+    let preferred = if update_to_latest {
+      latest_versions.latest.as_ref()?
+    } else {
+      latest_versions.semver_compatible.as_ref()?
+    };
+    if preferred.version <= resolved?.version {
+      return None;
+    }
+    Some(
+      VersionReq::parse_from_specifier(
+        format!("^{}", preferred.version).as_str(),
+      )
+      .unwrap(),
+    )
+  }
+}
+
+async fn update(
+  mut deps: DepManager,
+  update_to_latest: bool,
+  filter_set: &filter::FilterSet,
+  flags: Arc<Flags>,
+) -> Result<(), AnyError> {
+  let mut updated = Vec::new();
+
+  for (dep_id, resolved, latest_versions) in deps
+    .deps_with_resolved_latest_versions()
+    .into_iter()
+    .collect::<Vec<_>>()
+  {
+    let dep = deps.get_dep(dep_id);
+    let new_version_req = choose_new_version_req(
+      dep,
+      resolved.as_ref(),
+      &latest_versions,
+      update_to_latest,
+      filter_set,
+    );
+    let Some(new_version_req) = new_version_req else {
+      continue;
+    };
+
+    updated.push((
+      dep_id,
+      format!("{}:{}", dep.kind.scheme(), dep.req.name),
+      deps.resolved_version(dep.id).cloned(),
+      new_version_req.clone(),
+    ));
+
+    deps.update_dep(dep_id, new_version_req);
+  }
+
+  deps.commit_changes()?;
+
+  if !updated.is_empty() {
+    let factory = super::npm_install_after_modification(
+      flags.clone(),
+      Some(deps.jsr_fetch_resolver.clone()),
+    )
+    .await?;
+
+    let mut updated_to_versions = HashSet::new();
+    let cli_options = factory.cli_options()?;
+    let args = dep_manager_args(
+      &factory,
+      cli_options,
+      deps.npm_fetch_resolver.clone(),
+      deps.jsr_fetch_resolver.clone(),
+    )
+    .await?;
+
+    let mut deps = deps.reloaded_after_modification(args);
+    deps.resolve_current_versions().await?;
+    for (dep_id, package_name, maybe_current_version, new_version_req) in
+      updated
+    {
+      if let Some(nv) = deps.resolved_version(dep_id) {
+        updated_to_versions.insert((
+          package_name,
+          maybe_current_version,
+          nv.version.clone(),
+        ));
+      } else {
+        log::warn!(
+          "Failed to resolve version for new version requirement: {} -> {}",
+          package_name,
+          new_version_req
+        );
+      }
+    }
+
+    log::info!(
+      "Updated {} dependenc{}:",
+      updated_to_versions.len(),
+      if updated_to_versions.len() == 1 {
+        "y"
+      } else {
+        "ies"
+      }
+    );
+    let mut updated_to_versions =
+      updated_to_versions.into_iter().collect::<Vec<_>>();
+    updated_to_versions.sort_by(|(k, _, _), (k2, _, _)| k.cmp(k2));
+    let max_name = updated_to_versions
+      .iter()
+      .map(|(name, _, _)| name.len())
+      .max()
+      .unwrap_or(0);
+    let max_old = updated_to_versions
+      .iter()
+      .map(|(_, maybe_current, _)| {
+        maybe_current
+          .as_ref()
+          .map(|v| v.version.to_string().len())
+          .unwrap_or(0)
+      })
+      .max()
+      .unwrap_or(0);
+    let max_new = updated_to_versions
+      .iter()
+      .map(|(_, _, new_version)| new_version.to_string().len())
+      .max()
+      .unwrap_or(0);
+
+    for (package_name, maybe_current_version, new_version) in
+      updated_to_versions
+    {
+      let current_version = if let Some(current_version) = maybe_current_version
+      {
+        current_version.version.to_string()
+      } else {
+        "".to_string()
+      };
+
+      log::info!(
+        " - {}{} {}{} -> {}{}",
+        format!(
+          "{}{}",
+          colors::gray(package_name[0..4].to_string()),
+          package_name[4..].to_string()
+        ),
+        " ".repeat(max_name - package_name.len()),
+        " ".repeat(max_old - current_version.len()),
+        colors::gray(&current_version),
+        " ".repeat(max_new - new_version.to_string().len()),
+        colors::green(&new_version),
+      );
+    }
+  } else {
+    log::info!(
+      "All {}dependencies are up to date.",
+      if filter_set.is_empty() {
+        ""
+      } else {
+        "matching "
+      }
+    );
+  }
+
+  Ok(())
+}
+
+async fn dep_manager_args(
+  factory: &CliFactory,
+  cli_options: &CliOptions,
+  npm_fetch_resolver: Arc<NpmFetchResolver>,
+  jsr_fetch_resolver: Arc<JsrFetchResolver>,
+) -> Result<DepManagerArgs, AnyError> {
+  Ok(DepManagerArgs {
+    module_load_preparer: factory.module_load_preparer().await?.clone(),
+    jsr_fetch_resolver,
+    npm_fetch_resolver,
+    npm_resolver: factory.npm_resolver().await?.clone(),
+    permissions_container: factory.root_permissions_container()?.clone(),
+    main_module_graph_container: factory
+      .main_module_graph_container()
+      .await?
+      .clone(),
+    lockfile: cli_options.maybe_lockfile().cloned(),
+  })
+}
+
+mod filter {
+  use deno_core::anyhow::anyhow;
+  use deno_core::anyhow::Context;
+  use deno_core::error::AnyError;
+  use deno_semver::VersionReq;
+
+  enum FilterKind {
+    Exclude,
+    Include,
+  }
+  pub struct Filter {
+    kind: FilterKind,
+    regex: regex::Regex,
+    version_spec: Option<VersionReq>,
+  }
+
+  fn pattern_to_regex(pattern: &str) -> Result<regex::Regex, AnyError> {
+    let escaped = regex::escape(pattern);
+    let unescaped_star = escaped.replace(r"\*", ".*");
+    Ok(regex::Regex::new(&format!("^{}$", unescaped_star))?)
+  }
+
+  impl Filter {
+    pub fn version_spec(&self) -> Option<&VersionReq> {
+      self.version_spec.as_ref()
+    }
+    pub fn from_str(input: &str) -> Result<Self, AnyError> {
+      let (kind, first_idx) = if input.starts_with('!') {
+        (FilterKind::Exclude, 1)
+      } else {
+        (FilterKind::Include, 0)
+      };
+      let s = &input[first_idx..];
+      let (pattern, version_spec) =
+        if let Some(scope_name) = s.strip_prefix('@') {
+          if let Some(idx) = scope_name.find('@') {
+            let (pattern, version_spec) = s.split_at(idx + 1);
+            (
+              pattern,
+              Some(
+                VersionReq::parse_from_specifier(
+                  version_spec.trim_start_matches('@'),
+                )
+                .with_context(|| format!("Invalid filter \"{input}\""))?,
+              ),
+            )
+          } else {
+            (s, None)
+          }
+        } else {
+          let mut parts = s.split('@');
+          let Some(pattern) = parts.next() else {
+            return Err(anyhow!("Invalid filter \"{input}\""));
+          };
+          (
+            pattern,
+            parts
+              .next()
+              .map(VersionReq::parse_from_specifier)
+              .transpose()
+              .with_context(|| format!("Invalid filter \"{input}\""))?,
+          )
+        };
+
+      Ok(Filter {
+        kind,
+        regex: pattern_to_regex(pattern)
+          .with_context(|| format!("Invalid filter \"{input}\""))?,
+        version_spec,
+      })
+    }
+
+    pub fn matches(&self, name: &str) -> bool {
+      self.regex.is_match(name)
+    }
+  }
+
+  pub struct FilterSet {
+    filters: Vec<Filter>,
+    has_exclude: bool,
+    has_include: bool,
+  }
+  impl FilterSet {
+    pub fn from_filter_strings<'a>(
+      filter_strings: impl IntoIterator<Item = &'a str>,
+    ) -> Result<Self, AnyError> {
+      let filters = filter_strings
+        .into_iter()
+        .map(Filter::from_str)
+        .collect::<Result<Vec<_>, _>>()?;
+      let has_exclude = filters
+        .iter()
+        .any(|f| matches!(f.kind, FilterKind::Exclude));
+      let has_include = filters
+        .iter()
+        .any(|f| matches!(f.kind, FilterKind::Include));
+      Ok(FilterSet {
+        filters,
+        has_exclude,
+        has_include,
+      })
+    }
+
+    pub fn is_empty(&self) -> bool {
+      self.filters.is_empty()
+    }
+
+    pub fn matches(&self, name: &str) -> bool {
+      self.matching_filter(name).is_included()
+    }
+
+    pub fn matching_filter(&self, name: &str) -> MatchResult<'_> {
+      if self.filters.is_empty() {
+        return MatchResult::Included;
+      }
+      let mut matched = None;
+      for filter in &self.filters {
+        match filter.kind {
+          FilterKind::Include => {
+            if matched.is_none() && filter.matches(name) {
+              matched = Some(filter);
+            }
+          }
+          FilterKind::Exclude => {
+            if filter.matches(name) {
+              return MatchResult::Excluded;
+            }
+          }
+        }
+      }
+      if let Some(filter) = matched {
+        MatchResult::Matches(filter)
+      } else if self.has_exclude && !self.has_include {
+        MatchResult::Included
+      } else {
+        MatchResult::Excluded
+      }
+    }
+  }
+
+  pub enum MatchResult<'a> {
+    Matches(&'a Filter),
+    Included,
+    Excluded,
+  }
+
+  impl MatchResult<'_> {
+    pub fn version_spec(&self) -> Option<&VersionReq> {
+      match self {
+        MatchResult::Matches(filter) => filter.version_spec(),
+        _ => None,
+      }
+    }
+    pub fn is_included(&self) -> bool {
+      matches!(self, MatchResult::Included | MatchResult::Matches(_))
+    }
+  }
+
+  #[cfg(test)]
+  mod test {
+    fn matches_filters<'a, 'b>(
+      filters: impl IntoIterator<Item = &'a str>,
+      name: &str,
+    ) -> bool {
+      let filters = super::FilterSet::from_filter_strings(filters).unwrap();
+      filters.matches(name)
+    }
+
+    fn version_spec(s: &str) -> deno_semver::VersionReq {
+      deno_semver::VersionReq::parse_from_specifier(s).unwrap()
+    }
+
+    #[test]
+    fn basic_glob() {
+      assert!(matches_filters(["foo*"], "foo"));
+      assert!(matches_filters(["foo*"], "foobar"));
+      assert!(!matches_filters(["foo*"], "barfoo"));
+
+      assert!(matches_filters(["*foo"], "foo"));
+      assert!(matches_filters(["*foo"], "barfoo"));
+      assert!(!matches_filters(["*foo"], "foobar"));
+
+      assert!(matches_filters(["@scope/foo*"], "@scope/foobar"));
+    }
+
+    #[test]
+    fn basic_glob_with_version() {
+      assert!(matches_filters(["foo*@1"], "foo",));
+      assert!(matches_filters(["foo*@1"], "foobar",));
+      assert!(matches_filters(["foo*@1"], "foo-bar",));
+      assert!(!matches_filters(["foo*@1"], "barfoo",));
+      assert!(matches_filters(["@scope/*@1"], "@scope/foo"));
+    }
+
+    #[test]
+    fn glob_exclude() {
+      assert!(!matches_filters(["!foo*"], "foo"));
+      assert!(!matches_filters(["!foo*"], "foobar"));
+      assert!(matches_filters(["!foo*"], "barfoo"));
+
+      assert!(!matches_filters(["!*foo"], "foo"));
+      assert!(!matches_filters(["!*foo"], "barfoo"));
+      assert!(matches_filters(["!*foo"], "foobar"));
+
+      assert!(!matches_filters(["!@scope/foo*"], "@scope/foobar"));
+    }
+
+    #[test]
+    fn multiple_globs() {
+      assert!(matches_filters(["foo*", "bar*"], "foo"));
+      assert!(matches_filters(["foo*", "bar*"], "bar"));
+      assert!(!matches_filters(["foo*", "bar*"], "baz"));
+
+      assert!(matches_filters(["foo*", "!bar*"], "foo"));
+      assert!(!matches_filters(["foo*", "!bar*"], "bar"));
+      assert!(matches_filters(["foo*", "!bar*"], "foobar"));
+      assert!(!matches_filters(["foo*", "!*bar"], "foobar"));
+      assert!(!matches_filters(["foo*", "!*bar"], "baz"));
+
+      let filters =
+        super::FilterSet::from_filter_strings(["foo*@1", "bar*@2"]).unwrap();
+
+      assert_eq!(
+        filters.matching_filter("foo").version_spec().cloned(),
+        Some(version_spec("1"))
+      );
+
+      assert_eq!(
+        filters.matching_filter("bar").version_spec().cloned(),
+        Some(version_spec("2"))
+      );
+    }
+  }
+}
--- 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::Types(range) => range,
+        TypeScriptReference::Path(s) => s,
+        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,
-        &specifier_with_range.range,
+        &jsdoc.specifier.text,
+        &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,
-            NodeModuleKind::Esm,
-            ResolutionMode::Execution,
+            &self.referrer,
+            deno_graph::Position::zeroed(),
+            ResolutionMode::Import,
+            NodeResolutionKind::Execution,
          )
          .ok()
          .or_else(|| ModuleSpecifier::parse(i).ok())
--- a/cli/tools/run/mod.rs
+++ b/cli/tools/run/mod.rs
@ -124,7 +124,8 @@ async fn run_with_watch(
      !watch_flags.no_clear_screen,
    ),
    WatcherRestartMode::Automatic,
-    move |flags, watcher_communicator, _changed_paths| {
+    move |flags, watcher_communicator, changed_paths| {
+      watcher_communicator.show_path_changed(changed_paths.clone());
      Ok(async move {
        let factory = CliFactory::from_flags_for_watcher(
          flags,
--- a/cli/tools/serve.rs
+++ b/cli/tools/serve.rs
@ -151,7 +151,8 @@ async fn serve_with_watch(
      !watch_flags.no_clear_screen,
    ),
    WatcherRestartMode::Automatic,
-    move |flags, watcher_communicator, _changed_paths| {
+    move |flags, watcher_communicator, changed_paths| {
+      watcher_communicator.show_path_changed(changed_paths.clone());
      Ok(async move {
        let factory = CliFactory::from_flags_for_watcher(
          flags,
--- a/cli/tools/task.rs
+++ b/cli/tools/task.rs
@ -1,23 +1,34 @@
 // Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.

-use std::borrow::Cow;
 use std::collections::HashMap;
 use std::collections::HashSet;
+use std::num::NonZeroUsize;
 use std::path::Path;
 use std::path::PathBuf;
 use std::rc::Rc;
 use std::sync::Arc;

-use deno_config::deno_json::Task;
+use console_static_text::ansi::strip_ansi_codes;
+use deno_config::workspace::FolderConfigs;
+use deno_config::workspace::TaskDefinition;
 use deno_config::workspace::TaskOrScript;
 use deno_config::workspace::WorkspaceDirectory;
+use deno_config::workspace::WorkspaceMemberTasksConfig;
 use deno_config::workspace::WorkspaceTasksConfig;
 use deno_core::anyhow::anyhow;
 use deno_core::anyhow::bail;
 use deno_core::anyhow::Context;
 use deno_core::error::AnyError;
+use deno_core::futures::future::LocalBoxFuture;
+use deno_core::futures::stream::futures_unordered;
+use deno_core::futures::FutureExt;
+use deno_core::futures::StreamExt;
+use deno_core::url::Url;
 use deno_path_util::normalize_path;
+use deno_runtime::deno_node::NodeResolver;
 use deno_task_shell::ShellCommand;
+use indexmap::IndexMap;
+use regex::Regex;

 use crate::args::CliOptions;
 use crate::args::Flags;
@ -28,6 +39,12 @@ use crate::npm::CliNpmResolver;
 use crate::task_runner;
 use crate::util::fs::canonicalize_path;

+#[derive(Debug)]
+struct PackageTaskInfo {
+  matched_tasks: Vec<String>,
+  tasks_config: WorkspaceTasksConfig,
+}
+
 pub async fn execute_script(
  flags: Arc<Flags>,
  task_flags: TaskFlags,
@ -35,7 +52,7 @@ pub async fn execute_script(
  let factory = CliFactory::from_flags(flags);
  let cli_options = factory.cli_options()?;
  let start_dir = &cli_options.start_dir;
-  if !start_dir.has_deno_or_pkg_json() {
+  if !start_dir.has_deno_or_pkg_json() && !task_flags.eval {
    bail!("deno task couldn't find deno.json(c). See https://docs.deno.com/go/config")
  }
  let force_use_pkg_json =
@ -48,155 +65,563 @@ pub async fn execute_script(
        v == "1"
      })
      .unwrap_or(false);
-  let tasks_config = start_dir.to_tasks_config()?;
-  let tasks_config = if force_use_pkg_json {
-    tasks_config.with_only_pkg_json()
-  } else {
-    tasks_config
-  };

-  let task_name = match &task_flags.task {
-    Some(task) => task,
-    None => {
+  fn arg_to_regex(input: &str) -> Result<regex::Regex, regex::Error> {
+    let mut regex_str = regex::escape(input);
+    regex_str = regex_str.replace("\\*", ".*");
+
+    Regex::new(&regex_str)
+  }
+
+  let packages_task_configs: Vec<PackageTaskInfo> = if let Some(filter) =
+    &task_flags.filter
+  {
+    let task_name = task_flags.task.as_ref().unwrap();
+
+    // Filter based on package name
+    let package_regex = arg_to_regex(filter)?;
+    let task_regex = arg_to_regex(task_name)?;
+
+    let mut packages_task_info: Vec<PackageTaskInfo> = vec![];
+
+    fn matches_package(
+      config: &FolderConfigs,
+      force_use_pkg_json: bool,
+      regex: &Regex,
+    ) -> bool {
+      if !force_use_pkg_json {
+        if let Some(deno_json) = &config.deno_json {
+          if let Some(name) = &deno_json.json.name {
+            if regex.is_match(name) {
+              return true;
+            }
+          }
+        }
+      }
+
+      if let Some(package_json) = &config.pkg_json {
+        if let Some(name) = &package_json.name {
+          if regex.is_match(name) {
+            return true;
+          }
+        }
+      }
+
+      false
+    }
+
+    let workspace = cli_options.workspace();
+    for folder in workspace.config_folders() {
+      if !matches_package(folder.1, force_use_pkg_json, &package_regex) {
+        continue;
+      }
+
+      let member_dir = workspace.resolve_member_dir(folder.0);
+      let mut tasks_config = member_dir.to_tasks_config()?;
+      if force_use_pkg_json {
+        tasks_config = tasks_config.with_only_pkg_json();
+      }
+
+      // Any of the matched tasks could be a child task of another matched
+      // one. Therefore we need to filter these out to ensure that every
+      // task is only run once.
+      let mut matched: HashSet<String> = HashSet::new();
+      let mut visited: HashSet<String> = HashSet::new();
+
+      fn visit_task(
+        tasks_config: &WorkspaceTasksConfig,
+        visited: &mut HashSet<String>,
+        name: &str,
+      ) {
+        if visited.contains(name) {
+          return;
+        }
+
+        visited.insert(name.to_string());
+
+        if let Some((_, TaskOrScript::Task(_, task))) = &tasks_config.task(name)
+        {
+          for dep in &task.dependencies {
+            visit_task(tasks_config, visited, dep);
+          }
+        }
+      }
+
+      // Match tasks in deno.json
+      for name in tasks_config.task_names() {
+        if task_regex.is_match(name) && !visited.contains(name) {
+          matched.insert(name.to_string());
+          visit_task(&tasks_config, &mut visited, name);
+        }
+      }
+
+      packages_task_info.push(PackageTaskInfo {
+        matched_tasks: matched
+          .iter()
+          .map(|s| s.to_string())
+          .collect::<Vec<_>>(),
+        tasks_config,
+      });
+    }
+
+    // Logging every task definition would be too spammy. Pnpm only
+    // logs a simple message too.
+    if packages_task_info
+      .iter()
+      .all(|config| config.matched_tasks.is_empty())
+    {
+      log::warn!(
+        "{}",
+        colors::red(format!(
+          "No matching task or script '{}' found in selected packages.",
+          task_name
+        ))
+      );
+      return Ok(0);
+    }
+
+    // FIXME: Sort packages topologically
+    //
+
+    packages_task_info
+  } else {
+    let mut tasks_config = start_dir.to_tasks_config()?;
+
+    if force_use_pkg_json {
+      tasks_config = tasks_config.with_only_pkg_json()
+    }
+
+    let Some(task_name) = &task_flags.task else {
      print_available_tasks(
        &mut std::io::stdout(),
        &cli_options.start_dir,
        &tasks_config,
      )?;
      return Ok(0);
-    }
+    };
+
+    vec![PackageTaskInfo {
+      tasks_config,
+      matched_tasks: vec![task_name.to_string()],
+    }]
  };

  let npm_resolver = factory.npm_resolver().await?;
  let node_resolver = factory.node_resolver().await?;
  let env_vars = task_runner::real_env_vars();

-  match tasks_config.task(task_name) {
-    Some((dir_url, task_or_script)) => match task_or_script {
-      TaskOrScript::Task(_tasks, script) => {
-        let cwd = match task_flags.cwd {
-          Some(path) => canonicalize_path(&PathBuf::from(path))
-            .context("failed canonicalizing --cwd")?,
-          None => normalize_path(dir_url.to_file_path().unwrap()),
-        };
+  let no_of_concurrent_tasks = if let Ok(value) = std::env::var("DENO_JOBS") {
+    value.parse::<NonZeroUsize>().ok()
+  } else {
+    std::thread::available_parallelism().ok()
+  }
+  .unwrap_or_else(|| NonZeroUsize::new(2).unwrap());

-        let custom_commands = task_runner::resolve_custom_commands(
-          npm_resolver.as_ref(),
-          node_resolver,
-        )?;
-        run_task(RunTaskOptions {
-          task_name,
-          script,
-          cwd: &cwd,
-          env_vars,
-          custom_commands,
-          npm_resolver: npm_resolver.as_ref(),
-          cli_options,
-        })
-        .await
-      }
-      TaskOrScript::Script(scripts, _script) => {
-        // ensure the npm packages are installed if using a managed resolver
-        if let Some(npm_resolver) = npm_resolver.as_managed() {
-          npm_resolver.ensure_top_level_package_json_install().await?;
-        }
+  let task_runner = TaskRunner {
+    task_flags: &task_flags,
+    npm_resolver: npm_resolver.as_ref(),
+    node_resolver: node_resolver.as_ref(),
+    env_vars,
+    cli_options,
+    concurrency: no_of_concurrent_tasks.into(),
+  };

-        let cwd = match task_flags.cwd {
-          Some(path) => canonicalize_path(&PathBuf::from(path))?,
-          None => normalize_path(dir_url.to_file_path().unwrap()),
-        };
+  if task_flags.eval {
+    return task_runner
+      .run_deno_task(
+        &Url::from_directory_path(cli_options.initial_cwd()).unwrap(),
+        "",
+        &TaskDefinition {
+          command: task_flags.task.as_ref().unwrap().to_string(),
+          dependencies: vec![],
+          description: None,
+        },
+      )
+      .await;
+  }

-        // At this point we already checked if the task name exists in package.json.
-        // We can therefore check for "pre" and "post" scripts too, since we're only
-        // dealing with package.json here and not deno.json
-        let task_names = vec![
-          format!("pre{}", task_name),
-          task_name.clone(),
-          format!("post{}", task_name),
-        ];
-        let custom_commands = task_runner::resolve_custom_commands(
-          npm_resolver.as_ref(),
-          node_resolver,
-        )?;
-        for task_name in &task_names {
-          if let Some(script) = scripts.get(task_name) {
-            let exit_code = run_task(RunTaskOptions {
-              task_name,
-              script,
-              cwd: &cwd,
-              env_vars: env_vars.clone(),
-              custom_commands: custom_commands.clone(),
-              npm_resolver: npm_resolver.as_ref(),
-              cli_options,
-            })
-            .await?;
-            if exit_code > 0 {
-              return Ok(exit_code);
-            }
-          }
-        }
-
-        Ok(0)
-      }
-    },
-    None => {
-      if task_flags.is_run {
-        return Err(anyhow!("Task not found: {}", task_name));
-      }
-      log::error!("Task not found: {}", task_name);
-      if log::log_enabled!(log::Level::Error) {
-        print_available_tasks(
-          &mut std::io::stderr(),
-          &cli_options.start_dir,
-          &tasks_config,
-        )?;
-      }
-      Ok(1)
+  for task_config in &packages_task_configs {
+    let exit_code = task_runner.run_tasks(task_config).await?;
+    if exit_code > 0 {
+      return Ok(exit_code);
    }
  }
+
+  Ok(0)
 }

-struct RunTaskOptions<'a> {
+struct RunSingleOptions<'a> {
  task_name: &'a str,
  script: &'a str,
  cwd: &'a Path,
-  env_vars: HashMap<String, String>,
  custom_commands: HashMap<String, Rc<dyn ShellCommand>>,
-  npm_resolver: &'a dyn CliNpmResolver,
-  cli_options: &'a CliOptions,
 }

-async fn run_task(opts: RunTaskOptions<'_>) -> Result<i32, AnyError> {
-  let RunTaskOptions {
-    task_name,
-    script,
-    cwd,
-    env_vars,
-    custom_commands,
-    npm_resolver,
-    cli_options,
-  } = opts;
+struct TaskRunner<'a> {
+  task_flags: &'a TaskFlags,
+  npm_resolver: &'a dyn CliNpmResolver,
+  node_resolver: &'a NodeResolver,
+  env_vars: HashMap<String, String>,
+  cli_options: &'a CliOptions,
+  concurrency: usize,
+}

-  output_task(
-    opts.task_name,
-    &task_runner::get_script_with_args(script, cli_options.argv()),
-  );
+impl<'a> TaskRunner<'a> {
+  pub async fn run_tasks(
+    &self,
+    pkg_tasks_config: &PackageTaskInfo,
+  ) -> Result<i32, deno_core::anyhow::Error> {
+    match sort_tasks_topo(pkg_tasks_config) {
+      Ok(sorted) => self.run_tasks_in_parallel(sorted).await,
+      Err(err) => match err {
+        TaskError::NotFound(name) => {
+          if self.task_flags.is_run {
+            return Err(anyhow!("Task not found: {}", name));
+          }

-  Ok(
-    task_runner::run_task(task_runner::RunTaskOptions {
+          log::error!("Task not found: {}", name);
+          if log::log_enabled!(log::Level::Error) {
+            self.print_available_tasks(&pkg_tasks_config.tasks_config)?;
+          }
+          Ok(1)
+        }
+        TaskError::TaskDepCycle { path } => {
+          log::error!("Task cycle detected: {}", path.join(" -> "));
+          Ok(1)
+        }
+      },
+    }
+  }
+
+  pub fn print_available_tasks(
+    &self,
+    tasks_config: &WorkspaceTasksConfig,
+  ) -> Result<(), std::io::Error> {
+    print_available_tasks(
+      &mut std::io::stderr(),
+      &self.cli_options.start_dir,
+      tasks_config,
+    )
+  }
+
+  async fn run_tasks_in_parallel(
+    &self,
+    tasks: Vec<ResolvedTask<'a>>,
+  ) -> Result<i32, deno_core::anyhow::Error> {
+    struct PendingTasksContext<'a> {
+      completed: HashSet<usize>,
+      running: HashSet<usize>,
+      tasks: &'a [ResolvedTask<'a>],
+    }
+
+    impl<'a> PendingTasksContext<'a> {
+      fn has_remaining_tasks(&self) -> bool {
+        self.completed.len() < self.tasks.len()
+      }
+
+      fn mark_complete(&mut self, task: &ResolvedTask) {
+        self.running.remove(&task.id);
+        self.completed.insert(task.id);
+      }
+
+      fn get_next_task<'b>(
+        &mut self,
+        runner: &'b TaskRunner<'b>,
+      ) -> Option<
+        LocalBoxFuture<'b, Result<(i32, &'a ResolvedTask<'a>), AnyError>>,
+      >
+      where
+        'a: 'b,
+      {
+        for task in self.tasks.iter() {
+          if self.completed.contains(&task.id)
+            || self.running.contains(&task.id)
+          {
+            continue;
+          }
+
+          let should_run = task
+            .dependencies
+            .iter()
+            .all(|dep_id| self.completed.contains(dep_id));
+          if !should_run {
+            continue;
+          }
+
+          self.running.insert(task.id);
+          return Some(
+            async move {
+              match task.task_or_script {
+                TaskOrScript::Task(_, def) => {
+                  runner.run_deno_task(task.folder_url, task.name, def).await
+                }
+                TaskOrScript::Script(scripts, _) => {
+                  runner
+                    .run_npm_script(task.folder_url, task.name, scripts)
+                    .await
+                }
+              }
+              .map(|exit_code| (exit_code, task))
+            }
+            .boxed_local(),
+          );
+        }
+        None
+      }
+    }
+
+    let mut context = PendingTasksContext {
+      completed: HashSet::with_capacity(tasks.len()),
+      running: HashSet::with_capacity(self.concurrency),
+      tasks: &tasks,
+    };
+
+    let mut queue = futures_unordered::FuturesUnordered::new();
+
+    while context.has_remaining_tasks() {
+      while queue.len() < self.concurrency {
+        if let Some(task) = context.get_next_task(self) {
+          queue.push(task);
+        } else {
+          break;
+        }
+      }
+
+      // If queue is empty at this point, then there are no more tasks in the queue.
+      let Some(result) = queue.next().await else {
+        debug_assert_eq!(context.tasks.len(), 0);
+        break;
+      };
+
+      let (exit_code, name) = result?;
+      if exit_code > 0 {
+        return Ok(exit_code);
+      }
+
+      context.mark_complete(name);
+    }
+
+    Ok(0)
+  }
+
+  pub async fn run_deno_task(
+    &self,
+    dir_url: &Url,
+    task_name: &str,
+    definition: &TaskDefinition,
+  ) -> Result<i32, deno_core::anyhow::Error> {
+    let cwd = match &self.task_flags.cwd {
+      Some(path) => canonicalize_path(&PathBuf::from(path))
+        .context("failed canonicalizing --cwd")?,
+      None => normalize_path(dir_url.to_file_path().unwrap()),
+    };
+
+    let custom_commands = task_runner::resolve_custom_commands(
+      self.npm_resolver,
+      self.node_resolver,
+    )?;
+    self
+      .run_single(RunSingleOptions {
+        task_name,
+        script: &definition.command,
+        cwd: &cwd,
+        custom_commands,
+      })
+      .await
+  }
+
+  pub async fn run_npm_script(
+    &self,
+    dir_url: &Url,
+    task_name: &str,
+    scripts: &IndexMap<String, String>,
+  ) -> Result<i32, deno_core::anyhow::Error> {
+    // ensure the npm packages are installed if using a managed resolver
+    if let Some(npm_resolver) = self.npm_resolver.as_managed() {
+      npm_resolver.ensure_top_level_package_json_install().await?;
+    }
+
+    let cwd = match &self.task_flags.cwd {
+      Some(path) => canonicalize_path(&PathBuf::from(path))?,
+      None => normalize_path(dir_url.to_file_path().unwrap()),
+    };
+
+    // At this point we already checked if the task name exists in package.json.
+    // We can therefore check for "pre" and "post" scripts too, since we're only
+    // dealing with package.json here and not deno.json
+    let task_names = vec![
+      format!("pre{}", task_name),
+      task_name.to_string(),
+      format!("post{}", task_name),
+    ];
+    let custom_commands = task_runner::resolve_custom_commands(
+      self.npm_resolver,
+      self.node_resolver,
+    )?;
+    for task_name in &task_names {
+      if let Some(script) = scripts.get(task_name) {
+        let exit_code = self
+          .run_single(RunSingleOptions {
+            task_name,
+            script,
+            cwd: &cwd,
+            custom_commands: custom_commands.clone(),
+          })
+          .await?;
+        if exit_code > 0 {
+          return Ok(exit_code);
+        }
+      }
+    }
+
+    Ok(0)
+  }
+
+  async fn run_single(
+    &self,
+    opts: RunSingleOptions<'_>,
+  ) -> Result<i32, AnyError> {
+    let RunSingleOptions {
      task_name,
      script,
      cwd,
-      env_vars,
      custom_commands,
-      init_cwd: opts.cli_options.initial_cwd(),
-      argv: cli_options.argv(),
-      root_node_modules_dir: npm_resolver.root_node_modules_path(),
-      stdio: None,
-    })
-    .await?
-    .exit_code,
-  )
+    } = opts;
+
+    output_task(
+      opts.task_name,
+      &task_runner::get_script_with_args(script, self.cli_options.argv()),
+    );
+
+    Ok(
+      task_runner::run_task(task_runner::RunTaskOptions {
+        task_name,
+        script,
+        cwd,
+        env_vars: self.env_vars.clone(),
+        custom_commands,
+        init_cwd: self.cli_options.initial_cwd(),
+        argv: self.cli_options.argv(),
+        root_node_modules_dir: self.npm_resolver.root_node_modules_path(),
+        stdio: None,
+      })
+      .await?
+      .exit_code,
+    )
+  }
+}
+
+#[derive(Debug)]
+enum TaskError {
+  NotFound(String),
+  TaskDepCycle { path: Vec<String> },
+}
+
+struct ResolvedTask<'a> {
+  id: usize,
+  name: &'a str,
+  folder_url: &'a Url,
+  task_or_script: TaskOrScript<'a>,
+  dependencies: Vec<usize>,
+}
+
+fn sort_tasks_topo<'a>(
+  pkg_task_config: &'a PackageTaskInfo,
+) -> Result<Vec<ResolvedTask<'a>>, TaskError> {
+  trait TasksConfig {
+    fn task(
+      &self,
+      name: &str,
+    ) -> Option<(&Url, TaskOrScript, &dyn TasksConfig)>;
+  }
+
+  impl TasksConfig for WorkspaceTasksConfig {
+    fn task(
+      &self,
+      name: &str,
+    ) -> Option<(&Url, TaskOrScript, &dyn TasksConfig)> {
+      if let Some(member) = &self.member {
+        if let Some((dir_url, task_or_script)) = member.task(name) {
+          return Some((dir_url, task_or_script, self as &dyn TasksConfig));
+        }
+      }
+      if let Some(root) = &self.root {
+        if let Some((dir_url, task_or_script)) = root.task(name) {
+          // switch to only using the root tasks for the dependencies
+          return Some((dir_url, task_or_script, root as &dyn TasksConfig));
+        }
+      }
+      None
+    }
+  }
+
+  impl TasksConfig for WorkspaceMemberTasksConfig {
+    fn task(
+      &self,
+      name: &str,
+    ) -> Option<(&Url, TaskOrScript, &dyn TasksConfig)> {
+      self.task(name).map(|(dir_url, task_or_script)| {
+        (dir_url, task_or_script, self as &dyn TasksConfig)
+      })
+    }
+  }
+
+  fn sort_visit<'a>(
+    name: &'a str,
+    sorted: &mut Vec<ResolvedTask<'a>>,
+    mut path: Vec<(&'a Url, &'a str)>,
+    tasks_config: &'a dyn TasksConfig,
+  ) -> Result<usize, TaskError> {
+    let Some((folder_url, task_or_script, tasks_config)) =
+      tasks_config.task(name)
+    else {
+      return Err(TaskError::NotFound(name.to_string()));
+    };
+
+    if let Some(existing_task) = sorted
+      .iter()
+      .find(|task| task.name == name && task.folder_url == folder_url)
+    {
+      // already exists
+      return Ok(existing_task.id);
+    }
+
+    if path.contains(&(folder_url, name)) {
+      path.push((folder_url, name));
+      return Err(TaskError::TaskDepCycle {
+        path: path.iter().map(|(_, s)| s.to_string()).collect(),
+      });
+    }
+
+    let mut dependencies: Vec<usize> = Vec::new();
+    if let TaskOrScript::Task(_, task) = task_or_script {
+      dependencies.reserve(task.dependencies.len());
+      for dep in &task.dependencies {
+        let mut path = path.clone();
+        path.push((folder_url, name));
+        dependencies.push(sort_visit(dep, sorted, path, tasks_config)?);
+      }
+    }
+
+    let id = sorted.len();
+    sorted.push(ResolvedTask {
+      id,
+      name,
+      folder_url,
+      task_or_script,
+      dependencies,
+    });
+
+    Ok(id)
+  }
+
+  let mut sorted: Vec<ResolvedTask<'a>> = vec![];
+
+  for name in &pkg_task_config.matched_tasks {
+    sort_visit(name, &mut sorted, Vec::new(), &pkg_task_config.tasks_config)?;
+  }
+
+  Ok(sorted)
 }

 fn output_task(task_name: &str, script: &str) {
@ -222,80 +647,123 @@ fn print_available_tasks(
      "  {}",
      colors::red("No tasks found in configuration file")
    )?;
-  } else {
-    let mut seen_task_names =
-      HashSet::with_capacity(tasks_config.tasks_count());
-    for maybe_config in [&tasks_config.member, &tasks_config.root] {
-      let Some(config) = maybe_config else {
-        continue;
-      };
-      for (is_root, is_deno, (key, task)) in config
-        .deno_json
-        .as_ref()
-        .map(|config| {
-          let is_root = !is_cwd_root_dir
-            && config.folder_url
-              == *workspace_dir.workspace.root_dir().as_ref();
-          config
-            .tasks
-            .iter()
-            .map(move |(k, t)| (is_root, true, (k, Cow::Borrowed(t))))
-        })
-        .into_iter()
-        .flatten()
-        .chain(
-          config
-            .package_json
-            .as_ref()
-            .map(|config| {
-              let is_root = !is_cwd_root_dir
-                && config.folder_url
-                  == *workspace_dir.workspace.root_dir().as_ref();
-              config.tasks.iter().map(move |(k, v)| {
-                (is_root, false, (k, Cow::Owned(Task::Definition(v.clone()))))
-              })
-            })
-            .into_iter()
-            .flatten(),
-        )
-      {
-        if !seen_task_names.insert(key) {
+    return Ok(());
+  }
+
+  struct AvailableTaskDescription {
+    is_root: bool,
+    is_deno: bool,
+    name: String,
+    task: TaskDefinition,
+  }
+  let mut seen_task_names = HashSet::with_capacity(tasks_config.tasks_count());
+  let mut task_descriptions = Vec::with_capacity(tasks_config.tasks_count());
+
+  for maybe_config in [&tasks_config.member, &tasks_config.root] {
+    let Some(config) = maybe_config else {
+      continue;
+    };
+
+    if let Some(config) = config.deno_json.as_ref() {
+      let is_root = !is_cwd_root_dir
+        && config.folder_url == *workspace_dir.workspace.root_dir().as_ref();
+
+      for (name, definition) in &config.tasks {
+        if !seen_task_names.insert(name) {
          continue; // already seen
        }
+        task_descriptions.push(AvailableTaskDescription {
+          is_root,
+          is_deno: true,
+          name: name.to_string(),
+          task: definition.clone(),
+        });
+      }
+    }
+
+    if let Some(config) = config.package_json.as_ref() {
+      let is_root = !is_cwd_root_dir
+        && config.folder_url == *workspace_dir.workspace.root_dir().as_ref();
+      for (name, script) in &config.tasks {
+        if !seen_task_names.insert(name) {
+          continue; // already seen
+        }
+
+        task_descriptions.push(AvailableTaskDescription {
+          is_root,
+          is_deno: false,
+          name: name.to_string(),
+          task: deno_config::deno_json::TaskDefinition {
+            command: script.to_string(),
+            dependencies: vec![],
+            description: None,
+          },
+        });
+      }
+    }
+  }
+
+  for desc in task_descriptions {
+    writeln!(
+      writer,
+      "- {}{}",
+      colors::cyan(desc.name),
+      if desc.is_root {
+        if desc.is_deno {
+          format!(" {}", colors::italic_gray("(workspace)"))
+        } else {
+          format!(" {}", colors::italic_gray("(workspace package.json)"))
+        }
+      } else if desc.is_deno {
+        "".to_string()
+      } else {
+        format!(" {}", colors::italic_gray("(package.json)"))
+      }
+    )?;
+    if let Some(description) = &desc.task.description {
+      let slash_slash = colors::italic_gray("//");
+      for line in description.lines() {
        writeln!(
          writer,
-          "- {}{}",
-          colors::cyan(key),
-          if is_root {
-            if is_deno {
-              format!(" {}", colors::italic_gray("(workspace)"))
-            } else {
-              format!(" {}", colors::italic_gray("(workspace package.json)"))
-            }
-          } else if is_deno {
-            "".to_string()
-          } else {
-            format!(" {}", colors::italic_gray("(package.json)"))
-          }
+          "    {slash_slash} {}",
+          colors::italic_gray(strip_ansi_codes_and_escape_control_chars(line))
        )?;
-        let definition = match task.as_ref() {
-          Task::Definition(definition) => definition,
-          Task::Commented { definition, .. } => definition,
-        };
-        if let Task::Commented { comments, .. } = task.as_ref() {
-          let slash_slash = colors::italic_gray("//");
-          for comment in comments {
-            writeln!(
-              writer,
-              "    {slash_slash} {}",
-              colors::italic_gray(comment)
-            )?;
-          }
-        }
-        writeln!(writer, "    {definition}")?;
      }
    }
+    writeln!(
+      writer,
+      "    {}",
+      strip_ansi_codes_and_escape_control_chars(&desc.task.command)
+    )?;
+    if !desc.task.dependencies.is_empty() {
+      let dependencies = desc
+        .task
+        .dependencies
+        .into_iter()
+        .map(|d| strip_ansi_codes_and_escape_control_chars(&d))
+        .collect::<Vec<_>>()
+        .join(", ");
+      writeln!(
+        writer,
+        "    {} {}",
+        colors::gray("depends on:"),
+        colors::cyan(dependencies)
+      )?;
+    }
  }

  Ok(())
 }
+
+fn strip_ansi_codes_and_escape_control_chars(s: &str) -> String {
+  strip_ansi_codes(s)
+    .chars()
+    .map(|c| match c {
+      '\n' => "\\n".to_string(),
+      '\r' => "\\r".to_string(),
+      '\t' => "\\t".to_string(),
+      c if c.is_control() => format!("\\x{:02x}", c as u8),
+      c => c.to_string(),
+    })
+    .collect()
+}
--- a/cli/tools/test/mod.rs
+++ b/cli/tools/test/mod.rs
@ -1661,6 +1661,7 @@ pub async fn run_tests_with_watch(
    ),
    move |flags, watcher_communicator, changed_paths| {
      let test_flags = test_flags.clone();
+      watcher_communicator.show_path_changed(changed_paths.clone());
      Ok(async move {
        let factory = CliFactory::from_flags_for_watcher(
          flags,
--- a/cli/tsc/99_main_compiler.js
+++ b/cli/tsc/99_main_compiler.js
@ -450,6 +450,12 @@ delete Object.prototype.__proto__;
    // We specify the resolution mode to be CommonJS for some npm files and this
    // diagnostic gets generated even though we're using custom module resolution.
    1452,
+    // Module '...' cannot be imported using this construct. The specifier only resolves to an
+    // ES module, which cannot be imported with 'require'.
+    1471,
+    // TS1479: The current file is a CommonJS module whose imports will produce 'require' calls;
+    // however, the referenced file is an ECMAScript module and cannot be imported with 'require'.
+    1479,
    // TS2306: File '.../index.d.ts' is not a module.
    // We get this for `x-typescript-types` declaration files which don't export
    // anything. We prefer to treat these as modules with no exports.
@ -675,14 +681,18 @@ delete Object.prototype.__proto__;
    getNewLine() {
      return "\n";
    },
-    resolveTypeReferenceDirectives(
-      typeDirectiveNames,
+    resolveTypeReferenceDirectiveReferences(
+      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"
          ? {
@ -695,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,
-              resolvedFileName: resolved[0],
+              resolvedTypeReferenceDirective: {
+                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(
@ -714,41 +736,56 @@ delete Object.prototype.__proto__;
            host,
            redirectedReference,
            undefined,
-            containingFileMode ?? fileReference.resolutionMode,
-          ).resolvedTypeReferenceDirective;
+            containingSourceFile?.impliedNodeFormat ??
+              fileReference.resolutionMode,
+          );
        }
      });
+      return result;
    },
-    resolveModuleNames(
-      specifiers,
+    resolveModuleNameLiterals(
+      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,
-              extension,
-              isExternalLibraryImport: false,
+              resolvedModule: {
+                resolvedFileName,
+                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.deno.ns.d.ts
+++ b/cli/tsc/dts/lib.deno.ns.d.ts
@ -4535,7 +4535,7 @@ declare namespace Deno {
  /** The object that is returned from a {@linkcode Deno.upgradeWebSocket}
   * request.
   *
-   * @category Web Sockets */
+   * @category WebSockets */
  export interface WebSocketUpgrade {
    /** The response object that represents the HTTP response to the client,
     * which should be used to the {@linkcode RequestEvent} `.respondWith()` for
@ -4549,7 +4549,7 @@ declare namespace Deno {
  /** Options which can be set when performing a
   * {@linkcode Deno.upgradeWebSocket} upgrade of a {@linkcode Request}
   *
-   * @category Web Sockets */
+   * @category WebSockets */
  export interface UpgradeWebSocketOptions {
    /** Sets the `.protocol` property on the client side web socket to the
     * value provided here, which should be one of the strings specified in the
@ -4597,7 +4597,7 @@ declare namespace Deno {
   * This operation does not yet consume the request or open the websocket. This
   * only happens once the returned response has been passed to `respondWith()`.
   *
-   * @category Web Sockets
+   * @category WebSockets
   */
  export function upgradeWebSocket(
    request: Request,
--- a/cli/tsc/dts/lib.deno.shared_globals.d.ts
+++ b/cli/tsc/dts/lib.deno.shared_globals.d.ts
@ -15,14 +15,14 @@
 /// <reference lib="deno.crypto" />
 /// <reference lib="deno.ns" />

-/** @category WASM */
+/** @category Wasm */
 declare namespace WebAssembly {
  /**
   * The `WebAssembly.CompileError` object indicates an error during WebAssembly decoding or validation.
   *
   * [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/CompileError)
   *
-   * @category WASM
+   * @category Wasm
   */
  export class CompileError extends Error {
    /** Creates a new `WebAssembly.CompileError` object. */
@ -36,7 +36,7 @@ declare namespace WebAssembly {
   *
   * [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/Global)
   *
-   * @category WASM
+   * @category Wasm
   */
  export class Global {
    /** Creates a new `Global` object. */
@ -59,7 +59,7 @@ declare namespace WebAssembly {
   *
   * [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/Instance)
   *
-   * @category WASM
+   * @category Wasm
   */
  export class Instance {
    /** Creates a new Instance object. */
@ -79,7 +79,7 @@ declare namespace WebAssembly {
   *
   * [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/LinkError)
   *
-   * @category WASM
+   * @category Wasm
   */
  export class LinkError extends Error {
    /** Creates a new WebAssembly.LinkError object. */
@ -95,7 +95,7 @@ declare namespace WebAssembly {
   *
   * [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/Memory)
   *
-   * @category WASM
+   * @category Wasm
   */
  export class Memory {
    /** Creates a new `Memory` object. */
@ -117,7 +117,7 @@ declare namespace WebAssembly {
   *
   * [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/Module)
   *
-   * @category WASM
+   * @category Wasm
   */
  export class Module {
    /** Creates a new `Module` object. */
@ -145,7 +145,7 @@ declare namespace WebAssembly {
   *
   * [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/RuntimeError)
   *
-   * @category WASM
+   * @category Wasm
   */
  export class RuntimeError extends Error {
    /** Creates a new `WebAssembly.RuntimeError` object. */
@ -160,7 +160,7 @@ declare namespace WebAssembly {
   *
   * [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/Table)
   *
-   * @category WASM
+   * @category Wasm
   */
  export class Table {
    /** Creates a new `Table` object. */
@ -182,7 +182,7 @@ declare namespace WebAssembly {
  /** The `GlobalDescriptor` describes the options you can pass to
   * `new WebAssembly.Global()`.
   *
-   * @category WASM
+   * @category Wasm
   */
  export interface GlobalDescriptor {
    mutable?: boolean;
@ -192,7 +192,7 @@ declare namespace WebAssembly {
  /** The `MemoryDescriptor` describes the options you can pass to
   * `new WebAssembly.Memory()`.
   *
-   * @category WASM
+   * @category Wasm
   */
  export interface MemoryDescriptor {
    initial: number;
@ -203,7 +203,7 @@ declare namespace WebAssembly {
  /** A `ModuleExportDescriptor` is the description of a declared export in a
   * `WebAssembly.Module`.
   *
-   * @category WASM
+   * @category Wasm
   */
  export interface ModuleExportDescriptor {
    kind: ImportExportKind;
@ -213,7 +213,7 @@ declare namespace WebAssembly {
  /** A `ModuleImportDescriptor` is the description of a declared import in a
   * `WebAssembly.Module`.
   *
-   * @category WASM
+   * @category Wasm
   */
  export interface ModuleImportDescriptor {
    kind: ImportExportKind;
@ -224,7 +224,7 @@ declare namespace WebAssembly {
  /** The `TableDescriptor` describes the options you can pass to
   * `new WebAssembly.Table()`.
   *
-   * @category WASM
+   * @category Wasm
   */
  export interface TableDescriptor {
    element: TableKind;
@ -234,7 +234,7 @@ declare namespace WebAssembly {

  /** The value returned from `WebAssembly.instantiate`.
   *
-   * @category WASM
+   * @category Wasm
   */
  export interface WebAssemblyInstantiatedSource {
    /* A `WebAssembly.Instance` object that contains all the exported WebAssembly functions. */
@ -247,21 +247,21 @@ declare namespace WebAssembly {
    module: Module;
  }

-  /** @category WASM */
+  /** @category Wasm */
  export type ImportExportKind = "function" | "global" | "memory" | "table";
-  /** @category WASM */
+  /** @category Wasm */
  export type TableKind = "anyfunc";
-  /** @category WASM */
+  /** @category Wasm */
  export type ValueType = "f32" | "f64" | "i32" | "i64";
-  /** @category WASM */
+  /** @category Wasm */
  export type ExportValue = Function | Global | Memory | Table;
-  /** @category WASM */
+  /** @category Wasm */
  export type Exports = Record<string, ExportValue>;
-  /** @category WASM */
+  /** @category Wasm */
  export type ImportValue = ExportValue | number;
-  /** @category WASM */
+  /** @category Wasm */
  export type ModuleImports = Record<string, ImportValue>;
-  /** @category WASM */
+  /** @category Wasm */
  export type Imports = Record<string, ModuleImports>;

  /**
@ -272,7 +272,7 @@ declare namespace WebAssembly {
   *
   * [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/compile)
   *
-   * @category WASM
+   * @category Wasm
   */
  export function compile(bytes: BufferSource): Promise<Module>;

@ -284,7 +284,7 @@ declare namespace WebAssembly {
   *
   * [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/compileStreaming)
   *
-   * @category WASM
+   * @category Wasm
   */
  export function compileStreaming(
    source: Response | Promise<Response>,
@ -301,7 +301,7 @@ declare namespace WebAssembly {
   *
   * [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/instantiate)
   *
-   * @category WASM
+   * @category Wasm
   */
  export function instantiate(
    bytes: BufferSource,
@ -318,7 +318,7 @@ declare namespace WebAssembly {
   *
   * [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/instantiate)
   *
-   * @category WASM
+   * @category Wasm
   */
  export function instantiate(
    moduleObject: Module,
@ -332,7 +332,7 @@ declare namespace WebAssembly {
   *
   * [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/instantiateStreaming)
   *
-   * @category WASM
+   * @category Wasm
   */
  export function instantiateStreaming(
    response: Response | PromiseLike<Response>,
@ -346,7 +346,7 @@ declare namespace WebAssembly {
   *
   * [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/validate)
   *
-   * @category WASM
+   * @category Wasm
   */
  export function validate(bytes: BufferSource): boolean;
 }
--- a/cli/tsc/dts/lib.deno.unstable.d.ts
+++ b/cli/tsc/dts/lib.deno.unstable.d.ts
@ -1180,6 +1180,32 @@ declare namespace Deno {
      ...values: unknown[]
    ): Displayable;

+    /**
+     * Display a JPG or PNG image.
+     *
+     * ```
+     * Deno.jupyter.image("./cat.jpg");
+     * Deno.jupyter.image("./dog.png");
+     * ```
+     *
+     * @category Jupyter
+     * @experimental
+     */
+    export function image(path: string): Displayable;
+
+    /**
+     * Display a JPG or PNG image.
+     *
+     * ```
+     * const img = Deno.readFileSync("./cat.jpg");
+     * Deno.jupyter.image(img);
+     * ```
+     *
+     * @category Jupyter
+     * @experimental
+     */
+    export function image(data: Uint8Array): Displayable;
+
    /**
     * Format an object for displaying in Deno
     *
@ -1226,80 +1252,53 @@ declare namespace Deno {
  }

  /**
+   * **UNSTABLE**: New API, yet to be vetted.
+   *
+   * APIs for working with the OpenTelemetry observability framework. Deno can
+   * export traces, metrics, and logs to OpenTelemetry compatible backends via
+   * the OTLP protocol.
+   *
+   * Deno automatically instruments the runtime with OpenTelemetry traces and
+   * metrics. This data is exported via OTLP to OpenTelemetry compatible
+   * backends. User logs from the `console` API are exported as OpenTelemetry
+   * logs via OTLP.
+   *
+   * User code can also create custom traces, metrics, and logs using the
+   * OpenTelemetry API. This is done using the official OpenTelemetry package
+   * for JavaScript:
+   * [`npm:@opentelemetry/api`](https://opentelemetry.io/docs/languages/js/).
+   * Deno integrates with this package to provide trace context propagation
+   * between native Deno APIs (like `Deno.serve` or `fetch`) and custom user
+   * code. Deno also provides APIs that allow exporting custom telemetry data
+   * via the same OTLP channel used by the Deno runtime. This is done using the
+   * [`jsr:@deno/otel`](https://jsr.io/@deno/otel) package.
+   *
+   * @example Using OpenTelemetry API to create custom traces
+   * ```ts,ignore
+   * import { trace } from "npm:@opentelemetry/api@1";
+   * import "jsr:@deno/otel@0.0.2/register";
+   *
+   * const tracer = trace.getTracer("example-tracer");
+   *
+   * async function doWork() {
+   *   return tracer.startActiveSpan("doWork", async (span) => {
+   *     span.setAttribute("key", "value");
+   *     await new Promise((resolve) => setTimeout(resolve, 1000));
+   *     span.end();
+   *   });
+   * }
+   *
+   * Deno.serve(async (req) => {
+   *   await doWork();
+   *   const resp = await fetch("https://example.com");
+   *   return resp;
+   * });
+   * ```
+   *
   * @category Telemetry
   * @experimental
   */
-  export namespace tracing {
-    /**
-     * Whether tracing is enabled.
-     * @category Telemetry
-     * @experimental
-     */
-    export const enabled: boolean;
-
-    /**
-     * Allowed attribute type.
-     * @category Telemetry
-     * @experimental
-     */
-    export type AttributeValue = string | number | boolean | bigint;
-
-    /**
-     * A tracing span.
-     * @category Telemetry
-     * @experimental
-     */
-    export class Span implements Disposable {
-      readonly traceId: string;
-      readonly spanId: string;
-      readonly parentSpanId: string;
-      readonly kind: string;
-      readonly name: string;
-      readonly startTime: number;
-      readonly endTime: number;
-      readonly status: null | { code: 1 } | { code: 2; message: string };
-      readonly attributes: Record<string, AttributeValue>;
-      readonly traceFlags: number;
-
-      /**
-       * Construct a new Span and enter it as the "current" span.
-       */
-      constructor(
-        name: string,
-        kind?: "internal" | "server" | "client" | "producer" | "consumer",
-      );
-
-      /**
-       * Set an attribute on this span.
-       */
-      setAttribute(
-        name: string,
-        value: AttributeValue,
-      ): void;
-
-      /**
-       * Enter this span as the "current" span.
-       */
-      enter(): void;
-
-      /**
-       * Exit this span as the "current" span and restore the previous one.
-       */
-      exit(): void;
-
-      /**
-       * End this span, and exit it as the "current" span.
-       */
-      end(): void;
-
-      [Symbol.dispose](): void;
-
-      /**
-       * Get the "current" span, if one exists.
-       */
-      static current(): Span | undefined | null;
-    }
-
+  export namespace telemetry {
    /**
     * A SpanExporter compatible with OpenTelemetry.js
     * https://open-telemetry.github.io/opentelemetry-js/interfaces/_opentelemetry_sdk_trace_base.SpanExporter.html
@ -1319,14 +1318,6 @@ declare namespace Deno {
    export {}; // only export exports
  }

-  /**
-   * @category Telemetry
-   * @experimental
-   */
-  export namespace metrics {
-    export {}; // only export exports
-  }
-
  export {}; // only export exports
 }

--- 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::NodeResolutionMode;
+use node_resolver::NodeResolutionKind;
+use node_resolver::ResolutionMode;
 use once_cell::sync::Lazy;
 use std::borrow::Cow;
 use std::collections::HashMap;
@ -650,19 +650,27 @@ fn op_load_inner(
          media_type = MediaType::Json;
          Some(Cow::Borrowed(&*module.source))
        }
+        Module::Wasm(module) => {
+          media_type = MediaType::Dts;
+          Some(Cow::Borrowed(&*module.source_dts))
+        }
        Module::Npm(_) | Module::Node(_) => None,
        Module::External(module) => {
-          // means it's Deno code importing an npm module
-          let specifier = node::resolve_specifier_into_node_modules(
-            &module.specifier,
-            &deno_fs::RealFs,
-          );
-          Some(Cow::Owned(load_from_node_modules(
-            &specifier,
-            state.maybe_npm.as_ref(),
-            &mut media_type,
-            &mut is_cjs,
-          )?))
+          if module.specifier.scheme() != "file" {
+            None
+          } else {
+            // means it's Deno code importing an npm module
+            let specifier = node::resolve_specifier_into_node_modules(
+              &module.specifier,
+              &deno_fs::RealFs,
+            );
+            Some(Cow::Owned(load_from_node_modules(
+              &specifier,
+              state.maybe_npm.as_ref(),
+              &mut media_type,
+              &mut is_cjs,
+            )?))
+          }
        }
      }
    } else if let Some(npm) = state
@ -699,10 +707,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]
@ -710,17 +717,9 @@ pub struct ResolveArgs {
 fn op_resolve(
  state: &mut OpState,
  #[string] base: String,
-  is_base_cjs: bool,
-  #[serde] specifiers: Vec<String>,
+  #[serde] specifiers: Vec<(bool, String)>,
 ) -> Result<Vec<(String, &'static str)>, AnyError> {
-  op_resolve_inner(
-    state,
-    ResolveArgs {
-      base,
-      is_base_cjs,
-      specifiers,
-    },
-  )
+  op_resolve_inner(state, ResolveArgs { base, specifiers })
 }

 #[inline]
@ -731,11 +730,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)
  {
@ -748,7 +742,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(),
@ -767,13 +761,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,
        )?
      }
@ -781,7 +782,7 @@ fn op_resolve_inner(
        match resolve_non_graph_specifier_types(
          &specifier,
          &referrer,
-          referrer_kind,
+          resolution_mode,
          state,
        ) {
          Ok(maybe_result) => maybe_result,
@ -848,7 +849,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;
@ -889,6 +890,9 @@ fn resolve_graph_specifier_types(
    Some(Module::Json(module)) => {
      Ok(Some((module.specifier.clone(), module.media_type)))
    }
+    Some(Module::Wasm(module)) => {
+      Ok(Some((module.specifier.clone(), MediaType::Dmts)))
+    }
    Some(Module::Npm(module)) => {
      if let Some(npm) = &state.maybe_npm.as_ref() {
        let package_folder = npm
@ -901,8 +905,8 @@ fn resolve_graph_specifier_types(
            &package_folder,
            module.nv_reference.sub_path(),
            Some(referrer),
-            referrer_kind,
-            NodeResolutionMode::Types,
+            resolution_mode,
+            NodeResolutionKind::Types,
          );
        let maybe_url = match res_result {
          Ok(url) => Some(url),
@ -942,7 +946,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)>,
@ -960,8 +964,8 @@ fn resolve_non_graph_specifier_types(
        .resolve(
          raw_specifier,
          referrer,
-          referrer_kind,
-          NodeResolutionMode::Types,
+          resolution_mode,
+          NodeResolutionKind::Types,
        )
        .ok()
        .map(|res| res.into_url()),
@ -969,7 +973,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
@ -981,8 +985,8 @@ fn resolve_non_graph_specifier_types(
      &package_folder,
      npm_req_ref.sub_path(),
      Some(referrer),
-      referrer_kind,
-      NodeResolutionMode::Types,
+      resolution_mode,
+      NodeResolutionKind::Types,
    );
    let maybe_url = match res_result {
      Ok(url) => Some(url),
@ -1196,7 +1200,7 @@ mod tests {
        .context("Unable to get CWD")
        .unwrap(),
    );
-    let mut op_state = OpState::new(None);
+    let mut op_state = OpState::new(None, None);
    op_state.put(state);
    op_state
  }
@ -1381,8 +1385,7 @@ mod tests {
      &mut state,
      ResolveArgs {
        base: "https://deno.land/x/a.ts".to_string(),
-        is_base_cjs: false,
-        specifiers: vec!["./b.ts".to_string()],
+        specifiers: vec![(false, "./b.ts".to_string())],
      },
    )
    .expect("should have invoked op");
@ -1401,8 +1404,7 @@ mod tests {
      &mut state,
      ResolveArgs {
        base: "https://deno.land/x/a.ts".to_string(),
-        is_base_cjs: false,
-        specifiers: vec!["./bad.ts".to_string()],
+        specifiers: vec![(false, "./bad.ts".to_string())],
      },
    )
    .expect("should have not errored");
--- a/cli/util/file_watcher.rs
+++ b/cli/util/file_watcher.rs
@ -127,19 +127,12 @@ impl PrintConfig {
  }
 }

-fn create_print_after_restart_fn(
-  banner: &'static str,
-  clear_screen: bool,
-) -> impl Fn() {
+fn create_print_after_restart_fn(clear_screen: bool) -> impl Fn() {
  move || {
    #[allow(clippy::print_stderr)]
    if clear_screen && std::io::stderr().is_terminal() {
      eprint!("{}", CLEAR_SCREEN);
    }
-    info!(
-      "{} File change detected! Restarting!",
-      colors::intense_blue(banner),
-    );
  }
 }

@ -187,7 +180,17 @@ impl WatcherCommunicator {
  }

  pub fn print(&self, msg: String) {
-    log::info!("{} {}", self.banner, msg);
+    log::info!("{} {}", self.banner, colors::gray(msg));
+  }
+
+  pub fn show_path_changed(&self, changed_paths: Option<Vec<PathBuf>>) {
+    if let Some(paths) = changed_paths {
+      if !paths.is_empty() {
+        self.print(format!("Restarting! File change detected: {:?}", paths[0]))
+      } else {
+        self.print("Restarting! File change detected.".to_string())
+      }
+    }
  }
 }

@ -263,7 +266,7 @@ where
    clear_screen,
  } = print_config;

-  let print_after_restart = create_print_after_restart_fn(banner, clear_screen);
+  let print_after_restart = create_print_after_restart_fn(clear_screen);
  let watcher_communicator = Arc::new(WatcherCommunicator {
    paths_to_watch_tx: paths_to_watch_tx.clone(),
    changed_paths_rx: changed_paths_rx.resubscribe(),
--- 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/util/path.rs
+++ b/cli/util/path.rs
@ -27,7 +27,16 @@ pub fn is_importable_ext(path: &Path) -> bool {
  if let Some(ext) = get_extension(path) {
    matches!(
      ext.as_str(),
-      "ts" | "tsx" | "js" | "jsx" | "mjs" | "mts" | "cjs" | "cts" | "json"
+      "ts"
+        | "tsx"
+        | "js"
+        | "jsx"
+        | "mjs"
+        | "mts"
+        | "cjs"
+        | "cts"
+        | "json"
+        | "wasm"
    )
  } else {
    false
@ -222,6 +231,7 @@ mod test {
    assert!(is_script_ext(Path::new("foo.cjs")));
    assert!(is_script_ext(Path::new("foo.cts")));
    assert!(!is_script_ext(Path::new("foo.json")));
+    assert!(!is_script_ext(Path::new("foo.wasm")));
    assert!(!is_script_ext(Path::new("foo.mjsx")));
  }

@ -243,6 +253,7 @@ mod test {
    assert!(is_importable_ext(Path::new("foo.cjs")));
    assert!(is_importable_ext(Path::new("foo.cts")));
    assert!(is_importable_ext(Path::new("foo.json")));
+    assert!(is_importable_ext(Path::new("foo.wasm")));
    assert!(!is_importable_ext(Path::new("foo.mjsx")));
  }

--- a/cli/util/text_encoding.rs
+++ b/cli/util/text_encoding.rs
@ -11,6 +11,15 @@ use deno_core::ModuleSourceCode;
 static SOURCE_MAP_PREFIX: &[u8] =
  b"//# sourceMappingURL=data:application/json;base64,";

+#[inline(always)]
+pub fn from_utf8_lossy_cow(bytes: Cow<[u8]>) -> Cow<str> {
+  match bytes {
+    Cow::Borrowed(bytes) => String::from_utf8_lossy(bytes),
+    Cow::Owned(bytes) => Cow::Owned(from_utf8_lossy_owned(bytes)),
+  }
+}
+
+#[inline(always)]
 pub fn from_utf8_lossy_owned(bytes: Vec<u8>) -> String {
  match String::from_utf8_lossy(&bytes) {
    Cow::Owned(code) => code,
--- 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::NodeResolutionMode;
+use node_resolver::NodeResolutionKind;
+use node_resolver::ResolutionMode;
 use tokio::select;

 use crate::args::CliLockfile;
@ -83,6 +83,15 @@ pub trait HmrRunner: Send + Sync {
  async fn run(&mut self) -> Result<(), AnyError>;
 }

+pub trait CliCodeCache: code_cache::CodeCache {
+  /// Gets if the code cache is still enabled.
+  fn enabled(&self) -> bool {
+    true
+  }
+
+  fn as_code_cache(self: Arc<Self>) -> Arc<dyn code_cache::CodeCache>;
+}
+
 #[async_trait::async_trait(?Send)]
 pub trait CoverageCollector: Send + Sync {
  async fn start_collecting(&mut self) -> Result<(), AnyError>;
@ -127,7 +136,7 @@ pub struct CliMainWorkerOptions {
 struct SharedWorkerState {
  blob_store: Arc<BlobStore>,
  broadcast_channel: InMemoryBroadcastChannel,
-  code_cache: Option<Arc<dyn code_cache::CodeCache>>,
+  code_cache: Option<Arc<dyn CliCodeCache>>,
  compiled_wasm_module_store: CompiledWasmModuleStore,
  feature_checker: Arc<FeatureChecker>,
  fs: Arc<dyn deno_fs::FileSystem>,
@ -384,6 +393,13 @@ impl CliMainWorker {
  }
 }

+// TODO(bartlomieju): this should be moved to some other place, added to avoid string
+// duplication between worker setups and `deno info` output.
+pub fn get_cache_storage_dir() -> PathBuf {
+  // Note: we currently use temp_dir() to avoid managing storage size.
+  std::env::temp_dir().join("deno_cache")
+}
+
 #[derive(Clone)]
 pub struct CliMainWorkerFactory {
  shared: Arc<SharedWorkerState>,
@ -393,7 +409,7 @@ impl CliMainWorkerFactory {
  #[allow(clippy::too_many_arguments)]
  pub fn new(
    blob_store: Arc<BlobStore>,
-    code_cache: Option<Arc<dyn code_cache::CodeCache>>,
+    code_cache: Option<Arc<dyn CliCodeCache>>,
    feature_checker: Arc<FeatureChecker>,
    fs: Arc<dyn deno_fs::FileSystem>,
    maybe_file_watcher_communicator: Option<Arc<WatcherCommunicator>>,
@ -520,10 +536,7 @@ impl CliMainWorkerFactory {
    });
    let cache_storage_dir = maybe_storage_key.map(|key| {
      // TODO(@satyarohith): storage quota management
-      // Note: we currently use temp_dir() to avoid managing storage size.
-      std::env::temp_dir()
-        .join("deno_cache")
-        .join(checksum::gen(&[key.as_bytes()]))
+      get_cache_storage_dir().join(checksum::gen(&[key.as_bytes()]))
    });

    // TODO(bartlomieju): this is cruft, update FeatureChecker to spit out
@ -547,13 +560,14 @@ impl CliMainWorkerFactory {
      npm_process_state_provider: Some(shared.npm_process_state_provider()),
      blob_store: shared.blob_store.clone(),
      broadcast_channel: shared.broadcast_channel.clone(),
+      fetch_dns_resolver: Default::default(),
      shared_array_buffer_store: Some(shared.shared_array_buffer_store.clone()),
      compiled_wasm_module_store: Some(
        shared.compiled_wasm_module_store.clone(),
      ),
      feature_checker,
      permissions,
-      v8_code_cache: shared.code_cache.clone(),
+      v8_code_cache: shared.code_cache.clone().map(|c| c.as_code_cache()),
    };

    let options = WorkerOptions {
@ -603,6 +617,8 @@ impl CliMainWorkerFactory {
      origin_storage_dir,
      stdio,
      skip_op_registration: shared.options.skip_op_registration,
+      enable_stack_trace_arg_in_ops: crate::args::has_trace_permissions_enabled(
+      ),
    };

    let mut worker = MainWorker::bootstrap_from_options(
@ -682,8 +698,8 @@ impl CliMainWorkerFactory {
        package_folder,
        sub_path,
        /* referrer */ None,
-        NodeModuleKind::Esm,
-        NodeResolutionMode::Execution,
+        ResolutionMode::Import,
+        NodeResolutionKind::Execution,
      )?;
    if specifier
      .to_file_path()
@ -719,10 +735,7 @@ fn create_web_worker_callback(
      .resolve_storage_key(&args.main_module);
    let cache_storage_dir = maybe_storage_key.map(|key| {
      // TODO(@satyarohith): storage quota management
-      // Note: we currently use temp_dir() to avoid managing storage size.
-      std::env::temp_dir()
-        .join("deno_cache")
-        .join(checksum::gen(&[key.as_bytes()]))
+      get_cache_storage_dir().join(checksum::gen(&[key.as_bytes()]))
    });

    // TODO(bartlomieju): this is cruft, update FeatureChecker to spit out
@ -802,6 +815,8 @@ fn create_web_worker_callback(
      strace_ops: shared.options.strace_ops.clone(),
      close_on_idle: args.close_on_idle,
      maybe_worker_metadata: args.maybe_worker_metadata,
+      enable_stack_trace_arg_in_ops: crate::args::has_trace_permissions_enabled(
+      ),
    };

    WebWorker::bootstrap_from_options(services, options)
@ -855,6 +870,7 @@ mod tests {
        node_services: Default::default(),
        npm_process_state_provider: Default::default(),
        root_cert_store_provider: Default::default(),
+        fetch_dns_resolver: Default::default(),
        shared_array_buffer_store: Default::default(),
        compiled_wasm_module_store: Default::default(),
        v8_code_cache: Default::default(),
--- a/ext/broadcast_channel/Cargo.toml
+++ b/ext/broadcast_channel/Cargo.toml
@ -2,7 +2,7 @@

 [package]
 name = "deno_broadcast_channel"
-version = "0.171.0"
+version = "0.174.0"
 authors.workspace = true
 edition.workspace = true
 license.workspace = true
--- a/ext/cache/Cargo.toml
+++ b/ext/cache/Cargo.toml
@ -2,7 +2,7 @@

 [package]
 name = "deno_cache"
-version = "0.109.0"
+version = "0.112.0"
 authors.workspace = true
 edition.workspace = true
 license.workspace = true
--- a/ext/cache/sqlite.rs
+++ b/ext/cache/sqlite.rs
@ -8,6 +8,7 @@ use std::time::SystemTime;
 use std::time::UNIX_EPOCH;

 use async_trait::async_trait;
+use deno_core::anyhow::Context;
 use deno_core::error::AnyError;
 use deno_core::futures::future::poll_fn;
 use deno_core::parking_lot::Mutex;
@ -45,7 +46,13 @@ impl SqliteBackedCache {
  pub fn new(cache_storage_dir: PathBuf) -> Result<Self, CacheError> {
    {
      std::fs::create_dir_all(&cache_storage_dir)
-        .expect("failed to create cache dir");
+        .with_context(|| {
+          format!(
+            "Failed to create cache storage directory {}",
+            cache_storage_dir.display()
+          )
+        })
+        .map_err(CacheError::Other)?;
      let path = cache_storage_dir.join("cache_metadata.db");
      let connection = rusqlite::Connection::open(&path).unwrap_or_else(|_| {
        panic!("failed to open cache db at {}", path.display())
--- a/ext/canvas/Cargo.toml
+++ b/ext/canvas/Cargo.toml
@ -2,7 +2,7 @@

 [package]
 name = "deno_canvas"
-version = "0.46.0"
+version = "0.49.0"
 authors.workspace = true
 edition.workspace = true
 license.workspace = true
--- a/ext/console/Cargo.toml
+++ b/ext/console/Cargo.toml
@ -2,7 +2,7 @@

 [package]
 name = "deno_console"
-version = "0.177.0"
+version = "0.180.0"
 authors.workspace = true
 edition.workspace = true
 license.workspace = true
--- a/ext/console/internal.d.ts
+++ b/ext/console/internal.d.ts
@ -9,4 +9,7 @@ declare module "ext:deno_console/01_console.js" {
    keys: (keyof TObject)[];
    evaluate: boolean;
  }): Record<string, unknown>;
+
+  class Console {
+  }
 }
--- a/ext/cron/Cargo.toml
+++ b/ext/cron/Cargo.toml
@ -2,7 +2,7 @@

 [package]
 name = "deno_cron"
-version = "0.57.0"
+version = "0.60.0"
 authors.workspace = true
 edition.workspace = true
 license.workspace = true
--- a/ext/crypto/Cargo.toml
+++ b/ext/crypto/Cargo.toml
@ -2,7 +2,7 @@

 [package]
 name = "deno_crypto"
-version = "0.191.0"
+version = "0.194.0"
 authors.workspace = true
 edition.workspace = true
 license.workspace = true
--- a/ext/fetch/22_body.js
+++ b/ext/fetch/22_body.js
@ -15,6 +15,7 @@ import { core, primordials } from "ext:core/mod.js";
 const {
  isAnyArrayBuffer,
  isArrayBuffer,
+  isStringObject,
 } = core;
 const {
  ArrayBufferIsView,
@ -285,8 +286,13 @@ function mixinBody(prototype, bodySymbol, mimeTypeSymbol) {
       */
      get() {
        webidl.assertBranded(this, prototype);
-        if (this[bodySymbol] !== null) {
-          return this[bodySymbol].consumed();
+        try {
+          if (this[bodySymbol] !== null) {
+            return this[bodySymbol].consumed();
+          }
+        } catch (_) {
+          // Request is closed.
+          return true;
        }
        return false;
      },
@ -466,6 +472,8 @@ function extractBody(object) {
    if (object.locked || isReadableStreamDisturbed(object)) {
      throw new TypeError("ReadableStream is locked or disturbed");
    }
+  } else if (object[webidl.AsyncIterable] === webidl.AsyncIterable) {
+    stream = ReadableStream.from(object.open());
  }
  if (typeof source === "string") {
    // WARNING: this deviates from spec (expects length to be set)
@ -483,6 +491,9 @@ function extractBody(object) {
  return { body, contentType };
 }

+webidl.converters["async iterable<Uint8Array>"] = webidl
+  .createAsyncIterableConverter(webidl.converters.Uint8Array);
+
 webidl.converters["BodyInit_DOMString"] = (V, prefix, context, opts) => {
  // Union for (ReadableStream or Blob or ArrayBufferView or ArrayBuffer or FormData or URLSearchParams or USVString)
  if (ObjectPrototypeIsPrototypeOf(ReadableStreamPrototype, V)) {
@ -501,6 +512,14 @@ webidl.converters["BodyInit_DOMString"] = (V, prefix, context, opts) => {
    if (ArrayBufferIsView(V)) {
      return webidl.converters["ArrayBufferView"](V, prefix, context, opts);
    }
+    if (webidl.isAsyncIterable(V) && !isStringObject(V)) {
+      return webidl.converters["async iterable<Uint8Array>"](
+        V,
+        prefix,
+        context,
+        opts,
+      );
+    }
  }
  // BodyInit conversion is passed to extractBody(), which calls core.encode().
  // core.encode() will UTF-8 encode strings with replacement, being equivalent to the USV normalization.
--- 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.
-  // We reconnect it by assigning the result of that dispatch to `opPromise`,
-  // awaiting `opPromise` in an inner function also named `fetch()` and
-  // returning the result from that.
-  let opPromise = undefined;
-  // 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;
+  let span;
+  try {
+    if (TRACING_ENABLED) {
+      span = new Span("fetch", { kind: 2 });
+      enterSpan(span);
    }

-    // 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);
+    // There is an async dispatch later that causes a stack trace disconnect.
+    // We reconnect it by assigning the result of that dispatch to `opPromise`,
+    // awaiting `opPromise` in an inner function also named `fetch()` and
+    // returning the result from that.
+    let opPromise = undefined;
+    // 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);

-    if (!requestObject.headers.has("Accept")) {
-      ArrayPrototypePush(request.headerList, ["Accept", "*/*"]);
-    }
+      if (span) {
+        updateSpanFromRequest(span, requestObject);
+      }

-    if (!requestObject.headers.has("Accept-Language")) {
-      ArrayPrototypePush(request.headerList, ["Accept-Language", "*"]);
-    }
+      // 3.
+      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.
-    opPromise = PromisePrototypeCatch(
-      PromisePrototypeThen(
-        mainFetch(request, false, requestObject.signal),
-        (response) => {
-          // 12.1.
-          if (locallyAborted) return;
-          // 12.2.
-          if (response.aborted) {
-            reject(
-              abortFetch(
-                request,
-                responseObject,
-                requestObject.signal.reason,
-              ),
-            );
+      if (!requestObject.headers.has("Accept")) {
+        ArrayPrototypePush(request.headerList, ["Accept", "*/*"]);
+      }
+
+      if (!requestObject.headers.has("Accept-Language")) {
+        ArrayPrototypePush(request.headerList, ["Accept-Language", "*"]);
+      }
+
+      // 12.
+      opPromise = PromisePrototypeCatch(
+        PromisePrototypeThen(
+          mainFetch(request, false, requestObject.signal),
+          (response) => {
+            // 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.
-          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");
-          resolve(responseObject);
+          },
+        ),
+        (err) => {
+          reject(err);
          requestObject.signal[abortSignal.remove](onabort);
        },
-      ),
-      (err) => {
-        reject(err);
-        requestObject.signal[abortSignal.remove](onabort);
-      },
-    );
-  });
-  if (opPromise) {
-    PromisePrototypeCatch(result, () => {});
-    return (async function fetch() {
-      await opPromise;
-      return result;
-    })();
+      );
+    });
+
+    if (opPromise) {
+      PromisePrototypeCatch(result, () => {});
+      return (async function fetch() {
+        try {
+          await opPromise;
+          return result;
+        } finally {
+          if (span) {
+            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/Cargo.toml
+++ b/ext/fetch/Cargo.toml
@ -2,7 +2,7 @@

 [package]
 name = "deno_fetch"
-version = "0.201.0"
+version = "0.204.0"
 authors.workspace = true
 edition.workspace = true
 license.workspace = true
@ -22,6 +22,7 @@ deno_permissions.workspace = true
 deno_tls.workspace = true
 dyn-clone = "1"
 error_reporter = "1"
+hickory-resolver.workspace = true
 http.workspace = true
 http-body-util.workspace = true
 hyper.workspace = true
--- a/ext/fetch/dns.rs
+++ b/ext/fetch/dns.rs
@ -0,0 +1,116 @@
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+use std::future::Future;
+use std::io;
+use std::net::SocketAddr;
+use std::pin::Pin;
+use std::task::Poll;
+use std::task::{self};
+use std::vec;
+
+use hickory_resolver::error::ResolveError;
+use hickory_resolver::name_server::GenericConnector;
+use hickory_resolver::name_server::TokioRuntimeProvider;
+use hickory_resolver::AsyncResolver;
+use hyper_util::client::legacy::connect::dns::GaiResolver;
+use hyper_util::client::legacy::connect::dns::Name;
+use tokio::task::JoinHandle;
+use tower::Service;
+
+#[derive(Clone, Debug)]
+pub enum Resolver {
+  /// A resolver using blocking `getaddrinfo` calls in a threadpool.
+  Gai(GaiResolver),
+  /// hickory-resolver's userspace resolver.
+  Hickory(AsyncResolver<GenericConnector<TokioRuntimeProvider>>),
+}
+
+impl Default for Resolver {
+  fn default() -> Self {
+    Self::gai()
+  }
+}
+
+impl Resolver {
+  pub fn gai() -> Self {
+    Self::Gai(GaiResolver::new())
+  }
+
+  /// Create a [`AsyncResolver`] from system conf.
+  pub fn hickory() -> Result<Self, ResolveError> {
+    Ok(Self::Hickory(
+      hickory_resolver::AsyncResolver::tokio_from_system_conf()?,
+    ))
+  }
+
+  pub fn hickory_from_async_resolver(
+    resolver: AsyncResolver<GenericConnector<TokioRuntimeProvider>>,
+  ) -> Self {
+    Self::Hickory(resolver)
+  }
+}
+
+type SocketAddrs = vec::IntoIter<SocketAddr>;
+
+pub struct ResolveFut {
+  inner: JoinHandle<Result<SocketAddrs, io::Error>>,
+}
+
+impl Future for ResolveFut {
+  type Output = Result<SocketAddrs, io::Error>;
+
+  fn poll(
+    mut self: Pin<&mut Self>,
+    cx: &mut task::Context<'_>,
+  ) -> Poll<Self::Output> {
+    Pin::new(&mut self.inner).poll(cx).map(|res| match res {
+      Ok(Ok(addrs)) => Ok(addrs),
+      Ok(Err(e)) => Err(e),
+      Err(join_err) => {
+        if join_err.is_cancelled() {
+          Err(io::Error::new(io::ErrorKind::Interrupted, join_err))
+        } else {
+          Err(io::Error::new(io::ErrorKind::Other, join_err))
+        }
+      }
+    })
+  }
+}
+
+impl Service<Name> for Resolver {
+  type Response = SocketAddrs;
+  type Error = io::Error;
+  type Future = ResolveFut;
+
+  fn poll_ready(
+    &mut self,
+    _cx: &mut task::Context<'_>,
+  ) -> Poll<Result<(), io::Error>> {
+    Poll::Ready(Ok(()))
+  }
+
+  fn call(&mut self, name: Name) -> Self::Future {
+    let task = match self {
+      Resolver::Gai(gai_resolver) => {
+        let mut resolver = gai_resolver.clone();
+        tokio::spawn(async move {
+          let result = resolver.call(name).await?;
+          let x: Vec<_> = result.into_iter().collect();
+          let iter: SocketAddrs = x.into_iter();
+          Ok(iter)
+        })
+      }
+      Resolver::Hickory(async_resolver) => {
+        let resolver = async_resolver.clone();
+        tokio::spawn(async move {
+          let result = resolver.lookup_ip(name.as_str()).await?;
+
+          let x: Vec<_> =
+            result.into_iter().map(|x| SocketAddr::new(x, 0)).collect();
+          let iter: SocketAddrs = x.into_iter();
+          Ok(iter)
+        })
+      }
+    };
+    ResolveFut { inner: task }
+  }
+}
--- a/ext/fetch/lib.deno_fetch.d.ts
+++ b/ext/fetch/lib.deno_fetch.d.ts
@ -163,6 +163,8 @@ type BodyInit =
  | FormData
  | URLSearchParams
  | ReadableStream<Uint8Array>
+  | Iterable<Uint8Array>
+  | AsyncIterable<Uint8Array>
  | string;
 /** @category Fetch */
 type RequestDestination =
--- a/ext/fetch/lib.rs
+++ b/ext/fetch/lib.rs
@ -1,5 +1,6 @@
 // Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.

+pub mod dns;
 mod fs_fetch_handler;
 mod proxy;
 #[cfg(test)]
@ -26,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;
@ -66,6 +68,7 @@ use http_body_util::BodyExt;
 use hyper::body::Frame;
 use hyper_util::client::legacy::connect::HttpConnector;
 use hyper_util::client::legacy::connect::HttpInfo;
+use hyper_util::client::legacy::Builder as HyperClientBuilder;
 use hyper_util::rt::TokioExecutor;
 use hyper_util::rt::TokioTimer;
 use serde::Deserialize;
@ -84,6 +87,16 @@ pub struct Options {
  pub user_agent: String,
  pub root_cert_store_provider: Option<Arc<dyn RootCertStoreProvider>>,
  pub proxy: Option<Proxy>,
+  /// A callback to customize HTTP client configuration.
+  ///
+  /// The settings applied with this hook may be overridden by the options
+  /// provided through `Deno.createHttpClient()` API. For instance, if the hook
+  /// calls [`hyper_util::client::legacy::Builder::pool_max_idle_per_host`] with
+  /// a value of 99, and a user calls `Deno.createHttpClient({ poolMaxIdlePerHost: 42 })`,
+  /// the value that will take effect is 42.
+  ///
+  /// For more info on what can be configured, see [`hyper_util::client::legacy::Builder`].
+  pub client_builder_hook: Option<fn(HyperClientBuilder) -> HyperClientBuilder>,
  #[allow(clippy::type_complexity)]
  pub request_builder_hook: Option<
    fn(&mut http::Request<ReqBody>) -> Result<(), deno_core::error::AnyError>,
@ -91,6 +104,7 @@ pub struct Options {
  pub unsafely_ignore_certificate_errors: Option<Vec<String>>,
  pub client_cert_chain_and_key: TlsKeys,
  pub file_fetch_handler: Rc<dyn FetchHandler>,
+  pub resolver: dns::Resolver,
 }

 impl Options {
@ -110,10 +124,12 @@ impl Default for Options {
      user_agent: "".to_string(),
      root_cert_store_provider: None,
      proxy: None,
+      client_builder_hook: None,
      request_builder_hook: None,
      unsafely_ignore_certificate_errors: None,
      client_cert_chain_and_key: TlsKeys::Null,
      file_fetch_handler: Rc::new(DefaultFileFetchHandler),
+      resolver: dns::Resolver::default(),
    }
  }
 }
@ -126,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",
@ -255,6 +272,7 @@ pub fn create_client_from_options(
        .map_err(HttpClientCreateError::RootCertStore)?,
      ca_certs: vec![],
      proxy: options.proxy.clone(),
+      dns_resolver: options.resolver.clone(),
      unsafely_ignore_certificate_errors: options
        .unsafely_ignore_certificate_errors
        .clone(),
@ -267,6 +285,7 @@ pub fn create_client_from_options(
      pool_idle_timeout: None,
      http1: true,
      http2: true,
+      client_builder_hook: options.client_builder_hook,
    },
  )
 }
@ -380,7 +399,7 @@ impl FetchPermissions for deno_permissions::PermissionsContainer {
  }
 }

-#[op2]
+#[op2(stack_trace)]
 #[serde]
 #[allow(clippy::too_many_arguments)]
 pub fn op_fetch<FP>(
@ -835,6 +854,8 @@ pub struct CreateHttpClientArgs {
  proxy: Option<Proxy>,
  pool_max_idle_per_host: Option<usize>,
  pool_idle_timeout: Option<serde_json::Value>,
+  #[serde(default)]
+  use_hickory_resolver: bool,
  #[serde(default = "default_true")]
  http1: bool,
  #[serde(default = "default_true")]
@ -847,7 +868,7 @@ fn default_true() -> bool {
  true
 }

-#[op2]
+#[op2(stack_trace)]
 #[smi]
 pub fn op_fetch_custom_client<FP>(
  state: &mut OpState,
@ -878,6 +899,13 @@ where
        .map_err(HttpClientCreateError::RootCertStore)?,
      ca_certs,
      proxy: args.proxy,
+      dns_resolver: if args.use_hickory_resolver {
+        dns::Resolver::hickory()
+          .map_err(deno_core::error::AnyError::new)
+          .map_err(FetchError::Resource)?
+      } else {
+        dns::Resolver::default()
+      },
      unsafely_ignore_certificate_errors: options
        .unsafely_ignore_certificate_errors
        .clone(),
@ -895,6 +923,7 @@ where
      ),
      http1: args.http1,
      http2: args.http2,
+      client_builder_hook: options.client_builder_hook,
    },
  )?;

@ -909,12 +938,14 @@ pub struct CreateHttpClientOptions {
  pub root_cert_store: Option<RootCertStore>,
  pub ca_certs: Vec<Vec<u8>>,
  pub proxy: Option<Proxy>,
+  pub dns_resolver: dns::Resolver,
  pub unsafely_ignore_certificate_errors: Option<Vec<String>>,
  pub client_cert_chain_and_key: Option<TlsKey>,
  pub pool_max_idle_per_host: Option<usize>,
  pub pool_idle_timeout: Option<Option<u64>>,
  pub http1: bool,
  pub http2: bool,
+  pub client_builder_hook: Option<fn(HyperClientBuilder) -> HyperClientBuilder>,
 }

 impl Default for CreateHttpClientOptions {
@ -923,12 +954,14 @@ impl Default for CreateHttpClientOptions {
      root_cert_store: None,
      ca_certs: vec![],
      proxy: None,
+      dns_resolver: dns::Resolver::default(),
      unsafely_ignore_certificate_errors: None,
      client_cert_chain_and_key: None,
      pool_max_idle_per_host: None,
      pool_idle_timeout: None,
      http1: true,
      http2: true,
+      client_builder_hook: None,
    }
  }
 }
@ -976,18 +1009,22 @@ pub fn create_http_client(
  tls_config.alpn_protocols = alpn_protocols;
  let tls_config = Arc::from(tls_config);

-  let mut http_connector = HttpConnector::new();
+  let mut http_connector =
+    HttpConnector::new_with_resolver(options.dns_resolver.clone());
  http_connector.enforce_http(false);

  let user_agent = user_agent.parse::<HeaderValue>().map_err(|_| {
    HttpClientCreateError::InvalidUserAgent(user_agent.to_string())
  })?;

-  let mut builder =
-    hyper_util::client::legacy::Builder::new(TokioExecutor::new());
+  let mut builder = HyperClientBuilder::new(TokioExecutor::new());
  builder.timer(TokioTimer::new());
  builder.pool_timer(TokioTimer::new());

+  if let Some(client_builder_hook) = options.client_builder_hook {
+    builder = client_builder_hook(builder);
+  }
+
  let mut proxies = proxy::from_env();
  if let Some(proxy) = options.proxy {
    let mut intercept = proxy::Intercept::all(&proxy.url)
@ -1051,7 +1088,7 @@ pub struct Client {
  user_agent: HeaderValue,
 }

-type Connector = proxy::ProxyConnector<HttpConnector>;
+type Connector = proxy::ProxyConnector<HttpConnector<dns::Resolver>>;

 // clippy is wrong here
 #[allow(clippy::declare_interior_mutable_const)]
@ -1171,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/fetch/tests.rs
+++ b/ext/fetch/tests.rs
@ -1,6 +1,8 @@
 // Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.

 use std::net::SocketAddr;
+use std::sync::atomic::AtomicUsize;
+use std::sync::atomic::Ordering::SeqCst;
 use std::sync::Arc;

 use bytes::Bytes;
@ -10,6 +12,8 @@ use http_body_util::BodyExt;
 use tokio::io::AsyncReadExt;
 use tokio::io::AsyncWriteExt;

+use crate::dns;
+
 use super::create_http_client;
 use super::CreateHttpClientOptions;

@ -17,6 +21,53 @@ static EXAMPLE_CRT: &[u8] = include_bytes!("../tls/testdata/example1_cert.der");
 static EXAMPLE_KEY: &[u8] =
  include_bytes!("../tls/testdata/example1_prikey.der");

+#[test]
+fn test_userspace_resolver() {
+  let thread_counter = Arc::new(AtomicUsize::new(0));
+
+  let thread_counter_ref = thread_counter.clone();
+  let rt = tokio::runtime::Builder::new_current_thread()
+    .enable_all()
+    .on_thread_start(move || {
+      thread_counter_ref.fetch_add(1, SeqCst);
+    })
+    .build()
+    .unwrap();
+
+  rt.block_on(async move {
+    assert_eq!(thread_counter.load(SeqCst), 0);
+    let src_addr = create_https_server(true).await;
+    assert_eq!(src_addr.ip().to_string(), "127.0.0.1");
+    // use `localhost` to ensure dns step happens.
+    let addr = format!("localhost:{}", src_addr.port());
+
+    let hickory = hickory_resolver::AsyncResolver::tokio(
+      Default::default(),
+      Default::default(),
+    );
+
+    assert_eq!(thread_counter.load(SeqCst), 0);
+    rust_test_client_with_resolver(
+      None,
+      addr.clone(),
+      "https",
+      http::Version::HTTP_2,
+      dns::Resolver::hickory_from_async_resolver(hickory),
+    )
+    .await;
+    assert_eq!(thread_counter.load(SeqCst), 0, "userspace resolver shouldn't spawn new threads.");
+    rust_test_client_with_resolver(
+      None,
+      addr.clone(),
+      "https",
+      http::Version::HTTP_2,
+      dns::Resolver::gai(),
+    )
+    .await;
+    assert_eq!(thread_counter.load(SeqCst), 1, "getaddrinfo is called inside spawn_blocking, so tokio spawn a new worker thread for it.");
+  });
+}
+
 #[tokio::test]
 async fn test_https_proxy_http11() {
  let src_addr = create_https_server(false).await;
@ -52,27 +103,30 @@ async fn test_socks_proxy_h2() {
  run_test_client(prx_addr, src_addr, "socks5", http::Version::HTTP_2).await;
 }

-async fn run_test_client(
-  prx_addr: SocketAddr,
-  src_addr: SocketAddr,
+async fn rust_test_client_with_resolver(
+  prx_addr: Option<SocketAddr>,
+  src_addr: String,
  proto: &str,
  ver: http::Version,
+  resolver: dns::Resolver,
 ) {
  let client = create_http_client(
    "fetch/test",
    CreateHttpClientOptions {
      root_cert_store: None,
      ca_certs: vec![],
-      proxy: Some(deno_tls::Proxy {
-        url: format!("{}://{}", proto, prx_addr),
+      proxy: prx_addr.map(|p| deno_tls::Proxy {
+        url: format!("{}://{}", proto, p),
        basic_auth: None,
      }),
      unsafely_ignore_certificate_errors: Some(vec![]),
      client_cert_chain_and_key: None,
      pool_max_idle_per_host: None,
      pool_idle_timeout: None,
+      dns_resolver: resolver,
      http1: true,
      http2: true,
+      client_builder_hook: None,
    },
  )
  .unwrap();
@ -92,6 +146,22 @@ async fn run_test_client(
  assert_eq!(hello, "hello from server");
 }

+async fn run_test_client(
+  prx_addr: SocketAddr,
+  src_addr: SocketAddr,
+  proto: &str,
+  ver: http::Version,
+) {
+  rust_test_client_with_resolver(
+    Some(prx_addr),
+    src_addr.to_string(),
+    proto,
+    ver,
+    Default::default(),
+  )
+  .await
+}
+
 async fn create_https_server(allow_h2: bool) -> SocketAddr {
  let mut tls_config = deno_tls::rustls::server::ServerConfig::builder()
    .with_no_client_auth()
--- a/Show more
+++ b/Show more