fix(compile): write bytes directly to output file (#18777)

1. Adds cli/standalone folder
2. Writes the bytes directly to the output file. When adding npm
packages this might get quite large, so let's not keep the final output
in memory just in case.

cli/main.rs

@@ -42,6 +42,7 @@ use deno_runtime::colors;
 use deno_runtime::fmt_errors::format_js_error;
 use deno_runtime::tokio_util::run_local;
 use std::env;
+use std::env::current_exe;
 use std::path::PathBuf;
 
 async fn run_subcommand(flags: Flags) -> Result<i32, AnyError> {
@@ -245,8 +246,11 @@ pub fn main() {
   let args: Vec<String> = env::args().collect();
 
   let future = async move {
+    let current_exe_path = current_exe()?;
     let standalone_res =
-      match standalone::extract_standalone(args.clone()).await {
+      match standalone::extract_standalone(&current_exe_path, args.clone())
+        .await
+      {
         Ok(Some((metadata, eszip))) => standalone::run(eszip, metadata).await,
         Ok(None) => Ok(()),
         Err(err) => Err(err),

cli/standalone/binary.rs

@@ -0,0 +1,307 @@
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+
+use std::io::Read;
+use std::io::Seek;
+use std::io::SeekFrom;
+use std::io::Write;
+use std::path::Path;
+use std::sync::Arc;
+
+use deno_ast::ModuleSpecifier;
+use deno_core::anyhow::Context;
+use deno_core::error::AnyError;
+use deno_core::futures::io::AllowStdIo;
+use deno_core::futures::AsyncReadExt;
+use deno_core::futures::AsyncSeekExt;
+use deno_core::serde_json;
+use deno_core::url::Url;
+use deno_runtime::permissions::PermissionsOptions;
+use log::Level;
+use serde::Deserialize;
+use serde::Serialize;
+
+use crate::args::CaData;
+use crate::args::CliOptions;
+use crate::args::CompileFlags;
+use crate::cache::DenoDir;
+use crate::file_fetcher::FileFetcher;
+use crate::http_util::HttpClient;
+use crate::util::progress_bar::ProgressBar;
+use crate::util::progress_bar::ProgressBarStyle;
+
+const MAGIC_TRAILER: &[u8; 8] = b"d3n0l4nd";
+
+#[derive(Deserialize, Serialize)]
+pub struct Metadata {
+  pub argv: Vec<String>,
+  pub unstable: bool,
+  pub seed: Option<u64>,
+  pub permissions: PermissionsOptions,
+  pub location: Option<Url>,
+  pub v8_flags: Vec<String>,
+  pub log_level: Option<Level>,
+  pub ca_stores: Option<Vec<String>>,
+  pub ca_data: Option<Vec<u8>>,
+  pub unsafely_ignore_certificate_errors: Option<Vec<String>>,
+  pub maybe_import_map: Option<(Url, String)>,
+  pub entrypoint: ModuleSpecifier,
+}
+
+pub fn write_binary_bytes(
+  writer: &mut impl Write,
+  original_bin: Vec<u8>,
+  metadata: &Metadata,
+  eszip: eszip::EszipV2,
+) -> Result<(), AnyError> {
+  let metadata = serde_json::to_string(metadata)?.as_bytes().to_vec();
+  let eszip_archive = eszip.into_bytes();
+
+  let eszip_pos = original_bin.len();
+  let metadata_pos = eszip_pos + eszip_archive.len();
+  let mut trailer = MAGIC_TRAILER.to_vec();
+  trailer.write_all(&eszip_pos.to_be_bytes())?;
+  trailer.write_all(&metadata_pos.to_be_bytes())?;
+
+  writer.write_all(&original_bin)?;
+  writer.write_all(&eszip_archive)?;
+  writer.write_all(&metadata)?;
+  writer.write_all(&trailer)?;
+
+  Ok(())
+}
+
+pub fn is_standalone_binary(exe_path: &Path) -> bool {
+  let Ok(mut output_file) = std::fs::File::open(exe_path) else {
+    return false;
+  };
+  if output_file.seek(SeekFrom::End(-24)).is_err() {
+    // This seek may fail because the file is too small to possibly be
+    // `deno compile` output.
+    return false;
+  }
+  let mut trailer = [0; 24];
+  if output_file.read_exact(&mut trailer).is_err() {
+    return false;
+  };
+  let (magic_trailer, _) = trailer.split_at(8);
+  magic_trailer == MAGIC_TRAILER
+}
+
+/// This function will try to run this binary as a standalone binary
+/// produced by `deno compile`. It determines if this is a standalone
+/// binary by checking for the magic trailer string `d3n0l4nd` at EOF-24 (8 bytes * 3).
+/// The magic trailer is followed by:
+/// - a u64 pointer to the JS bundle embedded in the binary
+/// - a u64 pointer to JSON metadata (serialized flags) embedded in the binary
+/// These are dereferenced, and the bundle is executed under the configuration
+/// specified by the metadata. If no magic trailer is present, this function
+/// exits with `Ok(None)`.
+pub async fn extract_standalone(
+  exe_path: &Path,
+  cli_args: Vec<String>,
+) -> Result<Option<(Metadata, eszip::EszipV2)>, AnyError> {
+  let file = std::fs::File::open(exe_path)?;
+
+  let mut bufreader =
+    deno_core::futures::io::BufReader::new(AllowStdIo::new(file));
+
+  let trailer_pos = bufreader.seek(SeekFrom::End(-24)).await?;
+  let mut trailer = [0; 24];
+  bufreader.read_exact(&mut trailer).await?;
+  let (magic_trailer, rest) = trailer.split_at(8);
+  if magic_trailer != MAGIC_TRAILER {
+    return Ok(None);
+  }
+
+  let (eszip_archive_pos, rest) = rest.split_at(8);
+  let metadata_pos = rest;
+  let eszip_archive_pos = u64_from_bytes(eszip_archive_pos)?;
+  let metadata_pos = u64_from_bytes(metadata_pos)?;
+  let metadata_len = trailer_pos - metadata_pos;
+
+  bufreader.seek(SeekFrom::Start(eszip_archive_pos)).await?;
+
+  let (eszip, loader) = eszip::EszipV2::parse(bufreader)
+    .await
+    .context("Failed to parse eszip header")?;
+
+  let mut bufreader = loader.await.context("Failed to parse eszip archive")?;
+
+  bufreader.seek(SeekFrom::Start(metadata_pos)).await?;
+
+  let mut metadata = String::new();
+
+  bufreader
+    .take(metadata_len)
+    .read_to_string(&mut metadata)
+    .await
+    .context("Failed to read metadata from the current executable")?;
+
+  let mut metadata: Metadata = serde_json::from_str(&metadata).unwrap();
+  metadata.argv.append(&mut cli_args[1..].to_vec());
+
+  Ok(Some((metadata, eszip)))
+}
+
+fn u64_from_bytes(arr: &[u8]) -> Result<u64, AnyError> {
+  let fixed_arr: &[u8; 8] = arr
+    .try_into()
+    .context("Failed to convert the buffer into a fixed-size array")?;
+  Ok(u64::from_be_bytes(*fixed_arr))
+}
+
+pub struct DenoCompileBinaryWriter {
+  file_fetcher: Arc<FileFetcher>,
+  client: HttpClient,
+  deno_dir: DenoDir,
+}
+
+impl DenoCompileBinaryWriter {
+  pub fn new(
+    file_fetcher: Arc<FileFetcher>,
+    client: HttpClient,
+    deno_dir: DenoDir,
+  ) -> Self {
+    Self {
+      file_fetcher,
+      client,
+      deno_dir,
+    }
+  }
+
+  pub async fn write_bin(
+    &self,
+    writer: &mut impl Write,
+    eszip: eszip::EszipV2,
+    module_specifier: &ModuleSpecifier,
+    compile_flags: &CompileFlags,
+    cli_options: &CliOptions,
+  ) -> Result<(), AnyError> {
+    // Select base binary based on target
+    let original_binary =
+      self.get_base_binary(compile_flags.target.clone()).await?;
+
+    self
+      .write_standalone_binary(
+        writer,
+        original_binary,
+        eszip,
+        module_specifier,
+        cli_options,
+        compile_flags,
+      )
+      .await
+  }
+
+  async fn get_base_binary(
+    &self,
+    target: Option<String>,
+  ) -> Result<Vec<u8>, AnyError> {
+    if target.is_none() {
+      let path = std::env::current_exe()?;
+      return Ok(std::fs::read(path)?);
+    }
+
+    let target = target.unwrap_or_else(|| env!("TARGET").to_string());
+    let binary_name = format!("deno-{target}.zip");
+
+    let binary_path_suffix = if crate::version::is_canary() {
+      format!("canary/{}/{}", crate::version::GIT_COMMIT_HASH, binary_name)
+    } else {
+      format!("release/v{}/{}", env!("CARGO_PKG_VERSION"), binary_name)
+    };
+
+    let download_directory = self.deno_dir.dl_folder_path();
+    let binary_path = download_directory.join(&binary_path_suffix);
+
+    if !binary_path.exists() {
+      self
+        .download_base_binary(&download_directory, &binary_path_suffix)
+        .await?;
+    }
+
+    let archive_data = std::fs::read(binary_path)?;
+    let temp_dir = tempfile::TempDir::new()?;
+    let base_binary_path = crate::tools::upgrade::unpack_into_dir(
+      archive_data,
+      target.contains("windows"),
+      &temp_dir,
+    )?;
+    let base_binary = std::fs::read(base_binary_path)?;
+    drop(temp_dir); // delete the temp dir
+    Ok(base_binary)
+  }
+
+  async fn download_base_binary(
+    &self,
+    output_directory: &Path,
+    binary_path_suffix: &str,
+  ) -> Result<(), AnyError> {
+    let download_url = format!("https://dl.deno.land/{binary_path_suffix}");
+    let maybe_bytes = {
+      let progress_bars = ProgressBar::new(ProgressBarStyle::DownloadBars);
+      let progress = progress_bars.update(&download_url);
+
+      self
+        .client
+        .download_with_progress(download_url, &progress)
+        .await?
+    };
+    let bytes = match maybe_bytes {
+      Some(bytes) => bytes,
+      None => {
+        log::info!("Download could not be found, aborting");
+        std::process::exit(1)
+      }
+    };
+
+    std::fs::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?;
+    Ok(())
+  }
+
+  /// This functions creates a standalone deno binary by appending a bundle
+  /// and magic trailer to the currently executing binary.
+  async fn write_standalone_binary(
+    &self,
+    writer: &mut impl Write,
+    original_bin: Vec<u8>,
+    eszip: eszip::EszipV2,
+    entrypoint: &ModuleSpecifier,
+    cli_options: &CliOptions,
+    compile_flags: &CompileFlags,
+  ) -> Result<(), AnyError> {
+    let ca_data = match cli_options.ca_data() {
+      Some(CaData::File(ca_file)) => Some(
+        std::fs::read(ca_file)
+          .with_context(|| format!("Reading: {ca_file}"))?,
+      ),
+      Some(CaData::Bytes(bytes)) => Some(bytes.clone()),
+      None => None,
+    };
+    let maybe_import_map = cli_options
+      .resolve_import_map(&self.file_fetcher)
+      .await?
+      .map(|import_map| (import_map.base_url().clone(), import_map.to_json()));
+    let metadata = Metadata {
+      argv: compile_flags.args.clone(),
+      unstable: cli_options.unstable(),
+      seed: cli_options.seed(),
+      location: cli_options.location_flag().clone(),
+      permissions: cli_options.permissions_options(),
+      v8_flags: cli_options.v8_flags().clone(),
+      unsafely_ignore_certificate_errors: cli_options
+        .unsafely_ignore_certificate_errors()
+        .clone(),
+      log_level: cli_options.log_level(),
+      ca_stores: cli_options.ca_stores().clone(),
+      ca_data,
+      entrypoint: entrypoint.clone(),
+      maybe_import_map,
+    };
+
+    write_binary_bytes(writer, original_bin, &metadata, eszip)
+  }
+}

cli/standalone/mod.rs

@@ -12,16 +12,9 @@ use crate::CliGraphResolver;
 use deno_core::anyhow::Context;
 use deno_core::error::type_error;
 use deno_core::error::AnyError;
-use deno_core::futures::io::AllowStdIo;
 use deno_core::futures::task::LocalFutureObj;
-use deno_core::futures::AsyncReadExt;
-use deno_core::futures::AsyncSeekExt;
 use deno_core::futures::FutureExt;
 use deno_core::located_script_name;
-use deno_core::serde::Deserialize;
-use deno_core::serde::Serialize;
-use deno_core::serde_json;
-use deno_core::url::Url;
 use deno_core::v8_set_flags;
 use deno_core::ModuleLoader;
 use deno_core::ModuleSpecifier;
@@ -33,7 +26,6 @@ use deno_runtime::ops::worker_host::CreateWebWorkerCb;
 use deno_runtime::ops::worker_host::WorkerEventCb;
 use deno_runtime::permissions::Permissions;
 use deno_runtime::permissions::PermissionsContainer;
-use deno_runtime::permissions::PermissionsOptions;
 use deno_runtime::web_worker::WebWorker;
 use deno_runtime::web_worker::WebWorkerOptions;
 use deno_runtime::worker::MainWorker;
@@ -41,93 +33,17 @@ use deno_runtime::worker::WorkerOptions;
 use deno_runtime::BootstrapOptions;
 use import_map::parse_from_json;
 use log::Level;
-use std::env::current_exe;
-use std::io::SeekFrom;
 use std::pin::Pin;
 use std::rc::Rc;
 use std::sync::Arc;
 
-#[derive(Deserialize, Serialize)]
-pub struct Metadata {
-  pub argv: Vec<String>,
-  pub unstable: bool,
-  pub seed: Option<u64>,
-  pub permissions: PermissionsOptions,
-  pub location: Option<Url>,
-  pub v8_flags: Vec<String>,
-  pub log_level: Option<Level>,
-  pub ca_stores: Option<Vec<String>>,
-  pub ca_data: Option<Vec<u8>>,
-  pub unsafely_ignore_certificate_errors: Option<Vec<String>>,
-  pub maybe_import_map: Option<(Url, String)>,
-  pub entrypoint: ModuleSpecifier,
-}
+mod binary;
 
-pub const MAGIC_TRAILER: &[u8; 8] = b"d3n0l4nd";
+pub use binary::extract_standalone;
+pub use binary::is_standalone_binary;
+pub use binary::DenoCompileBinaryWriter;
 
-/// This function will try to run this binary as a standalone binary
-/// produced by `deno compile`. It determines if this is a standalone
-/// binary by checking for the magic trailer string `d3n0l4nd` at EOF-24.
-/// The magic trailer is followed by:
-/// - a u64 pointer to the JS bundle embedded in the binary
-/// - a u64 pointer to JSON metadata (serialized flags) embedded in the binary
-/// These are dereferenced, and the bundle is executed under the configuration
-/// specified by the metadata. If no magic trailer is present, this function
-/// exits with `Ok(None)`.
-pub async fn extract_standalone(
-  args: Vec<String>,
-) -> Result<Option<(Metadata, eszip::EszipV2)>, AnyError> {
-  let current_exe_path = current_exe()?;
-
-  let file = std::fs::File::open(current_exe_path)?;
-
-  let mut bufreader =
-    deno_core::futures::io::BufReader::new(AllowStdIo::new(file));
-
-  let trailer_pos = bufreader.seek(SeekFrom::End(-24)).await?;
-  let mut trailer = [0; 24];
-  bufreader.read_exact(&mut trailer).await?;
-  let (magic_trailer, rest) = trailer.split_at(8);
-  if magic_trailer != MAGIC_TRAILER {
-    return Ok(None);
-  }
-
-  let (eszip_archive_pos, rest) = rest.split_at(8);
-  let metadata_pos = rest;
-  let eszip_archive_pos = u64_from_bytes(eszip_archive_pos)?;
-  let metadata_pos = u64_from_bytes(metadata_pos)?;
-  let metadata_len = trailer_pos - metadata_pos;
-
-  bufreader.seek(SeekFrom::Start(eszip_archive_pos)).await?;
-
-  let (eszip, loader) = eszip::EszipV2::parse(bufreader)
-    .await
-    .context("Failed to parse eszip header")?;
-
-  let mut bufreader = loader.await.context("Failed to parse eszip archive")?;
-
-  bufreader.seek(SeekFrom::Start(metadata_pos)).await?;
-
-  let mut metadata = String::new();
-
-  bufreader
-    .take(metadata_len)
-    .read_to_string(&mut metadata)
-    .await
-    .context("Failed to read metadata from the current executable")?;
-
-  let mut metadata: Metadata = serde_json::from_str(&metadata).unwrap();
-  metadata.argv.append(&mut args[1..].to_vec());
-
-  Ok(Some((metadata, eszip)))
-}
-
-fn u64_from_bytes(arr: &[u8]) -> Result<u64, AnyError> {
-  let fixed_arr: &[u8; 8] = arr
-    .try_into()
-    .context("Failed to convert the buffer into a fixed-size array")?;
-  Ok(u64::from_be_bytes(*fixed_arr))
-}
+use self::binary::Metadata;
 
 #[derive(Clone)]
 struct EmbeddedModuleLoader {

cli/tests/integration/compile_tests.rs

@@ -4,6 +4,7 @@ use std::fs::File;
 use std::process::Command;
 use test_util as util;
 use test_util::TempDir;
+use util::assert_contains;
 
 #[test]
 fn compile() {
@@ -111,13 +112,13 @@ fn standalone_error() {
   let stderr = util::strip_ansi_codes(&stderr).to_string();
   // On Windows, we cannot assert the file path (because '\').
   // Instead we just check for relevant output.
-  assert!(stderr.contains("error: Uncaught Error: boom!"));
-  assert!(stderr.contains("throw new Error(\"boom!\");"));
-  assert!(stderr.contains("\n    at boom (file://"));
-  assert!(stderr.contains("standalone_error.ts:2:11"));
-  assert!(stderr.contains("at foo (file://"));
-  assert!(stderr.contains("standalone_error.ts:5:5"));
-  assert!(stderr.contains("standalone_error.ts:7:1"));
+  assert_contains!(stderr, "error: Uncaught Error: boom!");
+  assert_contains!(stderr, "throw new Error(\"boom!\");");
+  assert_contains!(stderr, "\n    at boom (file://");
+  assert_contains!(stderr, "standalone_error.ts:2:11");
+  assert_contains!(stderr, "at foo (file://");
+  assert_contains!(stderr, "standalone_error.ts:5:5");
+  assert_contains!(stderr, "standalone_error.ts:7:1");
 }
 
 #[test]
@@ -156,10 +157,10 @@ fn standalone_error_module_with_imports() {
   let stderr = util::strip_ansi_codes(&stderr).to_string();
   // On Windows, we cannot assert the file path (because '\').
   // Instead we just check for relevant output.
-  assert!(stderr.contains("error: Uncaught Error: boom!"));
-  assert!(stderr.contains("throw new Error(\"boom!\");"));
-  assert!(stderr.contains("\n    at file://"));
-  assert!(stderr.contains("standalone_error_module_with_imports_2.ts:2:7"));
+  assert_contains!(stderr, "error: Uncaught Error: boom!");
+  assert_contains!(stderr, "throw new Error(\"boom!\");");
+  assert_contains!(stderr, "\n    at file://");
+  assert_contains!(stderr, "standalone_error_module_with_imports_2.ts:2:7");
 }
 
 #[test]
@@ -259,7 +260,7 @@ fn compile_with_file_exists_error() {
     file_path.display(),
   );
   let stderr = String::from_utf8(output.stderr).unwrap();
-  assert!(stderr.contains(&expected_stderr));
+  assert_contains!(stderr, &expected_stderr);
 }
 
 #[test]
@@ -293,7 +294,7 @@ fn compile_with_directory_exists_error() {
     exe.display()
   );
   let stderr = String::from_utf8(output.stderr).unwrap();
-  assert!(stderr.contains(&expected_stderr));
+  assert_contains!(stderr, &expected_stderr);
 }
 
 #[test]
@@ -327,8 +328,7 @@ fn compile_with_conflict_file_exists_error() {
     exe.display()
   );
   let stderr = String::from_utf8(output.stderr).unwrap();
-  dbg!(&stderr);
-  assert!(stderr.contains(&expected_stderr));
+  assert_contains!(stderr, &expected_stderr);
   assert!(std::fs::read(&exe)
     .unwrap()
     .eq(b"SHOULD NOT BE OVERWRITTEN"));
@@ -407,8 +407,10 @@ fn standalone_runtime_flags() {
   let stdout_str = String::from_utf8(output.stdout).unwrap();
   assert_eq!(util::strip_ansi_codes(&stdout_str), "0.147205063401058\n");
   let stderr_str = String::from_utf8(output.stderr).unwrap();
-  assert!(util::strip_ansi_codes(&stderr_str)
-    .contains("PermissionDenied: Requires write access"));
+  assert_contains!(
+    util::strip_ansi_codes(&stderr_str),
+    "PermissionDenied: Requires write access"
+  );
 }
 
 #[test]
@@ -636,9 +638,10 @@ fn check_local_by_default2() {
   let stdout = String::from_utf8(output.stdout).unwrap();
   let stderr = String::from_utf8(output.stderr).unwrap();
   assert!(stdout.is_empty());
-  assert!(stderr.contains(
+  assert_contains!(
+    stderr,
     r#"error: TS2322 [ERROR]: Type '12' is not assignable to type '"b"'."#
-  ));
+  );
 }
 
 #[test]

cli/tools/standalone.rs

@@ -1,32 +1,18 @@
 // Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
 
-use crate::args::CaData;
 use crate::args::CompileFlags;
 use crate::args::Flags;
-use crate::cache::DenoDir;
 use crate::graph_util::error_for_any_npm_specifier;
-use crate::http_util::HttpClient;
-use crate::standalone::Metadata;
-use crate::standalone::MAGIC_TRAILER;
+use crate::standalone::is_standalone_binary;
+use crate::standalone::DenoCompileBinaryWriter;
 use crate::util::path::path_has_trailing_slash;
-use crate::util::progress_bar::ProgressBar;
-use crate::util::progress_bar::ProgressBarStyle;
 use crate::ProcState;
 use deno_core::anyhow::bail;
 use deno_core::anyhow::Context;
 use deno_core::error::generic_error;
 use deno_core::error::AnyError;
 use deno_core::resolve_url_or_path;
-use deno_core::serde_json;
-use deno_graph::ModuleSpecifier;
 use deno_runtime::colors;
-use std::env;
-use std::fs;
-use std::fs::File;
-use std::io::Read;
-use std::io::Seek;
-use std::io::SeekFrom;
-use std::io::Write;
 use std::path::Path;
 use std::path::PathBuf;
 use std::sync::Arc;
@@ -38,6 +24,11 @@ pub async fn compile(
   compile_flags: CompileFlags,
 ) -> Result<(), AnyError> {
   let ps = ProcState::from_flags(flags).await?;
+  let binary_writer = DenoCompileBinaryWriter::new(
+    ps.file_fetcher.clone(),
+    ps.http_client.clone(),
+    ps.dir.clone(),
+  );
   let module_specifier = ps.options.resolve_main_module()?;
   let module_roots = {
     let mut vec = Vec::with_capacity(compile_flags.include.len() + 1);
@@ -47,7 +38,6 @@ pub async fn compile(
     }
     vec
   };
-  let deno_dir = &ps.dir;
 
   let output_path = resolve_compile_executable_output_path(
     &compile_flags,
@@ -69,164 +59,40 @@ pub async fn compile(
   let eszip = eszip::EszipV2::from_graph(graph, &parser, Default::default())?;
 
   log::info!(
-    "{} {}",
+    "{} {} to {}",
     colors::green("Compile"),
-    module_specifier.to_string()
+    module_specifier.to_string(),
+    output_path.display(),
   );
+  validate_output_path(&output_path)?;
 
-  // Select base binary based on target
-  let original_binary =
-    get_base_binary(&ps.http_client, deno_dir, compile_flags.target.clone())
-      .await?;
+  let mut file = std::fs::File::create(&output_path)?;
+  binary_writer
+    .write_bin(
+      &mut file,
+      eszip,
+      &module_specifier,
+      &compile_flags,
+      &ps.options,
+    )
+    .await
+    .with_context(|| format!("Writing {}", output_path.display()))?;
+  drop(file);
 
-  let final_bin = create_standalone_binary(
-    original_binary,
-    eszip,
-    module_specifier,
-    &compile_flags,
-    ps,
-  )
-  .await?;
-
-  log::info!("{} {}", colors::green("Emit"), output_path.display());
-
-  write_standalone_binary(output_path, final_bin).await?;
-  Ok(())
-}
-
-async fn get_base_binary(
-  client: &HttpClient,
-  deno_dir: &DenoDir,
-  target: Option<String>,
-) -> Result<Vec<u8>, AnyError> {
-  if target.is_none() {
-    let path = std::env::current_exe()?;
-    return Ok(tokio::fs::read(path).await?);
+  // set it as executable
+  #[cfg(unix)]
+  {
+    use std::os::unix::fs::PermissionsExt;
+    let perms = std::fs::Permissions::from_mode(0o777);
+    std::fs::set_permissions(output_path, perms)?;
   }
 
-  let target = target.unwrap_or_else(|| env!("TARGET").to_string());
-  let binary_name = format!("deno-{target}.zip");
-
-  let binary_path_suffix = if crate::version::is_canary() {
-    format!("canary/{}/{}", crate::version::GIT_COMMIT_HASH, binary_name)
-  } else {
-    format!("release/v{}/{}", env!("CARGO_PKG_VERSION"), binary_name)
-  };
-
-  let download_directory = deno_dir.dl_folder_path();
-  let binary_path = download_directory.join(&binary_path_suffix);
-
-  if !binary_path.exists() {
-    download_base_binary(client, &download_directory, &binary_path_suffix)
-      .await?;
-  }
-
-  let archive_data = tokio::fs::read(binary_path).await?;
-  let temp_dir = tempfile::TempDir::new()?;
-  let base_binary_path = crate::tools::upgrade::unpack_into_dir(
-    archive_data,
-    target.contains("windows"),
-    &temp_dir,
-  )?;
-  let base_binary = tokio::fs::read(base_binary_path).await?;
-  drop(temp_dir); // delete the temp dir
-  Ok(base_binary)
-}
-
-async fn download_base_binary(
-  client: &HttpClient,
-  output_directory: &Path,
-  binary_path_suffix: &str,
-) -> Result<(), AnyError> {
-  let download_url = format!("https://dl.deno.land/{binary_path_suffix}");
-  let maybe_bytes = {
-    let progress_bars = ProgressBar::new(ProgressBarStyle::DownloadBars);
-    let progress = progress_bars.update(&download_url);
-
-    client
-      .download_with_progress(download_url, &progress)
-      .await?
-  };
-  let bytes = match maybe_bytes {
-    Some(bytes) => bytes,
-    None => {
-      log::info!("Download could not be found, aborting");
-      std::process::exit(1)
-    }
-  };
-
-  std::fs::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?;
   Ok(())
 }
 
-/// This functions creates a standalone deno binary by appending a bundle
-/// and magic trailer to the currently executing binary.
-async fn create_standalone_binary(
-  mut original_bin: Vec<u8>,
-  eszip: eszip::EszipV2,
-  entrypoint: ModuleSpecifier,
-  compile_flags: &CompileFlags,
-  ps: ProcState,
-) -> Result<Vec<u8>, AnyError> {
-  let mut eszip_archive = eszip.into_bytes();
-
-  let ca_data = match ps.options.ca_data() {
-    Some(CaData::File(ca_file)) => {
-      Some(fs::read(ca_file).with_context(|| format!("Reading: {ca_file}"))?)
-    }
-    Some(CaData::Bytes(bytes)) => Some(bytes.clone()),
-    None => None,
-  };
-  let maybe_import_map = ps
-    .options
-    .resolve_import_map(&ps.file_fetcher)
-    .await?
-    .map(|import_map| (import_map.base_url().clone(), import_map.to_json()));
-  let metadata = Metadata {
-    argv: compile_flags.args.clone(),
-    unstable: ps.options.unstable(),
-    seed: ps.options.seed(),
-    location: ps.options.location_flag().clone(),
-    permissions: ps.options.permissions_options(),
-    v8_flags: ps.options.v8_flags().clone(),
-    unsafely_ignore_certificate_errors: ps
-      .options
-      .unsafely_ignore_certificate_errors()
-      .clone(),
-    log_level: ps.options.log_level(),
-    ca_stores: ps.options.ca_stores().clone(),
-    ca_data,
-    entrypoint,
-    maybe_import_map,
-  };
-  let mut metadata = serde_json::to_string(&metadata)?.as_bytes().to_vec();
-
-  let eszip_pos = original_bin.len();
-  let metadata_pos = eszip_pos + eszip_archive.len();
-  let mut trailer = MAGIC_TRAILER.to_vec();
-  trailer.write_all(&eszip_pos.to_be_bytes())?;
-  trailer.write_all(&metadata_pos.to_be_bytes())?;
-
-  let mut final_bin = Vec::with_capacity(
-    original_bin.len() + eszip_archive.len() + trailer.len(),
-  );
-  final_bin.append(&mut original_bin);
-  final_bin.append(&mut eszip_archive);
-  final_bin.append(&mut metadata);
-  final_bin.append(&mut trailer);
-
-  Ok(final_bin)
-}
-
 /// This function writes out a final binary to specified path. If output path
 /// is not already standalone binary it will return error instead.
-async fn write_standalone_binary(
-  output_path: PathBuf,
-  final_bin: Vec<u8>,
-) -> Result<(), AnyError> {
+fn validate_output_path(output_path: &Path) -> Result<(), AnyError> {
   if output_path.exists() {
     // If the output is a directory, throw error
     if output_path.is_dir() {
@@ -240,19 +106,9 @@ async fn write_standalone_binary(
       );
     }
 
-    // Make sure we don't overwrite any file not created by Deno compiler.
-    // Check for magic trailer in last 24 bytes.
-    let mut has_trailer = false;
-    let mut output_file = File::open(&output_path)?;
-    // This seek may fail because the file is too small to possibly be
-    // `deno compile` output.
-    if output_file.seek(SeekFrom::End(-24)).is_ok() {
-      let mut trailer = [0; 24];
-      output_file.read_exact(&mut trailer)?;
-      let (magic_trailer, _) = trailer.split_at(8);
-      has_trailer = magic_trailer == MAGIC_TRAILER;
-    }
-    if !has_trailer {
+    // Make sure we don't overwrite any file not created by Deno compiler because
+    // this filename is chosen automatically in some cases.
+    if !is_standalone_binary(output_path) {
       bail!(
         concat!(
           "Could not compile to file '{}' because the file already exists ",
@@ -265,28 +121,20 @@ async fn write_standalone_binary(
 
     // Remove file if it was indeed a deno compiled binary, to avoid corruption
     // (see https://github.com/denoland/deno/issues/10310)
-    std::fs::remove_file(&output_path)?;
+    std::fs::remove_file(output_path)?;
   } else {
     let output_base = &output_path.parent().unwrap();
     if output_base.exists() && output_base.is_file() {
       bail!(
-        concat!(
-          "Could not compile to file '{}' because its parent directory ",
-          "is an existing file. You can use the `--output <file-path>` flag to ",
-          "provide an alternative name.",
-        ),
-        output_base.display(),
-      );
+          concat!(
+            "Could not compile to file '{}' because its parent directory ",
+            "is an existing file. You can use the `--output <file-path>` flag to ",
+            "provide an alternative name.",
+          ),
+          output_base.display(),
+        );
     }
-    tokio::fs::create_dir_all(output_base).await?;
-  }
-
-  tokio::fs::write(&output_path, final_bin).await?;
-  #[cfg(unix)]
-  {
-    use std::os::unix::fs::PermissionsExt;
-    let perms = std::fs::Permissions::from_mode(0o777);
-    tokio::fs::set_permissions(output_path, perms).await?;
+    std::fs::create_dir_all(output_base)?;
   }
 
   Ok(())