diff --git a/runtime/ops/fs.rs b/runtime/ops/fs.rs
index f6b9a58ebfd97c..8dae9a0913d809 100644
--- a/runtime/ops/fs.rs
+++ b/runtime/ops/fs.rs
@@ -107,6 +107,10 @@ pub fn init() -> Extension {
     .build()
 }
 
+fn default_err_mapper(err: Error, desc: String) -> Error {
+  Error::new(err.kind(), format!("{err}, {desc}"))
+}
+
 #[derive(Deserialize, Default, Debug)]
 #[serde(rename_all = "camelCase")]
 #[serde(default)]
@@ -188,7 +192,7 @@ fn op_open_sync(
   let (path, open_options) =
     open_helper(state, &path, mode, options.as_ref(), "Deno.openSync()")?;
   let std_file = open_options.open(&path).map_err(|err| {
-    Error::new(err.kind(), format!("{}, open '{}'", err, path.display()))
+    default_err_mapper(err, format!("open '{}'", path.display()))
   })?;
   let resource = StdFileResource::fs_file(std_file);
   let rid = state.resource_table.add(resource);
@@ -211,7 +215,7 @@ async fn op_open_async(
   )?;
   let std_file = tokio::task::spawn_blocking(move || {
     open_options.open(&path).map_err(|err| {
-      Error::new(err.kind(), format!("{}, open '{}'", err, path.display()))
+      default_err_mapper(err, format!("open '{}'", path.display()))
     })
   })
   .await?;
@@ -300,7 +304,7 @@ fn write_file(
   data: ZeroCopyBuf,
 ) -> Result<(), AnyError> {
   let mut std_file = open_options.open(path).map_err(|err| {
-    Error::new(err.kind(), format!("{}, open '{}'", err, path.display()))
+    default_err_mapper(err, format!("open '{}'", path.display()))
   })?;
 
   // need to chmod the file if it already exists and a mode is specified
@@ -308,11 +312,9 @@ fn write_file(
   if let Some(mode) = _mode {
     use std::os::unix::fs::PermissionsExt;
     let permissions = PermissionsExt::from_mode(mode & 0o777);
-    std_file
-      .set_permissions(permissions)
-      .map_err(|err: Error| {
-        Error::new(err.kind(), format!("{}, chmod '{}'", err, path.display()))
-      })?;
+    std_file.set_permissions(permissions).map_err(|err| {
+      default_err_mapper(err, format!("chmod '{}'", path.display()))
+    })?;
   }
 
   std_file.write_all(&data)?;
@@ -541,9 +543,8 @@ fn op_chdir(state: &mut OpState, directory: String) -> Result<(), AnyError> {
   state
     .borrow_mut::<PermissionsContainer>()
     .check_read(&d, "Deno.chdir()")?;
-  set_current_dir(&d).map_err(|err| {
-    Error::new(err.kind(), format!("{err}, chdir '{directory}'"))
-  })?;
+  set_current_dir(&d)
+    .map_err(|err| default_err_mapper(err, format!("chdir '{directory}'")))?;
   Ok(())
 }
 
@@ -571,7 +572,7 @@ fn op_mkdir_sync(state: &mut OpState, args: MkdirArgs) -> Result<(), AnyError> {
     builder.mode(mode);
   }
   builder.create(&path).map_err(|err| {
-    Error::new(err.kind(), format!("{}, mkdir '{}'", err, path.display()))
+    default_err_mapper(err, format!("mkdir '{}'", path.display()))
   })?;
   Ok(())
 }
@@ -601,7 +602,7 @@ async fn op_mkdir_async(
       builder.mode(mode);
     }
     builder.create(&path).map_err(|err| {
-      Error::new(err.kind(), format!("{}, mkdir '{}'", err, path.display()))
+      default_err_mapper(err, format!("mkdir '{}'", path.display()))
     })?;
     Ok(())
   })
