refactor: remove DENO_FUTURE (#25314)

16 files changed, 173 insertions, 332 deletions

diff --git a/cli/Cargo.toml b/cli/Cargo.toml
index 67b7034c9..d2283d5ef 100644
--- a/cli/Cargo.toml
+++ b/cli/Cargo.toml
@@ -65,7 +65,7 @@ winres.workspace = true
 [dependencies]
 deno_ast = { workspace = true, features = ["bundler", "cjs", "codegen", "proposal", "react", "sourcemap", "transforms", "typescript", "view", "visit"] }
 deno_cache_dir = { workspace = true }
-deno_config = { version = "=0.31.0", features = ["workspace", "sync"] }
+deno_config = { version = "=0.32.0", features = ["workspace", "sync"] }
 deno_core = { workspace = true, features = ["include_js_files_for_snapshotting"] }
 deno_doc = { version = "0.148.0", features = ["html", "syntect"] }
 deno_emit = "=0.45.0"
diff --git a/cli/args/flags.rs b/cli/args/flags.rs
index 050d55f4c..a0cf4d7bf 100644
--- a/cli/args/flags.rs
+++ b/cli/args/flags.rs
@@ -10,7 +10,7 @@ use clap::ColorChoice;
 use clap::Command;
 use clap::ValueHint;
 use color_print::cstr;
-use deno_config::deno_json::NodeModulesMode;
+use deno_config::deno_json::NodeModulesDirMode;
 use deno_config::glob::FilePatterns;
 use deno_config::glob::PathOrPatternSet;
 use deno_core::anyhow::bail;
@@ -41,7 +41,6 @@ use crate::args::resolve_no_prompt;
 use crate::util::fs::canonicalize_path;
 
 use super::flags_net;
-use super::DENO_FUTURE;
 
 #[derive(Clone, Debug, Default, Eq, PartialEq)]
 pub enum ConfigFlag {
@@ -580,7 +579,6 @@ fn parse_packages_allowed_scripts(s: &str) -> Result<String, AnyError> {
 pub struct UnstableConfig {
   pub legacy_flag_enabled: bool, // --unstable
   pub bare_node_builtins: bool,  // --unstable-bare-node-builts
-  pub byonm: bool,
   pub sloppy_imports: bool,
   pub features: Vec<String>, // --unstabe-kv --unstable-cron
 }
@@ -602,8 +600,7 @@ pub struct Flags {
   pub cached_only: bool,
   pub type_check_mode: TypeCheckMode,
   pub config_flag: ConfigFlag,
-  pub node_modules_dir: Option<bool>,
-  pub node_modules_mode: Option<NodeModulesMode>,
+  pub node_modules_dir: Option<NodeModulesDirMode>,
   pub vendor: Option<bool>,
   pub enable_op_summary_metrics: bool,
   pub enable_testing_features: bool,
@@ -1114,7 +1111,6 @@ static ENV_VARIABLES_HELP: &str = cstr!(
   <g>DENO_AUTH_TOKENS</>      A semi-colon separated list of bearer tokens and hostnames
                         to use when fetching remote modules from private repositories
                          <p(245)>(e.g. "abcde12345@deno.land;54321edcba@github.com")</>
-  <g>DENO_FUTURE</>           Set to "1" to enable APIs that will take effect in Deno 2
   <g>DENO_CERT</>             Load certificate authorities from PEM encoded file
   <g>DENO_DIR</>              Set the cache directory
   <g>DENO_INSTALL_ROOT</>     Set deno install's output directory
@@ -1508,11 +1504,7 @@ pub fn clap_root() -> Command {
         .subcommand(fmt_subcommand())
         .subcommand(init_subcommand())
         .subcommand(info_subcommand())
-        .subcommand(if *DENO_FUTURE {
-          future_install_subcommand()
-        } else {
-          install_subcommand()
-        })
+        .subcommand(future_install_subcommand())
         .subcommand(json_reference_subcommand())
         .subcommand(jupyter_subcommand())
         .subcommand(uninstall_subcommand())
@@ -2365,7 +2357,7 @@ TypeScript compiler cache: Subdirectory containing TS compiler output.",
       .arg(no_lock_arg())
       .arg(config_arg())
       .arg(import_map_arg())
-      .args(node_modules_args())
+      .arg(node_modules_dir_arg())
       .arg(vendor_arg())
       .arg(
         Arg::new("json")
@@ -2375,22 +2367,13 @@ TypeScript compiler cache: Subdirectory containing TS compiler output.",
       ))
 }
 
-fn install_args(cmd: Command, deno_future: bool) -> Command {
-  let cmd = if deno_future {
-    cmd.arg(
-      Arg::new("cmd")
-        .required_if_eq("global", "true")
-        .num_args(1..)
-        .value_hint(ValueHint::FilePath),
-    )
-  } else {
-    cmd.arg(
-      Arg::new("cmd")
-        .required_unless_present("help")
-        .num_args(1..)
-        .value_hint(ValueHint::FilePath),
-    )
-  };
+fn install_args(cmd: Command) -> Command {
+  let cmd = cmd.arg(
+    Arg::new("cmd")
+      .required_if_eq("global", "true")
+      .num_args(1..)
+      .value_hint(ValueHint::FilePath),
+  );
   cmd
     .arg(
       Arg::new("name")
@@ -2466,40 +2449,7 @@ These must be added to the path manually if required.", UnstableArgsConfig::Reso
     .visible_alias("i")
     .defer(|cmd| {
       let cmd = runtime_args(cmd, true, true).arg(check_arg(true)).arg(allow_scripts_arg());
-      install_args(cmd, true)
-    })
-}
-
-fn install_subcommand() -> Command {
-  command("install",
-      "Installs a script as an executable in the installation root's bin directory.
-
-  deno install --global --allow-net --allow-read jsr:@std/http/file-server
-  deno install -g https://examples.deno.land/color-logging.ts
-
-To change the executable name, use -n/--name:
-  deno install -g --allow-net --allow-read -n serve jsr:@std/http/file-server
-
-The executable name is inferred by default:
-  - Attempt to take the file stem of the URL path. The above example would
-    become 'file_server'.
-  - If the file stem is something generic like 'main', 'mod', 'index' or 'cli',
-    and the path has no parent, take the file name of the parent path. Otherwise
-    settle with the generic name.
-  - If the resulting name has an '@...' suffix, strip it.
-
-To change the installation root, use --root:
-  deno install -g --allow-net --allow-read --root /usr/local jsr:@std/http/file-server
-
-The installation root is determined, in order of precedence:
-  - --root option
-  - DENO_INSTALL_ROOT environment variable
-  - $HOME/.deno
-
-These must be added to the path manually if required.", UnstableArgsConfig::ResolutionAndRuntime)
-    .defer(|cmd| {
-      let cmd = runtime_args(cmd, true, true).arg(check_arg(true));
-      install_args(cmd, false)
+      install_args(cmd)
     })
 }
 
@@ -3180,7 +3130,7 @@ Remote modules and multiple modules may also be specified:
       .arg(config_arg())
       .arg(import_map_arg())
       .arg(lock_arg())
-      .args(node_modules_args())
+      .arg(node_modules_dir_arg())
       .arg(vendor_arg())
       .arg(reload_arg())
       .arg(ca_file_arg())
@@ -3242,7 +3192,7 @@ fn compile_args_without_check_args(app: Command) -> Command {
     .arg(import_map_arg())
     .arg(no_remote_arg())
     .arg(no_npm_arg())
-    .args(node_modules_args())
+    .arg(node_modules_dir_arg())
     .arg(vendor_arg())
     .arg(config_arg())
     .arg(no_config_arg())
@@ -3919,48 +3869,35 @@ fn no_npm_arg() -> Arg {
 }
 
 fn node_modules_arg_parse(flags: &mut Flags, matches: &mut ArgMatches) {
-  if *DENO_FUTURE {
-    let value = matches.remove_one::<NodeModulesMode>("node-modules");
-    if let Some(mode) = value {
-      flags.node_modules_mode = Some(mode);
+  let value = matches.remove_one::<NodeModulesDirMode>("node-modules-dir");
+  if let Some(mode) = value {
+    flags.node_modules_dir = Some(mode);
+  }
+}
+
+fn node_modules_dir_arg() -> Arg {
+  fn parse_node_modules_dir_mode(
+    s: &str,
+  ) -> Result<NodeModulesDirMode, String> {
+    match s {
+      "auto" | "true" => Ok(NodeModulesDirMode::Auto),
+      "manual" => Ok(NodeModulesDirMode::Manual),
+      "none" | "false" => Ok(NodeModulesDirMode::None),
+      _ => Err(format!(
+        "Invalid value '{}': expected \"auto\", \"manual\" or \"none\"",
+        s
+      )),
     }
-  } else {
-    flags.node_modules_dir = matches.remove_one::<bool>("node-modules-dir");
   }
-}
 
-fn node_modules_args() -> Vec<Arg> {
-  if *DENO_FUTURE {
-    vec![
-      Arg::new("node-modules")
-        .long("node-modules")
-        .num_args(0..=1)
-        .value_parser(NodeModulesMode::parse)
-        .value_name("MODE")
-        .require_equals(true)
-        .help("Sets the node modules management mode for npm packages")
-        .help_heading(DEPENDENCY_MANAGEMENT_HEADING),
-      Arg::new("node-modules-dir")
-        .long("node-modules-dir")
-        .num_args(0..=1)
-        .value_parser(clap::builder::UnknownArgumentValueParser::suggest_arg(
-          "--node-modules",
-        ))
-        .require_equals(true),
-    ]
-  } else {
-    vec![
-      Arg::new("node-modules-dir")
-        .long("node-modules-dir")
-        .num_args(0..=1)
-        .value_parser(value_parser!(bool))
-        .value_name("ENABLED")
-        .default_missing_value("true")
-        .require_equals(true)
-        .help("Enables or disables the use of a local node_modules folder for npm packages")
-        .help_heading(DEPENDENCY_MANAGEMENT_HEADING)
-    ]
-  }
+  Arg::new("node-modules-dir")
+    .long("node-modules-dir")
+    .num_args(0..=1)
+    .value_parser(clap::builder::ValueParser::new(parse_node_modules_dir_mode))
+    .value_name("MODE")
+    .require_equals(true)
+    .help("Sets the node modules management mode for npm packages")
+    .help_heading(DEPENDENCY_MANAGEMENT_HEADING)
 }
 
 fn vendor_arg() -> Arg {
@@ -4039,7 +3976,6 @@ impl Iterator for UnstableArgsIter {
       Arg::new("unstable-byonm")
         .long("unstable-byonm")
         .help("Enable unstable 'bring your own node_modules' feature")
-        .env("DENO_UNSTABLE_BYONM")
         .value_parser(FalseyValueParser::new())
         .action(ArgAction::SetTrue)
         .hide(true)
@@ -4476,7 +4412,7 @@ fn install_parse(flags: &mut Flags, matches: &mut ArgMatches) {
   runtime_args_parse(flags, matches, true, true);
 
   let global = matches.get_flag("global");
-  if global || !*DENO_FUTURE {
+  if global {
     let root = matches.remove_one::<String>("root");
     let force = matches.get_flag("force");
     let name = matches.remove_one::<String>("name");
@@ -5422,7 +5358,6 @@ fn unstable_args_parse(
 
   flags.unstable_config.bare_node_builtins =
     matches.get_flag("unstable-bare-node-builtins");
-  flags.unstable_config.byonm = matches.get_flag("unstable-byonm");
   flags.unstable_config.sloppy_imports =
     matches.get_flag("unstable-sloppy-imports");
 
diff --git a/cli/args/lockfile.rs b/cli/args/lockfile.rs
index 3b6bcc2e5..35552b5b4 100644
--- a/cli/args/lockfile.rs
+++ b/cli/args/lockfile.rs
@@ -239,12 +239,6 @@ impl CliLockfile {
     }
     let lockfile = self.lockfile.lock();
     if lockfile.has_content_changed {
-      let suggested = if *super::DENO_FUTURE {
-        "`deno cache --frozen=false`, `deno install --frozen=false`,"
-      } else {
-        "`deno cache --frozen=false`"
-      };
-
       let contents =
         std::fs::read_to_string(&lockfile.filename).unwrap_or_default();
       let new_contents = lockfile.as_json_string();
@@ -252,7 +246,7 @@ impl CliLockfile {
       // has an extra newline at the end
       let diff = diff.trim_end();
       Err(deno_core::anyhow::anyhow!(
-        "The lockfile is out of date. Run {suggested} or rerun with `--frozen=false` to update it.\nchanges:\n{diff}"
+        "The lockfile is out of date. Run `deno cache --frozen=false`, `deno install --frozen=false`, or rerun with `--frozen=false` to update it.\nchanges:\n{diff}"
       ))
     } else {
       Ok(())
diff --git a/cli/args/mod.rs b/cli/args/mod.rs
index de64a5785..89ecc8da7 100644
--- a/cli/args/mod.rs
+++ b/cli/args/mod.rs
@@ -8,8 +8,9 @@ mod lockfile;
 mod package_json;
 
 use deno_ast::SourceMapOption;
-use deno_config::deno_json::NodeModulesMode;
+use deno_config::deno_json::NodeModulesDirMode;
 use deno_config::workspace::CreateResolverOptions;
+use deno_config::workspace::FolderConfigs;
 use deno_config::workspace::PackageJsonDepResolution;
 use deno_config::workspace::VendorEnablement;
 use deno_config::workspace::Workspace;
@@ -51,7 +52,6 @@ use deno_core::anyhow::Context;
 use deno_core::error::AnyError;
 use deno_core::serde_json;
 use deno_core::url::Url;
-use deno_runtime::deno_node::PackageJson;
 use deno_runtime::deno_permissions::PermissionsOptions;
 use deno_runtime::deno_tls::deno_native_certs::load_native_certs;
 use deno_runtime::deno_tls::rustls;
@@ -64,6 +64,7 @@ use dotenvy::from_filename;
 use once_cell::sync::Lazy;
 use serde::Deserialize;
 use serde::Serialize;
+use std::borrow::Cow;
 use std::collections::HashMap;
 use std::env;
 use std::io::BufReader;
@@ -117,9 +118,6 @@ pub static DENO_DISABLE_PEDANTIC_NODE_WARNINGS: Lazy<bool> = Lazy::new(|| {
     .is_some()
 });
 
-// TODO(2.0): remove this in a follow up.
-pub static DENO_FUTURE: Lazy<bool> = Lazy::new(|| true);
-
 pub fn jsr_url() -> &'static Url {
   static JSR_URL: Lazy<Url> = Lazy::new(|| {
     let env_var_name = "JSR_URL";
@@ -814,15 +812,12 @@ impl CliOptions {
     }
 
     let maybe_lockfile = maybe_lockfile.filter(|_| !force_global_cache);
-    let root_folder = start_dir.workspace.root_folder_configs();
     let deno_dir_provider =
       Arc::new(DenoDirProvider::new(flags.cache_path.clone()));
     let maybe_node_modules_folder = resolve_node_modules_folder(
       &initial_cwd,
       &flags,
       &start_dir.workspace,
-      root_folder.deno_json.as_deref(),
-      root_folder.pkg_json.as_deref(),
       &deno_dir_provider,
     )
     .with_context(|| "Resolving node_modules folder.")?;
@@ -919,10 +914,6 @@ impl CliOptions {
     };
 
     for diagnostic in start_dir.workspace.diagnostics() {
-      // TODO(2.0): remove
-      if matches!(diagnostic.kind, deno_config::workspace::WorkspaceDiagnosticKind::DeprecatedNodeModulesDirOption(_)) && !*DENO_FUTURE {
-        continue;
-      }
       log::warn!("{} {}", colors::yellow("Warning"), diagnostic);
     }
 
@@ -1143,10 +1134,6 @@ impl CliOptions {
     self.flags.env_file.as_ref()
   }
 
-  pub fn enable_future_features(&self) -> bool {
-    *DENO_FUTURE
-  }
-
   pub fn resolve_main_module(&self) -> Result<ModuleSpecifier, AnyError> {
     let main_module = match &self.flags.subcommand {
       DenoSubcommand::Bundle(bundle_flags) => {
@@ -1261,29 +1248,13 @@ impl CliOptions {
     }
   }
 
-  pub fn node_modules_mode(&self) -> Result<Option<NodeModulesMode>, AnyError> {
-    if *DENO_FUTURE {
-      if let Some(flag) = self.flags.node_modules_mode {
-        return Ok(Some(flag));
-      }
-      self.workspace().node_modules_mode().map_err(Into::into)
-    } else {
-      Ok(
-        self
-          .flags
-          .node_modules_dir
-          .or_else(|| self.workspace().node_modules_dir())
-          .map(|enabled| {
-            if enabled && self.byonm_enabled() {
-              NodeModulesMode::LocalManual
-            } else if enabled {
-              NodeModulesMode::LocalAuto
-            } else {
-              NodeModulesMode::GlobalAuto
-            }
-          }),
-      )
+  pub fn node_modules_dir(
+    &self,
+  ) -> Result<Option<NodeModulesDirMode>, AnyError> {
+    if let Some(flag) = self.flags.node_modules_dir {
+      return Ok(Some(flag));
     }
+    self.workspace().node_modules_dir_mode().map_err(Into::into)
   }
 
   pub fn vendor_dir_path(&self) -> Option<&PathBuf> {
@@ -1637,17 +1608,15 @@ impl CliOptions {
 
   fn byonm_enabled(&self) -> bool {
     // check if enabled via unstable
-    self.flags.unstable_config.byonm
+    self.node_modules_dir().ok().flatten() == Some(NodeModulesDirMode::Manual)
       || NPM_PROCESS_STATE
         .as_ref()
         .map(|s| matches!(s.kind, NpmProcessStateKind::Byonm))
         .unwrap_or(false)
-      || self.workspace().has_unstable("byonm")
   }
 
   pub fn use_byonm(&self) -> bool {
-    if self.enable_future_features()
-      && self.node_modules_mode().ok().flatten().is_none()
+    if self.node_modules_dir().ok().flatten().is_none()
       && self.maybe_node_modules_folder.is_some()
       && self
         .workspace()
@@ -1680,19 +1649,17 @@ impl CliOptions {
         }
       });
 
-    // TODO(2.0): remove this conditional and enable these features in `99_main.js` by default.
-    if *DENO_FUTURE {
-      let future_features = [
-        deno_runtime::deno_ffi::UNSTABLE_FEATURE_NAME.to_string(),
-        deno_runtime::deno_fs::UNSTABLE_FEATURE_NAME.to_string(),
-        deno_runtime::deno_webgpu::UNSTABLE_FEATURE_NAME.to_string(),
-      ];
-      future_features.iter().for_each(|future_feature| {
-        if !from_config_file.contains(future_feature) {
-          from_config_file.push(future_feature.to_string());
-        }
-      });
-    }
+    // TODO(2.0): remove this code and enable these features in `99_main.js` by default.
+    let future_features = [
+      deno_runtime::deno_ffi::UNSTABLE_FEATURE_NAME.to_string(),
+      deno_runtime::deno_fs::UNSTABLE_FEATURE_NAME.to_string(),
+      deno_runtime::deno_webgpu::UNSTABLE_FEATURE_NAME.to_string(),
+    ];
+    future_features.iter().for_each(|future_feature| {
+      if !from_config_file.contains(future_feature) {
+        from_config_file.push(future_feature.to_string());
+      }
+    });
 
     if !from_config_file.is_empty() {
       // collect unstable granular flags
@@ -1792,54 +1759,54 @@ fn resolve_node_modules_folder(
   cwd: &Path,
   flags: &Flags,
   workspace: &Workspace,
-  maybe_config_file: Option<&ConfigFile>,
-  maybe_package_json: Option<&PackageJson>,
   deno_dir_provider: &Arc<DenoDirProvider>,
 ) -> Result<Option<PathBuf>, AnyError> {
-  let use_node_modules_dir = if *DENO_FUTURE {
-    if let Some(mode) = flags.node_modules_mode {
-      Some(mode.uses_node_modules_dir())
-    } else {
-      workspace
-        .node_modules_mode()?
-        .map(|m| m.uses_node_modules_dir())
-        .or(flags.vendor)
-        .or_else(|| maybe_config_file.and_then(|c| c.json.vendor))
-    }
+  fn resolve_from_root(root_folder: &FolderConfigs, cwd: &Path) -> PathBuf {
+    root_folder
+      .deno_json
+      .as_ref()
+      .map(|c| Cow::Owned(c.dir_path()))
+      .or_else(|| {
+        root_folder
+          .pkg_json
+          .as_ref()
+          .map(|c| Cow::Borrowed(c.dir_path()))
+      })
+      .unwrap_or(Cow::Borrowed(cwd))
+      .join("node_modules")
+  }
+
+  let root_folder = workspace.root_folder_configs();
+  let use_node_modules_dir = if let Some(mode) = flags.node_modules_dir {
+    Some(mode.uses_node_modules_dir())
   } else {
-    flags
-      .node_modules_dir
-      .or_else(|| maybe_config_file.and_then(|c| c.json.node_modules_dir))
+    workspace
+      .node_modules_dir_mode()?
+      .map(|m| m.uses_node_modules_dir())
       .or(flags.vendor)
-      .or_else(|| maybe_config_file.and_then(|c| c.json.vendor))
+      .or_else(|| root_folder.deno_json.as_ref().and_then(|c| c.json.vendor))
   };
   let path = if use_node_modules_dir == Some(false) {
     return Ok(None);
   } else if let Some(state) = &*NPM_PROCESS_STATE {
     return Ok(state.local_node_modules_path.as_ref().map(PathBuf::from));
-  } else if let Some(package_json_path) = maybe_package_json.map(|c| &c.path) {
+  } else if workspace.package_jsons().next().is_some() {
+    let node_modules_dir = resolve_from_root(root_folder, cwd);
     if let Ok(deno_dir) = deno_dir_provider.get_or_create() {
       // `deno_dir.root` can be symlink in macOS
       if let Ok(root) = canonicalize_path_maybe_not_exists(&deno_dir.root) {
-        if package_json_path.starts_with(root) {
+        if node_modules_dir.starts_with(root) {
           // if the package.json is in deno_dir, then do not use node_modules
           // next to it as local node_modules dir
           return Ok(None);
         }
       }
     }
-    // auto-discover the local_node_modules_folder when a package.json exists
-    // and it's not in deno_dir
-    package_json_path.parent().unwrap().join("node_modules")
+    node_modules_dir
   } else if use_node_modules_dir.is_none() {
     return Ok(None);
-  } else if let Some(config_path) = maybe_config_file
-    .as_ref()
-    .and_then(|c| c.specifier.to_file_path().ok())
-  {
-    config_path.parent().unwrap().join("node_modules")
   } else {
-    cwd.join("node_modules")
+    resolve_from_root(root_folder, cwd)
   };
   Ok(Some(canonicalize_path_maybe_not_exists(&path)?))
 }
diff --git a/cli/factory.rs b/cli/factory.rs
index 1d1639815..42850f2cb 100644
--- a/cli/factory.rs
+++ b/cli/factory.rs
@@ -793,20 +793,12 @@ impl CliFactory {
       self.maybe_inspector_server()?.clone(),
       cli_options.maybe_lockfile().cloned(),
       self.feature_checker()?.clone(),
-      self.create_cli_main_worker_options()?,
-      cli_options.node_ipc_fd(),
-      cli_options.serve_port(),
-      cli_options.serve_host(),
-      cli_options.enable_future_features(),
-      // TODO(bartlomieju): temporarily disabled
-      // cli_options.disable_deprecated_api_warning,
-      true,
-      cli_options.verbose_deprecated_api_warning,
       if cli_options.code_cache_enabled() {
         Some(self.code_cache()?.clone())
       } else {
         None
       },
+      self.create_cli_main_worker_options()?,
     ))
   }
 
@@ -871,6 +863,13 @@ impl CliFactory {
       unstable: cli_options.legacy_unstable_flag(),
       create_hmr_runner,
       create_coverage_collector,
+      node_ipc: cli_options.node_ipc_fd(),
+      serve_port: cli_options.serve_port(),
+      serve_host: cli_options.serve_host(),
+      // TODO(bartlomieju): temporarily disabled
+      disable_deprecated_api_warning: true,
+      verbose_deprecated_api_warning: cli_options
+        .verbose_deprecated_api_warning,
     })
   }
 }
diff --git a/cli/graph_util.rs b/cli/graph_util.rs
index 8ff6c9ae3..f1188505e 100644
--- a/cli/graph_util.rs
+++ b/cli/graph_util.rs
@@ -543,7 +543,7 @@ impl ModuleGraphBuilder {
     // opted into using a node_modules directory
     if self
       .options
-      .node_modules_mode()?
+      .node_modules_dir()?
       .map(|m| m.uses_node_modules_dir())
       .unwrap_or(false)
     {
diff --git a/cli/lsp/config.rs b/cli/lsp/config.rs
index 4ac9b4d0a..854e55250 100644
--- a/cli/lsp/config.rs
+++ b/cli/lsp/config.rs
@@ -5,7 +5,7 @@ use deno_config::deno_json::DenoJsonCache;
 use deno_config::deno_json::FmtConfig;
 use deno_config::deno_json::FmtOptionsConfig;
 use deno_config::deno_json::LintConfig;
-use deno_config::deno_json::NodeModulesMode;
+use deno_config::deno_json::NodeModulesDirMode;
 use deno_config::deno_json::TestConfig;
 use deno_config::deno_json::TsConfig;
 use deno_config::fs::DenoConfigFs;
@@ -55,7 +55,6 @@ use crate::args::CliLockfile;
 use crate::args::ConfigFile;
 use crate::args::LintFlags;
 use crate::args::LintOptions;
-use crate::args::DENO_FUTURE;
 use crate::cache::FastInsecureHasher;
 use crate::file_fetcher::FileFetcher;
 use crate::lsp::logging::lsp_warn;
@@ -1388,24 +1387,14 @@ impl ConfigData {
       }
     }
 
-    let byonm = std::env::var("DENO_UNSTABLE_BYONM").is_ok()
-      || member_dir.workspace.has_unstable("byonm")
-      || (*DENO_FUTURE
-        && matches!(
-          member_dir.workspace.node_modules_mode().unwrap_or_default(),
-          Some(NodeModulesMode::LocalManual)
-        ))
-      || (
-        *DENO_FUTURE
-          && member_dir.workspace.package_jsons().next().is_some()
-          && member_dir
-            .workspace
-            .node_modules_mode()
-            .ok()
-            .flatten()
-            .is_none()
-        // TODO(2.0): remove
-      );
+    let node_modules_dir = member_dir
+      .workspace
+      .node_modules_dir_mode()
+      .unwrap_or_default();
+    let byonm = match node_modules_dir {
+      Some(mode) => mode == NodeModulesDirMode::Manual,
+      None => member_dir.workspace.package_jsons().next().is_some(),
+    };
     if byonm {
       lsp_log!("  Enabled 'bring your own node_modules'.");
     }
@@ -1879,27 +1868,16 @@ fn resolve_node_modules_dir(
   // `nodeModulesDir: true` setting in the deno.json file. This is to
   // reduce the chance of modifying someone's node_modules directory
   // without them having asked us to do so.
-  let node_modules_mode = workspace.node_modules_mode().ok().flatten();
-  let node_modules_dir_option = workspace.node_modules_dir();
-  let explicitly_disabled = if *DENO_FUTURE {
-    node_modules_mode == Some(NodeModulesMode::GlobalAuto)
-  } else {
-    node_modules_dir_option == Some(false)
-  };
+  let node_modules_mode = workspace.node_modules_dir_mode().ok().flatten();
+  let explicitly_disabled = node_modules_mode == Some(NodeModulesDirMode::None);
   if explicitly_disabled {
     return None;
   }
-  let enabled = if *DENO_FUTURE {
-    byonm
-      || node_modules_mode
-        .map(|m| m.uses_node_modules_dir())
-        .unwrap_or(false)
-      || workspace.vendor_dir_path().is_some()
-  } else {
-    byonm
-      || workspace.node_modules_dir() == Some(true)
-      || workspace.vendor_dir_path().is_some()
-  };
+  let enabled = byonm
+    || node_modules_mode
+      .map(|m| m.uses_node_modules_dir())
+      .unwrap_or(false)
+    || workspace.vendor_dir_path().is_some();
 
   if !enabled {
     return None;
diff --git a/cli/main.rs b/cli/main.rs
index ee2bd79cc..1c545ea45 100644
--- a/cli/main.rs
+++ b/cli/main.rs
@@ -32,7 +32,6 @@ mod worker;
 use crate::args::flags_from_vec;
 use crate::args::DenoSubcommand;
 use crate::args::Flags;
-use crate::args::DENO_FUTURE;
 use crate::graph_container::ModuleGraphContainer;
 use crate::util::display;
 use crate::util::v8::get_v8_flags_from_env;
@@ -454,30 +453,19 @@ fn resolve_flags_and_init(
     // https://github.com/microsoft/vscode/blob/48d4ba271686e8072fc6674137415bc80d936bc7/extensions/typescript-language-features/src/configuration/configuration.ts#L213-L214
     DenoSubcommand::Lsp => vec!["--max-old-space-size=3072".to_string()],
     _ => {
-      if *DENO_FUTURE {
-        // TODO(bartlomieju): I think this can be removed as it's handled by `deno_core`
-        // and its settings.
-        // deno_ast removes TypeScript `assert` keywords, so this flag only affects JavaScript
-        // TODO(petamoriken): Need to check TypeScript `assert` keywords in deno_ast
-        vec!["--no-harmony-import-assertions".to_string()]
-      } else {
-        vec![
-          // TODO(bartlomieju): I think this can be removed as it's handled by `deno_core`
-          // and its settings.
-          // If we're still in v1.X version we want to support import assertions.
-          // V8 12.6 unshipped the support by default, so force it by passing a
-          // flag.
-          "--harmony-import-assertions".to_string(),
-          // Verify with DENO_FUTURE for now.
-          "--no-maglev".to_string(),
-        ]
-      }
+      // TODO(bartlomieju): I think this can be removed as it's handled by `deno_core`
+      // and its settings.
+      // deno_ast removes TypeScript `assert` keywords, so this flag only affects JavaScript
+      // TODO(petamoriken): Need to check TypeScript `assert` keywords in deno_ast
+      vec!["--no-harmony-import-assertions".to_string()]
     }
   };
 
   init_v8_flags(&default_v8_flags, &flags.v8_flags, get_v8_flags_from_env());
   // TODO(bartlomieju): remove last argument in Deno 2.
-  deno_core::JsRuntime::init_platform(None, !*DENO_FUTURE);
+  deno_core::JsRuntime::init_platform(
+    None, /* import assertions enabled */ false,
+  );
   util::logger::init(flags.log_level);
 
   Ok(flags)
diff --git a/cli/npm/managed/resolvers/local.rs b/cli/npm/managed/resolvers/local.rs
index 8f729d79c..b88dd57cf 100644
--- a/cli/npm/managed/resolvers/local.rs
+++ b/cli/npm/managed/resolvers/local.rs
@@ -831,22 +831,14 @@ async fn sync_resolution_with_fs(
   }
 
   if !packages_with_scripts_not_run.is_empty() {
-    let (maybe_install, maybe_install_example) = if *crate::args::DENO_FUTURE {
-      (
-        " or `deno install`",
-        " or `deno install --allow-scripts=pkg1,pkg2`",
-      )
-    } else {
-      ("", "")
-    };
     let packages = packages_with_scripts_not_run
       .iter()
       .map(|(_, p)| format!("npm:{p}"))
       .collect::<Vec<_>>()
       .join(", ");
     log::warn!("{}: Packages contained npm lifecycle scripts (preinstall/install/postinstall) that were not executed.
-    This may cause the packages to not work correctly. To run them, use the `--allow-scripts` flag with `deno cache`{maybe_install}
-    (e.g. `deno cache --allow-scripts=pkg1,pkg2 <entrypoint>`{maybe_install_example}):\n      {packages}", crate::colors::yellow("warning"));
+    This may cause the packages to not work correctly. To run them, use the `--allow-scripts` flag with `deno cache` or `deno install`
+    (e.g. `deno cache --allow-scripts=pkg1,pkg2 <entrypoint>` or `deno install --allow-scripts=pkg1,pkg2`):\n      {packages}", crate::colors::yellow("warning"));
     for (scripts_warned_path, _) in packages_with_scripts_not_run {
       let _ignore_err = fs::write(scripts_warned_path, "");
     }
diff --git a/cli/resolver.rs b/cli/resolver.rs
index 57c05b532..e0a33bf3c 100644
--- a/cli/resolver.rs
+++ b/cli/resolver.rs
@@ -225,13 +225,8 @@ impl CliNodeResolver {
           let package_json_path = package_folder.join("package.json");
           if !self.fs.exists_sync(&package_json_path) {
             return Err(anyhow!(
-              "Could not find '{}'. Deno expects the node_modules/ directory to be up to date. Did you forget to run `{}`?",
+              "Could not find '{}'. Deno expects the node_modules/ directory to be up to date. Did you forget to run `deno install`?",
               package_json_path.display(),
-              if *crate::args::DENO_FUTURE {
-                "deno install"
-              } else {
-                "npm install"
-              },
             ));
           }
         }
diff --git a/cli/standalone/binary.rs b/cli/standalone/binary.rs
index d80f8a969..9d2c0781a 100644
--- a/cli/standalone/binary.rs
+++ b/cli/standalone/binary.rs
@@ -629,7 +629,6 @@ impl<'a> DenoCompileBinaryWriter<'a> {
       unstable_config: UnstableConfig {
         legacy_flag_enabled: cli_options.legacy_unstable_flag(),
         bare_node_builtins: cli_options.unstable_bare_node_builtins(),
-        byonm: cli_options.use_byonm(),
         sloppy_imports: cli_options.unstable_sloppy_imports(),
         features: cli_options.unstable_features(),
       },
diff --git a/cli/standalone/mod.rs b/cli/standalone/mod.rs
index 90b2b8a28..4c199a7d5 100644
--- a/cli/standalone/mod.rs
+++ b/cli/standalone/mod.rs
@@ -706,6 +706,8 @@ pub async fn run(
     None,
     None,
     feature_checker,
+    // Code cache is not supported for standalone binary yet.
+    None,
     CliMainWorkerOptions {
       argv: metadata.argv,
       log_level: WorkerLogLevel::Info,
@@ -732,17 +734,13 @@ pub async fn run(
       unstable: metadata.unstable_config.legacy_flag_enabled,
       create_hmr_runner: None,
       create_coverage_collector: None,
+      node_ipc: None,
+      serve_port: None,
+      serve_host: None,
+      // TODO(bartlomieju): temporarily disabled
+      disable_deprecated_api_warning: true,
+      verbose_deprecated_api_warning: false,
     },
-    None,
-    None,
-    None,
-    false,
-    // TODO(bartlomieju): temporarily disabled
-    // metadata.disable_deprecated_api_warning,
-    true,
-    false,
-    // Code cache is not supported for standalone binary yet.
-    None,
   );
 
   // Initialize v8 once from the main thread.
diff --git a/cli/tools/registry/pm.rs b/cli/tools/registry/pm.rs
index 87a5ea69a..4a36b459a 100644
--- a/cli/tools/registry/pm.rs
+++ b/cli/tools/registry/pm.rs
@@ -140,10 +140,10 @@ impl DenoOrPackageJson {
         ),
         factory,
       )),
-      (None, Some(package_json)) if options.enable_future_features() => {
+      (None, Some(package_json)) => {
         Ok((DenoOrPackageJson::Npm(package_json.clone(), None), factory))
       }
-      (None, Some(_) | None) => {
+      (None, None) => {
         std::fs::write(options.initial_cwd().join("deno.json"), "{}\n")
           .context("Failed to create deno.json file")?;
         drop(factory); // drop to prevent use
diff --git a/cli/tools/run/mod.rs b/cli/tools/run/mod.rs
index 9d1d5e78b..bdafdae88 100644
--- a/cli/tools/run/mod.rs
+++ b/cli/tools/run/mod.rs
@@ -3,6 +3,7 @@
 use std::io::Read;
 use std::sync::Arc;
 
+use deno_config::deno_json::NodeModulesDirMode;
 use deno_core::error::AnyError;
 use deno_runtime::deno_permissions::Permissions;
 use deno_runtime::deno_permissions::PermissionsContainer;
@@ -194,11 +195,8 @@ pub async fn eval_command(
 pub async fn maybe_npm_install(factory: &CliFactory) -> Result<(), AnyError> {
   // ensure an "npm install" is done if the user has explicitly
   // opted into using a managed node_modules directory
-  if factory
-    .cli_options()?
-    .node_modules_mode()?
-    .map(|m| m.uses_node_modules_dir())
-    .unwrap_or(false)
+  if factory.cli_options()?.node_modules_dir()?
+    == Some(NodeModulesDirMode::Auto)
   {
     if let Some(npm_resolver) = factory.npm_resolver().await?.as_managed() {
       npm_resolver.ensure_top_level_package_json_install().await?;
diff --git a/cli/tools/vendor/mod.rs b/cli/tools/vendor/mod.rs
index d21d17529..3de08f1d0 100644
--- a/cli/tools/vendor/mod.rs
+++ b/cli/tools/vendor/mod.rs
@@ -89,7 +89,7 @@ pub async fn vendor(
   let npm_package_count = graph.npm_packages.len();
   let try_add_node_modules_dir = npm_package_count > 0
     && cli_options
-      .node_modules_mode()?
+      .node_modules_dir()?
       .map(|m| m.uses_node_modules_dir())
       .unwrap_or(true);
 
@@ -344,7 +344,7 @@ fn update_config_text(
       let insert_position = obj.range.end - 1;
       text_changes.push(TextChange {
         range: insert_position..insert_position,
-        new_text: r#""nodeModulesDir": true"#.to_string(),
+        new_text: r#""nodeModulesDir": "auto""#.to_string(),
       });
       should_format = true;
       modified_result.added_node_modules_dir = true;
@@ -454,7 +454,7 @@ mod internal_test {
     assert_eq!(
       result.new_text.unwrap(),
       r#"{
-  "nodeModulesDir": true,
+  "nodeModulesDir": "auto",
   "importMap": "./vendor/import_map.json"
 }
 "#
@@ -467,7 +467,7 @@ mod internal_test {
     assert_eq!(
       result.new_text.unwrap(),
       r#"{
-  "nodeModulesDir": true
+  "nodeModulesDir": "auto"
 }
 "#
     );
@@ -546,10 +546,10 @@ mod internal_test {
 
   #[test]
   fn no_update_node_modules_dir() {
-    // will not update if this is already set (even if it's false)
+    // will not update if this is already set (even if it's "none")
     let result = update_config_text(
       r#"{
-  "nodeModulesDir": false
+  "nodeModulesDir": "none"
 }
 "#,
       &Default::default(),
@@ -563,7 +563,7 @@ mod internal_test {
 
     let result = update_config_text(
       r#"{
-  "nodeModulesDir": true
+  "nodeModulesDir": "auto"
 }
 "#,
       &Default::default(),
diff --git a/cli/worker.rs b/cli/worker.rs
index 31a88ae4e..f3ff1141a 100644
--- a/cli/worker.rs
+++ b/cli/worker.rs
@@ -116,6 +116,11 @@ pub struct CliMainWorkerOptions {
   pub skip_op_registration: bool,
   pub create_hmr_runner: Option<CreateHmrRunnerCb>,
   pub create_coverage_collector: Option<CreateCoverageCollectorCb>,
+  pub node_ipc: Option<i64>,
+  pub serve_port: Option<u16>,
+  pub serve_host: Option<String>,
+  pub disable_deprecated_api_warning: bool,
+  pub verbose_deprecated_api_warning: bool,
 }
 
 struct SharedWorkerState {
@@ -135,13 +140,8 @@ struct SharedWorkerState {
   maybe_inspector_server: Option<Arc<InspectorServer>>,
   maybe_lockfile: Option<Arc<CliLockfile>>,
   feature_checker: Arc<FeatureChecker>,
-  node_ipc: Option<i64>,
   enable_future_features: bool,
-  disable_deprecated_api_warning: bool,
-  verbose_deprecated_api_warning: bool,
   code_cache: Option<Arc<dyn code_cache::CodeCache>>,
-  serve_port: Option<u16>,
-  serve_host: Option<String>,
 }
 
 impl SharedWorkerState {
@@ -434,14 +434,8 @@ impl CliMainWorkerFactory {
     maybe_inspector_server: Option<Arc<InspectorServer>>,
     maybe_lockfile: Option<Arc<CliLockfile>>,
     feature_checker: Arc<FeatureChecker>,
-    options: CliMainWorkerOptions,
-    node_ipc: Option<i64>,
-    serve_port: Option<u16>,
-    serve_host: Option<String>,
-    enable_future_features: bool,
-    disable_deprecated_api_warning: bool,
-    verbose_deprecated_api_warning: bool,
     code_cache: Option<Arc<dyn code_cache::CodeCache>>,
+    options: CliMainWorkerOptions,
   ) -> Self {
     Self {
       shared: Arc::new(SharedWorkerState {
@@ -461,12 +455,8 @@ impl CliMainWorkerFactory {
         maybe_inspector_server,
         maybe_lockfile,
         feature_checker,
-        node_ipc,
-        serve_port,
-        serve_host,
-        enable_future_features,
-        disable_deprecated_api_warning,
-        verbose_deprecated_api_warning,
+        // TODO(2.0): remove?
+        enable_future_features: true,
         code_cache,
       }),
     }
@@ -602,13 +592,17 @@ impl CliMainWorkerFactory {
         has_node_modules_dir: shared.options.has_node_modules_dir,
         argv0: shared.options.argv0.clone(),
         node_debug: shared.options.node_debug.clone(),
-        node_ipc_fd: shared.node_ipc,
-        disable_deprecated_api_warning: shared.disable_deprecated_api_warning,
-        verbose_deprecated_api_warning: shared.verbose_deprecated_api_warning,
+        node_ipc_fd: shared.options.node_ipc,
+        disable_deprecated_api_warning: shared
+          .options
+          .disable_deprecated_api_warning,
+        verbose_deprecated_api_warning: shared
+          .options
+          .verbose_deprecated_api_warning,
         future: shared.enable_future_features,
         mode,
-        serve_port: shared.serve_port,
-        serve_host: shared.serve_host.clone(),
+        serve_port: shared.options.serve_port,
+        serve_host: shared.options.serve_host.clone(),
       },
       extensions: custom_extensions,
       startup_snapshot: crate::js::deno_isolate_init(),
@@ -801,12 +795,16 @@ fn create_web_worker_callback(
         argv0: shared.options.argv0.clone(),
         node_debug: shared.options.node_debug.clone(),
         node_ipc_fd: None,
-        disable_deprecated_api_warning: shared.disable_deprecated_api_warning,
-        verbose_deprecated_api_warning: shared.verbose_deprecated_api_warning,
+        disable_deprecated_api_warning: shared
+          .options
+          .disable_deprecated_api_warning,
+        verbose_deprecated_api_warning: shared
+          .options
+          .verbose_deprecated_api_warning,
         future: shared.enable_future_features,
         mode: WorkerExecutionMode::Worker,
-        serve_port: shared.serve_port,
-        serve_host: shared.serve_host.clone(),
+        serve_port: shared.options.serve_port,
+        serve_host: shared.options.serve_host.clone(),
       },
       extensions: vec![],
       startup_snapshot: crate::js::deno_isolate_init(),