@@ -646,9 +647,8 @@ async fn op_chmod_async(
 }
 
 fn raw_chmod(path: &Path, _raw_mode: u32) -> Result<(), AnyError> {
-  let err_mapper = |err: Error| {
-    Error::new(err.kind(), format!("{}, chmod '{}'", err, path.display()))
-  };
+  let err_mapper =
+    |err| default_err_mapper(err, format!("chmod '{}'", path.display()));
   #[cfg(unix)]
   {
     use std::os::unix::fs::PermissionsExt;
@@ -755,9 +755,8 @@ fn op_remove_sync(
   #[cfg(not(unix))]
   use std::os::windows::prelude::MetadataExt;
 
-  let err_mapper = |err: Error| {
-    Error::new(err.kind(), format!("{}, remove '{}'", err, path.display()))
-  };
+  let err_mapper =
+    |err| default_err_mapper(err, format!("remove '{}'", path.display()));
   let metadata = std::fs::symlink_metadata(&path).map_err(err_mapper)?;
 
   let file_type = metadata.file_type();
@@ -804,9 +803,8 @@ async fn op_remove_async(
   tokio::task::spawn_blocking(move || {
     #[cfg(not(unix))]
     use std::os::windows::prelude::MetadataExt;
-    let err_mapper = |err: Error| {
-      Error::new(err.kind(), format!("{}, remove '{}'", err, path.display()))
-    };
+    let err_mapper =
+      |err| default_err_mapper(err, format!("remove '{}'", path.display()));
     let metadata = std::fs::symlink_metadata(&path).map_err(err_mapper)?;
 
     debug!("op_remove_async {} {}", path.display(), recursive);
@@ -866,15 +864,10 @@ fn op_copy_file_sync(
     ));
   }
 
-  let err_mapper = |err: Error| {
-    Error::new(
-      err.kind(),
-      format!(
-        "{}, copy '{}' -> '{}'",
-        err,
-        from_path.display(),
-        to_path.display()
-      ),
+  let err_mapper = |err| {
+    default_err_mapper(
+      err,
+      format!("copy '{}' -> '{}'", from_path.display(), to_path.display()),
     )
   };
 
@@ -981,15 +974,13 @@ async fn op_copy_file_async(
         ),
       ));
     }
-
-    let err_mapper = |err: Error| {
-      Error::new(
-        err.kind(),
-        format!("{}, copy '{}' -> '{}'", err, from.display(), to.display()),
-      )
-    };
     // returns size of from as u64 (we ignore)
-    std::fs::copy(&from, &to).map_err(err_mapper)?;
+    std::fs::copy(&from, &to).map_err(|err| {
+      default_err_mapper(
+        err,
+        format!("copy '{}' -> '{}'", from.display(), to.display()),
+      )
+    })?;
     Ok(())
   })
   .await
@@ -1125,9 +1116,8 @@ fn op_stat_sync(
   state
     .borrow_mut::<PermissionsContainer>()
     .check_read(&path, "Deno.statSync()")?;
-  let err_mapper = |err: Error| {
-    Error::new(err.kind(), format!("{}, stat '{}'", err, path.display()))
-  };
+  let err_mapper =
+    |err| default_err_mapper(err, format!("stat '{}'", path.display()));
   let metadata = if lstat {
     std::fs::symlink_metadata(&path).map_err(err_mapper)?
   } else {
@@ -1157,9 +1147,8 @@ async fn op_stat_async(
 
   tokio::task::spawn_blocking(move || {
     debug!("op_stat_async {} {}", path.display(), lstat);
-    let err_mapper = |err: Error| {
-      Error::new(err.kind(), format!("{}, stat '{}'", err, path.display()))
-    };
+    let err_mapper =
+      |err| default_err_mapper(err, format!("stat '{}'", path.display()));
     let metadata = if lstat {
       std::fs::symlink_metadata(&path).map_err(err_mapper)?
     } else {
@@ -1249,11 +1238,11 @@ fn op_read_dir_sync(
     .check_read(&path, "Deno.readDirSync()")?;
 
   debug!("op_read_dir_sync {}", path.display());
-  let err_mapper = |err: Error| {
-    Error::new(err.kind(), format!("{}, readdir '{}'", err, path.display()))
-  };
+
   let entries: Vec<_> = std::fs::read_dir(&path)
-    .map_err(err_mapper)?
+    .map_err(|err| {
+      default_err_mapper(err, format!("readdir '{}'", path.display()))
+    })?
     .filter_map(|entry| {
       let entry = entry.unwrap();
       // Not all filenames can be encoded as UTF-8. Skip those for now.
@@ -1293,11 +1282,11 @@ async fn op_read_dir_async(
   }
   tokio::task::spawn_blocking(move || {
     debug!("op_read_dir_async {}", path.display());
-    let err_mapper = |err: Error| {
-      Error::new(err.kind(), format!("{}, readdir '{}'", err, path.display()))
-    };
+
     let entries: Vec<_> = std::fs::read_dir(&path)
-      .map_err(err_mapper)?
+      .map_err(|err| {
+        default_err_mapper(err, format!("readdir '{}'", path.display()))
+      })?
       .filter_map(|entry| {
         let entry = entry.unwrap();
         // Not all filenames can be encoded as UTF-8. Skip those for now.
@@ -1340,18 +1329,12 @@ fn op_rename_sync(
   permissions.check_write(&oldpath, "Deno.renameSync()")?;
   permissions.check_write(&newpath, "Deno.renameSync()")?;
 
-  let err_mapper = |err: Error| {
-    Error::new(
-      err.kind(),
-      format!(
-        "{}, rename '{}' -> '{}'",
-        err,
-        oldpath.display(),
-        newpath.display()
-      ),
+  std::fs::rename(&oldpath, &newpath).map_err(|err| {
+    default_err_mapper(
+      err,
+      format!("rename '{}' -> '{}'", oldpath.display(), newpath.display()),
     )
-  };
-  std::fs::rename(&oldpath, &newpath).map_err(err_mapper)?;
+  })?;
   Ok(())
 }
 
@@ -1370,19 +1353,14 @@ async fn op_rename_async(
     permissions.check_write(&oldpath, "Deno.rename()")?;
     permissions.check_write(&newpath, "Deno.rename()")?;
   }
+
   tokio::task::spawn_blocking(move || {
-    let err_mapper = |err: Error| {
-      Error::new(
-        err.kind(),
-        format!(
-          "{}, rename '{}' -> '{}'",
-          err,
-          oldpath.display(),
-          newpath.display()
-        ),
+    std::fs::rename(&oldpath, &newpath).map_err(|err| {
+      default_err_mapper(
+        err,
+        format!("rename '{}' -> '{}'", oldpath.display(), newpath.display()),
       )
-    };
-    std::fs::rename(&oldpath, &newpath).map_err(err_mapper)?;
+    })?;
     Ok(())
   })
   .await
@@ -1404,18 +1382,12 @@ fn op_link_sync(
   permissions.check_read(&newpath, "Deno.linkSync()")?;
   permissions.check_write(&newpath, "Deno.linkSync()")?;
 
-  let err_mapper = |err: Error| {
-    Error::new(
-      err.kind(),
-      format!(
-        "{}, link '{}' -> '{}'",
-        err,
-        oldpath.display(),
-        newpath.display()
-      ),
+  std::fs::hard_link(&oldpath, &newpath).map_err(|err| {
+    default_err_mapper(
+      err,
+      format!("link '{}' -> '{}'", oldpath.display(), newpath.display()),
     )
-  };
-  std::fs::hard_link(&oldpath, &newpath).map_err(err_mapper)?;
+  })?;
   Ok(())
 }
 
@@ -1438,15 +1410,10 @@ async fn op_link_async(
   }
 
   tokio::task::spawn_blocking(move || {
-    let err_mapper = |err: Error| {
-      Error::new(
-        err.kind(),
-        format!(
-          "{}, link '{}' -> '{}'",
-          err,
-          oldpath.display(),
-          newpath.display()
-        ),
+    let err_mapper = |err| {
+      default_err_mapper(
+        err,
+        format!("link '{}' -> '{}'", oldpath.display(), newpath.display()),
       )
     };
     std::fs::hard_link(&oldpath, &newpath).map_err(err_mapper)?;
@@ -1473,17 +1440,13 @@ fn op_symlink_sync(
     .borrow_mut::<PermissionsContainer>()
     .check_read_all("Deno.symlinkSync()")?;
 
-  let err_mapper = |err: Error| {
-    Error::new(
-      err.kind(),
-      format!(
-        "{}, symlink '{}' -> '{}'",
-        err,
-        oldpath.display(),
-        newpath.display()
-      ),
+  let err_mapper = |err| {
+    default_err_mapper(
+      err,
+      format!("symlink '{}' -> '{}'", oldpath.display(), newpath.display()),
     )
   };
+
   #[cfg(unix)]
   {
     use std::os::unix::fs::symlink;
@@ -1540,17 +1503,12 @@ async fn op_symlink_async(
   }
 
   tokio::task::spawn_blocking(move || {
-    let err_mapper = |err: Error| {
-      Error::new(
-        err.kind(),
-        format!(
-          "{}, symlink '{}' -> '{}'",
-          err,
-          oldpath.display(),
-          newpath.display()
-        ),
-      )
-    };
+    let err_mapper = |err| default_err_mapper(err, format!(
+      "symlink '{}' -> '{}'",
+      oldpath.display(),
+      newpath.display()
+    ));
+
     #[cfg(unix)]
     {
       use std::os::unix::fs::symlink;
@@ -1600,14 +1558,10 @@ fn op_read_link_sync(
     .check_read(&path, "Deno.readLink()")?;
 
   debug!("op_read_link_value {}", path.display());
-  let err_mapper = |err: Error| {
-    Error::new(
-      err.kind(),
-      format!("{}, readlink '{}'", err, path.display()),
-    )
-  };
   let target = std::fs::read_link(&path)
-    .map_err(err_mapper)?
+    .map_err(|err| {
+      default_err_mapper(err, format!("readlink '{}'", path.display()))
+    })?
     .into_os_string();
   let targetstr = into_string(target)?;
   Ok(targetstr)
@@ -1627,14 +1581,10 @@ async fn op_read_link_async(
   }
   tokio::task::spawn_blocking(move || {
     debug!("op_read_link_async {}", path.display());
-    let err_mapper = |err: Error| {
-      Error::new(
-        err.kind(),
-        format!("{}, readlink '{}'", err, path.display()),
-      )
-    };
     let target = std::fs::read_link(&path)
-      .map_err(err_mapper)?
+      .map_err(|err| {
+        default_err_mapper(err, format!("readlink '{}'", path.display()))
+      })?
       .into_os_string();
     let targetstr = into_string(target)?;
     Ok(targetstr)
@@ -1684,12 +1634,8 @@ fn op_truncate_sync(
     .check_write(&path, "Deno.truncateSync()")?;
 
   debug!("op_truncate_sync {} {}", path.display(), len);
-  let err_mapper = |err: Error| {
-    Error::new(
-      err.kind(),
-      format!("{}, truncate '{}'", err, path.display()),
-    )
-  };
+  let err_mapper =
+    |err| default_err_mapper(err, format!("truncate '{}'", path.display()));
   let f = std::fs::OpenOptions::new()
     .write(true)
     .open(&path)
@@ -1714,12 +1660,8 @@ async fn op_truncate_async(
   }
   tokio::task::spawn_blocking(move || {
     debug!("op_truncate_async {} {}", path.display(), len);
-    let err_mapper = |err: Error| {
-      Error::new(
-        err.kind(),
-        format!("{}, truncate '{}'", err, path.display()),
-      )
-    };
+    let err_mapper =
+      |err| default_err_mapper(err, format!("truncate '{}'", path.display()));
     let f = std::fs::OpenOptions::new()
       .write(true)
       .open(&path)
@@ -1966,7 +1908,7 @@ fn op_utime_sync(
     .borrow_mut::<PermissionsContainer>()
     .check_write(&path, "Deno.utime()")?;
   filetime::set_file_times(&path, atime, mtime).map_err(|err| {
-    Error::new(err.kind(), format!("{}, utime '{}'", err, path.display()))
+    default_err_mapper(err, format!("utime '{}'", path.display()))
   })?;
   Ok(())
 }
@@ -1991,7 +1933,7 @@ async fn op_utime_async(
 
   tokio::task::spawn_blocking(move || {
     filetime::set_file_times(&path, atime, mtime).map_err(|err| {
-      Error::new(err.kind(), format!("{}, utime '{}'", err, path.display()))
+      default_err_mapper(err, format!("utime '{}'", path.display()))
     })?;
     Ok(())
   })
@@ -2018,7 +1960,13 @@ fn op_readfile_sync(
   state
     .borrow_mut::<PermissionsContainer>()
     .check_read(path, "Deno.readFileSync()")?;
-  Ok(std::fs::read(path)?.into())
+  Ok(
+    std::fs::read(path)
+      .map_err(|err| {
+        default_err_mapper(err, format!("readfile '{}'", path.display()))
+      })?
+      .into(),
+  )
 }
 
 #[op]
@@ -2030,7 +1978,9 @@ fn op_readfile_text_sync(
   state
     .borrow_mut::<PermissionsContainer>()
     .check_read(path, "Deno.readTextFileSync()")?;
-  Ok(string_from_utf8_lossy(std::fs::read(path)?))
+  Ok(string_from_utf8_lossy(std::fs::read(path).map_err(
+    |err| default_err_mapper(err, format!("readfile '{}'", path.display())),
+  )?))
 }
 
 #[op]
@@ -2048,7 +1998,9 @@ async fn op_readfile_async(
   }
   let fut = tokio::task::spawn_blocking(move || {
     let path = Path::new(&path);
-    Ok(std::fs::read(path).map(ZeroCopyBuf::from)?)
+    Ok(std::fs::read(path).map(ZeroCopyBuf::from).map_err(|err| {
+      default_err_mapper(err, format!("readfile '{}'", path.display()))
+    })?)
   });
   if let Some(cancel_rid) = cancel_rid {
     let cancel_handle = state
@@ -2077,7 +2029,9 @@ async fn op_readfile_text_async(
   }
   let fut = tokio::task::spawn_blocking(move || {
     let path = Path::new(&path);
-    Ok(string_from_utf8_lossy(std::fs::read(path)?))
+    Ok(string_from_utf8_lossy(std::fs::read(path).map_err(
+      |err| default_err_mapper(err, format!("readfile '{}'", path.display())),
+    )?))
   });
   if let Some(cancel_rid) = cancel_rid {
     let cancel_handle = state