diff --git a/src/aot/lower/transpiled.rs b/src/aot/lower/transpiled.rs
index bc3262772b2a..3be0c209118d 100644
--- a/src/aot/lower/transpiled.rs
+++ b/src/aot/lower/transpiled.rs
@@ -146,6 +146,7 @@ impl RuntimeTranspiler<'_> {
         options.tree_shaking = true;
         options.warn_about_unbundled_modules = false;
         options.use_define_for_class_fields = !request.assigns_class_fields;
+        options.keep_parameter_lists_as_written = true;
         let features = &mut options.features;
         features.standard_decorators = !request.has_legacy_decorators;
         features.allow_runtime = true;
diff --git a/src/ast/ast_result.rs b/src/ast/ast_result.rs
index 1ab68574a4fd..10701d94071b 100644
--- a/src/ast/ast_result.rs
+++ b/src/ast/ast_result.rs
@@ -10,8 +10,8 @@ use bun_collections::{ArrayHashMap, StringArrayHashMap, StringHashMap};
 
 use crate::runtime;
 use crate::{
-    CharFreq, ExportsKind, Expr, InlinedEnumValue, LocRef, NamedExport, NamedImport, Part, Range,
-    Ref, Scope, SlotCounts, StoreStr, Target,
+    CharFreq, ExportsKind, Expr, InlinedEnumValue, LocRef, NamedExport, NamedImport,
+    ParameterListsAsWritten, Part, Range, Ref, Scope, SlotCounts, StoreStr, Target,
 };
 
 use crate::part::List as PartList;
@@ -104,6 +104,8 @@ pub struct Ast<'a> {
     pub import_meta_ref: Ref,
     /// Output depends on more than the source text (macros, `import.meta.glob`), so don't cache it.
     pub depends_on_more_than_source: bool,
+    /// Filled for a module the runtime loads.
+    pub parameter_lists_as_written: ParameterListsAsWritten,
 }
 
 // `parts`/`symbols`/`import_records` are now `ArenaVec`s and need an allocator,
@@ -150,8 +152,14 @@ impl<'a> Ast<'a> {
             has_import_meta: false,
             import_meta_ref: Ref::NONE,
             depends_on_more_than_source: false,
+            parameter_lists_as_written: Default::default(),
         }
     }
+
+    /// What the printer takes: `None` when no list is kept, so that it tests one pointer for each function.
+    pub fn kept_parameter_lists(&self) -> Option<&ParameterListsAsWritten> {
+        (!self.parameter_lists_as_written.is_empty()).then_some(&self.parameter_lists_as_written)
+    }
 }
 
 pub struct CommonJSNamedExport {
diff --git a/src/ast/lib.rs b/src/ast/lib.rs
index 586657d54ac8..3b826b688deb 100644
--- a/src/ast/lib.rs
+++ b/src/ast/lib.rs
@@ -2623,6 +2623,7 @@ pub mod runtime;
 pub mod ast_result;
 pub mod import_record;
 pub mod loader;
+pub mod parameter_list_as_written;
 pub mod target;
 
 pub use ast_result::{
@@ -2631,6 +2632,7 @@ pub use ast_result::{
 };
 pub use import_record::{Flags as ImportRecordFlags, ImportRecord, Tag as ImportRecordTag};
 pub use loader::{Loader, LoaderHashTable, SideEffects};
+pub use parameter_list_as_written::ParameterListsAsWritten;
 pub use target::Target;
 pub mod transpiler_cache;
 // Glob re-export: `link_interface!` emits `#[doc(hidden)]` type aliases that
diff --git a/src/ast/parameter_list_as_written.rs b/src/ast/parameter_list_as_written.rs
new file mode 100644
index 000000000000..d88605a8afc7
--- /dev/null
+++ b/src/ast/parameter_list_as_written.rs
@@ -0,0 +1,282 @@
+//! The runtime prints a parameter list that holds a comment as it is written: an injector reads `/* token */ name` from `fn.toString()`.
+
+use bun_alloc::AstAlloc;
+use bun_collections::ArrayHashMap;
+use bun_collections::array_hash_map::AutoContext;
+use bun_core::strings;
+
+use crate::StoreStr;
+
+/// The key is where the printer finds the list again: the `(` of a function, the start of an arrow function.
+pub type ParameterListsAsWritten = ArrayHashMap<i32, StoreStr, AutoContext, AstAlloc>;
+
+/// `mentionsOriginalModule` (src/jsc/bindings/BunPlugin.cpp) takes each of these, anywhere in the text of a `mock.module` factory, as a mention of the original module.
+const READ_BY_MOCK_MODULE: [&[u8]; 3] = [b"importOriginal", b"importActual", b"requireActual"];
+
+/// The text up to the `)` of the list that starts at `after_open_paren`, if the printer is to write it: plain names and a comment.
+pub fn text_to_keep(after_open_paren: &[u8]) -> Option<&[u8]> {
+    let mut names = Names::new(after_open_paren);
+    while names.next_name().ok()?.is_some() {}
+    let (text, rest) = after_open_paren.split_at(names.position);
+    let is_kept = names.has_comment
+        && rest.first() == Some(&b')')
+        && !READ_BY_MOCK_MODULE
+            .iter()
+            .any(|word| strings::contains(text, word));
+    is_kept.then_some(text)
+}
+
+pub struct Name {
+    pub start: usize,
+    pub end: usize,
+    /// `...` stands before it.
+    pub is_rest: bool,
+}
+
+/// The text is not a list of names with a comma between them, `...` before the last at most, ASCII whitespace and ASCII comments.
+#[derive(Debug)]
+pub struct NotPlainNames;
+
+/// The names in the text between the parentheses of a parameter list.
+pub struct Names<'a> {
+    text: &'a [u8],
+    position: usize,
+    has_comment: bool,
+    /// A name was passed, and no comma after it.
+    is_after_name: bool,
+    /// That name has `...` before it: nothing but whitespace and comments follows it.
+    is_after_rest: bool,
+}
+
+impl<'a> Names<'a> {
+    pub fn new(text: &'a [u8]) -> Self {
+        Names {
+            text,
+            position: 0,
+            has_comment: false,
+            is_after_name: false,
+            is_after_rest: false,
+        }
+    }
+
+    /// `Ok(None)` at the end of the list: the end of the text, or a `)`.
+    pub fn next_name(&mut self) -> Result<Option<Name>, NotPlainNames> {
+        let text = self.text;
+        let mut at = self.position;
+        let mut is_rest = false;
+        let found = loop {
+            match text.get(at).copied() {
+                Some(b' ' | b'\t' | b'\n' | b'\r' | 0x0B | 0x0C) => at += 1,
+                Some(b'/') => match end_of_comment(text, at) {
+                    Some(end) => {
+                        at = end;
+                        self.has_comment = true;
+                    }
+                    None => break Err(NotPlainNames),
+                },
+                None | Some(b')') if !is_rest => break Ok(None),
+                Some(b',') if self.is_after_name && !self.is_after_rest => {
+                    self.is_after_name = false;
+                    at += 1;
+                }
+                Some(b'.') if !self.is_after_name && !is_rest && text[at..].starts_with(b"...") => {
+                    is_rest = true;
+                    at += 3;
+                }
+                Some(b'a'..=b'z' | b'A'..=b'Z' | b'_' | b'$') if !self.is_after_name => {
+                    let start = at;
+                    while text.get(at).is_some_and(|&byte| is_name_byte(byte)) {
+                        at += 1;
+                    }
+                    self.is_after_name = true;
+                    self.is_after_rest = is_rest;
+                    break Ok(Some(Name {
+                        start,
+                        end: at,
+                        is_rest,
+                    }));
+                }
+                _ => break Err(NotPlainNames),
+            }
+        };
+        self.position = at;
+        found
+    }
+}
+
+fn is_name_byte(byte: u8) -> bool {
+    byte.is_ascii_alphanumeric() || byte == b'_' || byte == b'$'
+}
+
+/// `text[at]` is `/`. The end of the ASCII comment that starts there, if it ends inside the text: a line comment ends before its line terminator.
+fn end_of_comment(text: &[u8], at: usize) -> Option<usize> {
+    let body = text.get(at + 2..)?;
+    let length = match (text[at + 1], body.first()) {
+        // The printer writes a comment that starts with `!` by itself, into the body of the function.
+        (_, Some(b'!')) => return None,
+        (b'*', _) => strings::index_of(body, b"*/")? + 2,
+        // JavaScriptCore reads `sourceURL=` and `sourceMappingURL=` from a comment that starts with `//#` or `//@`.
+        (b'/', Some(b'#' | b'@')) => return None,
+        (b'/', _) => strings::index_of_any(body, b"\r\n")?,
+        _ => return None,
+    };
+    body[..length].is_ascii().then_some(at + 2 + length)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    /// `None`: not a list of plain names.
+    fn names_of(text: &str) -> Option<(Vec<String>, bool)> {
+        let mut names = Names::new(text.as_bytes());
+        let mut found = Vec::new();
+        while let Some(name) = names.next_name().ok()? {
+            let spelling = &text[name.start..name.end];
+            found.push(if name.is_rest {
+                format!("...{spelling}")
+            } else {
+                spelling.to_owned()
+            });
+        }
+        Some((found, names.has_comment))
+    }
+
+    fn commented(names: &[&str]) -> Option<(Vec<String>, bool)> {
+        Some((names.iter().map(|&name| name.to_owned()).collect(), true))
+    }
+
+    fn kept(after_open_paren: &str) -> Option<&str> {
+        text_to_keep(after_open_paren.as_bytes()).map(|text| core::str::from_utf8(text).unwrap())
+    }
+
+    #[test]
+    fn names_and_comments() {
+        assert_eq!(
+            names_of("/* config */config, /* config.proxies */proxies"),
+            commented(&["config", "proxies"])
+        );
+        assert_eq!(
+            names_of("a /* after */, $b_1 // line\n"),
+            commented(&["a", "$b_1"])
+        );
+        assert_eq!(names_of("/* a, b) */"), commented(&[]));
+        assert_eq!(
+            names_of(" a,\r\n\tb, "),
+            Some((vec!["a".into(), "b".into()], false))
+        );
+        assert_eq!(names_of(""), Some((vec![], false)));
+    }
+
+    #[test]
+    fn rest_parameter() {
+        assert_eq!(
+            names_of("a, /* all */ ...rest"),
+            commented(&["a", "...rest"])
+        );
+        assert_eq!(names_of("... /* all */ rest"), commented(&["...rest"]));
+        assert_eq!(names_of("a, ..."), None);
+        assert_eq!(names_of("......a"), None);
+        assert_eq!(names_of("..a"), None);
+        assert_eq!(names_of("...,a"), None);
+    }
+
+    #[test]
+    fn what_is_not_a_plain_name() {
+        for text in [
+            "a = 1",
+            "{ a }",
+            "[a]",
+            "a: number",
+            "a?",
+            "@inject a",
+            "a /* \u{e9} */",
+            "a // \u{e9}\n",
+            "\u{e9}",
+            "a\\u0062",
+            "a <!-- b\n",
+            "a / b",
+            "1",
+            "a b",
+            ",a",
+            "a,,b",
+            "a ...b",
+            "...a, b",
+            "...a,",
+        ] {
+            assert_eq!(names_of(text), None, "{text}");
+        }
+    }
+
+    #[test]
+    fn a_comment_ends_inside_the_text() {
+        assert_eq!(names_of("a /* open"), None);
+        assert_eq!(names_of("a // no line terminator"), None);
+        assert_eq!(names_of("a /"), None);
+        assert_eq!(names_of("a // ends\r"), commented(&["a"]));
+        assert_eq!(names_of("/**/"), commented(&[]));
+        assert_eq!(names_of("/*/ a */ b"), commented(&["b"]));
+    }
+
+    #[test]
+    fn a_line_comment_that_can_hold_a_directive_is_not_passed() {
+        assert_eq!(names_of("a, //# sourceURL=x.js\n b"), None);
+        assert_eq!(names_of("a, //@ sourceMappingURL=x\n b"), None);
+        assert_eq!(names_of("a, //#region\n b"), None);
+        assert_eq!(
+            names_of("a, // # sourceURL=x.js\n b"),
+            commented(&["a", "b"])
+        );
+        assert_eq!(names_of("/*# sourceURL=x.js */ a"), commented(&["a"]));
+    }
+
+    #[test]
+    fn a_comment_that_the_printer_writes_by_itself_is_not_passed() {
+        assert_eq!(names_of("/*! legal */ a"), None);
+        assert_eq!(names_of("a, //! legal\n b"), None);
+        assert_eq!(names_of("/* ! */ a"), commented(&["a"]));
+    }
+
+    #[test]
+    fn a_keyword_is_a_name_here() {
+        // The parser leaves a TypeScript `this` parameter out of the arguments, so the printer finds another name.
+        assert_eq!(names_of("this, /* c */ a"), commented(&["this", "a"]));
+        assert_eq!(names_of("public /* c */ a"), None);
+    }
+
+    #[test]
+    fn the_list_ends_at_a_close_paren() {
+        assert_eq!(names_of("a) { b }"), Some((vec!["a".into()], false)));
+        assert_eq!(names_of("a, /* c */ b,) => a"), commented(&["a", "b"]));
+        assert_eq!(names_of("a, ...) {}"), None);
+    }
+
+    #[test]
+    fn the_text_to_keep_ends_before_the_close_paren() {
+        assert_eq!(kept("a, /* c */ b) { return a; }"), Some("a, /* c */ b"));
+        assert_eq!(kept("/* none */) => 1"), Some("/* none */"));
+        assert_eq!(kept("a, // c\n  b,\n) {}"), Some("a, // c\n  b,\n"));
+    }
+
+    #[test]
+    fn no_text_is_kept() {
+        for after_open_paren in [
+            "a, b) /* c */ => a",
+            "/* c */ a = 1) {}",
+            "/* c */ a: string) {}",
+            "/* c */ a, { b }) {}",
+            "/* c */ a",
+            "/* c */",
+            "/* c */ ...) {}",
+            "/* c */ a b) {}",
+            "/* c */ ,a) {}",
+            "/* c */ ...a, b) {}",
+            "/*! legal */ a) {}",
+            "/* importOriginal */ load) => load()",
+            "load /* see vi.importActual */) => load()",
+            "/* c */ requireActual) => 1",
+        ] {
+            assert_eq!(kept(after_open_paren), None, "{after_open_paren}");
+        }
+    }
+}
diff --git a/src/bundler/aot/services.rs b/src/bundler/aot/services.rs
index 6952f1baba92..faa17b965ada 100644
--- a/src/bundler/aot/services.rs
+++ b/src/bundler/aot/services.rs
@@ -332,6 +332,7 @@ impl SourceProvider for BundlerServices {
                     ExportsKind::Cjs => crate::options::Format::Cjs,
                     _ => crate::options::Format::Esm,
                 },
+                parameter_lists_as_written: tree.kept_parameter_lists(),
                 ..Default::default()
             };
             let printed = js_printer::print::<false>(
diff --git a/src/bundler/transpiler.rs b/src/bundler/transpiler.rs
index 90e748d3c5c4..f579966dd492 100644
--- a/src/bundler/transpiler.rs
+++ b/src/bundler/transpiler.rs
@@ -1503,6 +1503,7 @@ impl<'a> Transpiler<'a> {
                     output_format: p_opts::Format::Esm,
                     transform_only: self.options.transform_only,
                     import_meta_glob: None,
+                    keep_parameter_lists_as_written: false,
                     import_meta_main_value: None,
                     lower_import_meta_main_for_node_js: false,
                     framework: None,
@@ -1630,6 +1631,7 @@ impl<'a> Transpiler<'a> {
                     // SAFETY: the resolver outlives the parse, which only calls it from this thread.
                     opts.import_meta_glob =
                         Some(unsafe { Resolver::import_meta_glob_host(&raw mut self.resolver) });
+                    opts.keep_parameter_lists_as_written = true;
                 }
 
                 // spec calls `transpiler.resolver.caches.js.parse`.
@@ -2483,6 +2485,7 @@ impl<'a> Transpiler<'a> {
             module_info,
             hmr_ref: ast.wrapper_ref,
             mangled_props: None,
+            parameter_lists_as_written: ast.kept_parameter_lists(),
             // The printer reads `opts.target` at
             // js_printer/lib.rs:6872 to gate the `var {require}=import.meta;`
             // hoist on `Target::Bun` — defaulting to `Browser` here regressed
diff --git a/src/js_parser/lexer.rs b/src/js_parser/lexer.rs
index b7620f767699..ff4c63607c57 100644
--- a/src/js_parser/lexer.rs
+++ b/src/js_parser/lexer.rs
@@ -157,6 +157,7 @@ pub struct LexerSnapshot<'a> {
     pub(crate) preserve_all_comments_before: bool,
     pub(crate) is_legacy_octal_literal: bool,
     pub(crate) is_log_disabled: bool,
+    pub(crate) last_comment_end: Loc,
     pub(crate) code_point: CodePoint,
     pub(crate) identifier: &'a [u8],
     pub(crate) jsx_pragma: JSXPragma,
@@ -226,6 +227,7 @@ pub struct Lexer<'a> {
     pub(crate) is_legacy_octal_literal: bool,
     pub(crate) is_log_disabled: bool,
     pub(crate) comments_to_preserve_before: Vec<js_ast::G::Comment>,
+    pub(crate) last_comment_end: Loc,
     pub(crate) code_point: CodePoint,
     pub(crate) identifier: &'a [u8],
     pub(crate) jsx_pragma: JSXPragma,
@@ -301,6 +303,12 @@ impl<'a> Lexer<'a> {
         bun_ast::usize2loc(self.start)
     }
 
+    /// A comment stands between the token at `loc` and the current token.
+    #[inline]
+    pub(crate) fn has_comment_after(&self, loc: Loc) -> bool {
+        self.last_comment_end.start > loc.start
+    }
+
     #[cold]
     pub(crate) fn add_range_error_with_notes(
         &mut self,
@@ -342,6 +350,7 @@ impl<'a> Lexer<'a> {
             preserve_all_comments_before: self.preserve_all_comments_before,
             is_legacy_octal_literal: self.is_legacy_octal_literal,
             is_log_disabled: self.is_log_disabled,
+            last_comment_end: self.last_comment_end,
             code_point: self.code_point,
             identifier: self.identifier,
             jsx_pragma: self.jsx_pragma,
@@ -379,6 +388,7 @@ impl<'a> Lexer<'a> {
         self.preserve_all_comments_before = original.preserve_all_comments_before;
         self.is_legacy_octal_literal = original.is_legacy_octal_literal;
         self.is_log_disabled = original.is_log_disabled;
+        self.last_comment_end = original.last_comment_end;
         self.code_point = original.code_point;
         self.identifier = original.identifier;
         self.jsx_pragma = original.jsx_pragma;
@@ -1905,6 +1915,7 @@ impl<'a> Lexer<'a> {
     }
 
     fn scan_comment_text(&mut self, for_pragma: bool) {
+        self.last_comment_end = bun_ast::usize2loc(self.end);
         let text = &self.contents[self.start..self.end];
         let has_legal_annotation = text.len() > 2 && text[2] == b'!';
         let is_multiline_comment = text.len() > 1 && text[1] == b'*';
@@ -2268,6 +2279,7 @@ impl<'a> Lexer<'a> {
             is_legacy_octal_literal: false,
             is_log_disabled: false,
             comments_to_preserve_before: Vec::new(),
+            last_comment_end: Loc::EMPTY,
             code_point: -1,
             identifier: b"",
             jsx_pragma: JSXPragma::default(),
diff --git a/src/js_parser/p.rs b/src/js_parser/p.rs
index 7af9d48c2bda..1a10420807b8 100644
--- a/src/js_parser/p.rs
+++ b/src/js_parser/p.rs
@@ -357,6 +357,8 @@ pub struct P<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> {
     pub(crate) stack_check: bun_core::StackCheck,
     /// `Parser::parse_only`: where what does not say so itself starts.
     pub(crate) starts_for_parse_only: Option<StartsForParseOnly>,
+    /// See `record_parameter_list_as_written`.
+    pub(crate) parameter_lists_as_written: js_ast::ParameterListsAsWritten,
 
     pub(crate) reported_stack_overflow: core::cell::Cell<bool>,
 
@@ -9460,6 +9462,7 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
             ts_enums,
             import_meta_ref: self.import_meta_ref,
             depends_on_more_than_source: self.depends_on_more_than_source(),
+            parameter_lists_as_written: core::mem::take(&mut self.parameter_lists_as_written),
 
             symbols,
             parts: parts_list,
@@ -9745,6 +9748,7 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
             log,
             stack_check: bun_core::StackCheck::init(),
             starts_for_parse_only: None,
+            parameter_lists_as_written: Default::default(),
             reported_stack_overflow: core::cell::Cell::new(false),
             ts_infer_constraint_backtracks: Vec::new(),
             ts_conditional_arrow_attempts: Vec::new(),
diff --git a/src/js_parser/parse/mod.rs b/src/js_parser/parse/mod.rs
index 40705ba79a14..0fb2ad26ee05 100644
--- a/src/js_parser/parse/mod.rs
+++ b/src/js_parser/parse/mod.rs
@@ -419,10 +419,11 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
         }
     }
 
-    /// This assumes that the open parenthesis has already been parsed by the caller
+    /// This assumes that the open parenthesis, which is at `open_paren_loc`, has already been parsed by the caller
     pub(crate) fn parse_paren_expr(
         &mut self,
         loc: bun_ast::Loc,
+        open_paren_loc: bun_ast::Loc,
         level: Level,
         opts: ParenExprOpts,
     ) -> Result<Expr, Error> {
@@ -603,6 +604,9 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
                     }
                 }
                 let args_slice: &'a mut [G::Arg] = args.into_bump_slice_mut();
+                if p.lexer.has_comment_after(open_paren_loc) {
+                    p.record_parameter_list_as_written(loc, open_paren_loc);
+                }
                 let mut arrow = p.parse_arrow_body(args_slice, &mut arrow_data)?;
                 arrow.is_async = opts.is_async;
                 arrow.has_rest_arg = spread_range.len > 0;
@@ -1717,9 +1721,11 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
                 // "async()"
                 // "async () => {}"
                 T::TOpenParen => {
+                    let open_paren_loc = p.lexer.loc();
                     p.lexer.next()?;
                     return p.parse_paren_expr(
                         async_range.loc,
+                        open_paren_loc,
                         level,
                         ParenExprOpts {
                             is_async: true,
@@ -1741,9 +1747,11 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
                             )? {
                             SkipTypeParameterResult::DidNotSkipAnything => {}
                             result => {
+                                let open_paren_loc = p.lexer.loc();
                                 p.lexer.next()?;
                                 return p.parse_paren_expr(
                                     async_range.loc,
+                                    open_paren_loc,
                                     level,
                                     ParenExprOpts {
                                         is_async: true,
diff --git a/src/js_parser/parse/parse_entry.rs b/src/js_parser/parse/parse_entry.rs
index 026bfc8ba168..0874a50fb6bf 100644
--- a/src/js_parser/parse/parse_entry.rs
+++ b/src/js_parser/parse/parse_entry.rs
@@ -179,6 +179,9 @@ pub struct Options<'a> {
     /// `None` leaves `import.meta.glob()` calls untouched.
     pub import_meta_glob: Option<crate::ImportMetaGlobHost>,
 
+    /// Fills `Ast::parameter_lists_as_written`.
+    pub keep_parameter_lists_as_written: bool,
+
     /// Used for inlining the state of import.meta.main during visiting
     pub import_meta_main_value: Option<bool>,
     pub lower_import_meta_main_for_node_js: bool,
@@ -230,6 +233,7 @@ impl<'a> Default for Options<'a> {
             output_format: options::Format::Esm,
             transform_only: false,
             import_meta_glob: None,
+            keep_parameter_lists_as_written: false,
             import_meta_main_value: None,
             lower_import_meta_main_for_node_js: false,
             framework: None,
@@ -325,6 +329,7 @@ impl<'a> Options<'a> {
             output_format: self.output_format,
             transform_only: self.transform_only,
             import_meta_glob: self.import_meta_glob,
+            keep_parameter_lists_as_written: self.keep_parameter_lists_as_written,
             import_meta_main_value: self.import_meta_main_value,
             lower_import_meta_main_for_node_js: self.lower_import_meta_main_for_node_js,
             framework: self.framework,
@@ -409,6 +414,7 @@ impl<'a> Options<'a> {
             output_format: options::Format::Esm,
             transform_only: false,
             import_meta_glob: None,
+            keep_parameter_lists_as_written: false,
             import_meta_main_value: None,
             lower_import_meta_main_for_node_js: false,
             framework: None,
diff --git a/src/js_parser/parse/parse_fn.rs b/src/js_parser/parse/parse_fn.rs
index 6555dfa0f358..d8a28f00f48c 100644
--- a/src/js_parser/parse/parse_fn.rs
+++ b/src/js_parser/parse/parse_fn.rs
@@ -160,6 +160,34 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
         Ok(p.s(S::Function { func }, loc))
     }
 
+    /// A comment was scanned after the `(` at `open_paren`. `key` is where the printer finds the list: see `bun_ast::parameter_list_as_written`.
+    #[cold]
+    #[inline(never)]
+    pub(crate) fn record_parameter_list_as_written(
+        &mut self,
+        key: bun_ast::Loc,
+        open_paren: bun_ast::Loc,
+    ) {
+        if !self.options.keep_parameter_lists_as_written {
+            return;
+        }
+        let contents: &'a [u8] = self.lexer.contents;
+        // Where the `(` is missing, `Lexer::expect` has logged that and gone on.
+        let Some((b'(', after_open_paren)) = usize::try_from(open_paren.start)
+            .ok()
+            .and_then(|at| contents.get(at..))
+            .and_then(<[u8]>::split_first)
+        else {
+            return;
+        };
+        if let Some(text) = js_ast::parameter_list_as_written::text_to_keep(after_open_paren) {
+            bun_core::handle_oom(
+                self.parameter_lists_as_written
+                    .put(key.start, js_ast::StoreStr::new(text)),
+            );
+        }
+    }
+
     pub(crate) fn parse_fn(
         &mut self,
         name: Option<js_ast::LocRef>,
@@ -362,6 +390,9 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
             p.symbols[func.arguments_ref.inner_index() as usize].set_must_not_be_renamed(true);
         }
 
+        if p.lexer.has_comment_after(func.open_parens_loc) {
+            p.record_parameter_list_as_written(func.open_parens_loc, func.open_parens_loc);
+        }
         p.lexer.expect(T::TCloseParen)?;
         p.fn_or_arrow_data_parse = old_fn_or_arrow_data;
 
diff --git a/src/js_parser/parse/parse_prefix.rs b/src/js_parser/parse/parse_prefix.rs
index 0b0a3204f3e6..85857e788913 100644
--- a/src/js_parser/parse/parse_prefix.rs
+++ b/src/js_parser/parse/parse_prefix.rs
@@ -62,6 +62,7 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
         }
 
         p.parse_paren_expr(
+            loc,
             loc,
             level,
             ParenExprOpts {
@@ -932,9 +933,11 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
             if p.is_ts_arrow_fn_jsx()? {
                 let _ =
                     p.skip_type_script_type_parameters(TypeParameterFlag::ALLOW_CONST_MODIFIER)?;
+                let open_paren_loc = p.lexer.loc();
                 p.lexer.expect(T::TOpenParen)?;
                 return p.parse_paren_expr(
                     loc,
+                    open_paren_loc,
                     level,
                     ParenExprOpts {
                         force_arrow_fn: true,
@@ -965,9 +968,11 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
             match p.try_skip_type_script_type_parameters_then_open_paren_with_backtracking()? {
                 SkipTypeParameterResult::DidNotSkipAnything => {}
                 result => {
+                    let open_paren_loc = p.lexer.loc();
                     p.lexer.expect(T::TOpenParen)?;
                     return p.parse_paren_expr(
                         loc,
+                        open_paren_loc,
                         level,
                         ParenExprOpts {
                             force_arrow_fn: result
diff --git a/src/js_parser/parse/parse_property.rs b/src/js_parser/parse/parse_property.rs
index 49a59202aa79..cbca327fbb24 100644
--- a/src/js_parser/parse/parse_property.rs
+++ b/src/js_parser/parse/parse_property.rs
@@ -130,6 +130,7 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
         let mut func = func;
         func.flags.insert(flags::Function::IsUniqueFormalParameters);
         let args = func.args.slice();
+        let open_parens_loc = func.open_parens_loc;
         let value = p.new_expr(E::Function { func }, loc);
 
         // Enforce argument rules for accessors
@@ -149,6 +150,9 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
                 }
             }
             PropertyKind::Set => {
+                // JavaScriptCore refuses the `,` that a list as written can end with: `set x(v,) {}`.
+                p.parameter_lists_as_written
+                    .swap_remove(&open_parens_loc.start);
                 if args.len() != 1 {
                     let mut r = js_lexer::range_of_identifier(
                         p.source,
diff --git a/src/js_printer/lib.rs b/src/js_printer/lib.rs
index 264fdd74b3c7..4c21c89efd1a 100644
--- a/src/js_printer/lib.rs
+++ b/src/js_printer/lib.rs
@@ -1380,6 +1380,9 @@ pub struct Options<'a> {
     pub line_offset_tables: Option<&'a SourceMap::line_offset_table::List<bun_alloc::AstAlloc>>,
 
     pub mangled_props: Option<&'a crate::MangledProps>,
+
+    /// `Ast::kept_parameter_lists`.
+    pub parameter_lists_as_written: Option<&'a js_ast::ParameterListsAsWritten>,
 }
 
 impl<'a> Options<'a> {
@@ -1431,6 +1434,7 @@ impl<'a> Default for Options<'a> {
             has_dynamic_import_items: false,
             line_offset_tables: None,
             mangled_props: None,
+            parameter_lists_as_written: None,
         }
     }
 }
@@ -2454,14 +2458,75 @@ pub(crate) mod __gated_printer {
             }
         }
 
+        /// Prints the list that the parser kept at `key`, when each parameter still has the name its text gives it. `false`: nothing is printed.
+        #[cold]
+        #[inline(never)]
+        fn print_parameter_list_as_written(
+            &mut self,
+            lists: &js_ast::ParameterListsAsWritten,
+            key: bun_ast::Loc,
+            open_paren_loc: Option<bun_ast::Loc>,
+            args: &[G::Arg],
+        ) -> bool {
+            use js_ast::parameter_list_as_written::Names;
+
+            let Some(text) = lists.get(&key.start) else {
+                return false;
+            };
+            let text = text.slice();
+
+            let mut names = Names::new(text);
+            let mut ranges = Vec::with_capacity(args.len());
+            for arg in args {
+                let BindingData::BIdentifier(identifier) = &arg.binding.data else {
+                    return false;
+                };
+                let Ok(Some(name)) = names.next_name() else {
+                    return false;
+                };
+                if self.name_for_symbol(identifier.get().r#ref) != &text[name.start..name.end] {
+                    return false;
+                }
+                ranges.push(name.start..name.end);
+            }
+            if !matches!(names.next_name(), Ok(None)) {
+                return false;
+            }
+
+            if let Some(loc) = open_paren_loc {
+                self.add_source_mapping(loc);
+            }
+            self.print(b"(");
+            let mut printed = 0;
+            for (arg, name) in args.iter().zip(ranges) {
+                self.print(&*strings::crlf_as_lf(&text[printed..name.start]));
+                self.add_source_mapping(arg.binding.loc);
+                self.print(&text[name.start..name.end]);
+                printed = name.end;
+            }
+            self.print(&*strings::crlf_as_lf(&text[printed..]));
+            self.print(b")");
+            true
+        }
+
+        /// `as_written_key`: where the parser keeps the list of a function or of an arrow function.
         pub(crate) fn print_fn_args(
             &mut self,
             open_paren_loc: Option<bun_ast::Loc>,
+            as_written_key: bun_ast::Loc,
             args: &[G::Arg],
             has_rest_arg: bool,
             // is_arrow can be used for minifying later
             _is_arrow: bool,
         ) {
+            // Only what the runtime loads has such lists, and that is printed for Bun.
+            if IS_BUN_PLATFORM
+                && let Some(lists) = self.options.parameter_lists_as_written
+                && self.print_parameter_list_as_written(lists, as_written_key, open_paren_loc, args)
+            {
+                return;
+            }
+
             let wrap = true;
 
             if wrap {
@@ -2497,6 +2562,7 @@ pub(crate) mod __gated_printer {
         pub(crate) fn print_func(&mut self, func: &G::Fn) {
             self.print_fn_args(
                 Some(func.open_parens_loc),
+                func.open_parens_loc,
                 slice_of(func.args),
                 func.flags.contains(G::FnFlags::HasRestArg),
                 false,
@@ -3810,6 +3876,7 @@ pub(crate) mod __gated_printer {
 
                     self.print_fn_args(
                         if e.is_async { None } else { Some(expr.loc) },
+                        expr.loc,
                         &e.args,
                         e.has_rest_arg,
                         true,
@@ -7066,6 +7133,7 @@ pub(crate) mod __gated_printer {
             {
                 self.print_fn_args(
                     Some(func.open_parens_loc),
+                    bun_ast::Loc::EMPTY,
                     slice_of(func.args),
                     func.flags.contains(G::FnFlags::HasRestArg),
                     false,
@@ -7181,6 +7249,7 @@ pub(crate) mod __gated_printer {
                 }
                 self.print_fn_args(
                     Some(func.open_parens_loc),
+                    bun_ast::Loc::EMPTY,
                     slice_of(func.args),
                     func.flags.contains(G::FnFlags::HasRestArg),
                     false,
diff --git a/src/jsc/RuntimeTranspilerCache.rs b/src/jsc/RuntimeTranspilerCache.rs
index cafb4f0281bf..93b3b7347908 100644
--- a/src/jsc/RuntimeTranspilerCache.rs
+++ b/src/jsc/RuntimeTranspilerCache.rs
@@ -85,7 +85,8 @@ bun_core::declare_scope!(cache, visible);
 /// Version 50: The body of a class with lowered class decorators names the class by the
 /// binding that holds what the decorators return.
 /// Version 51: A `bun:` specifier that names no builtin is printed as it is written.
-const EXPECTED_VERSION: u32 = 51;
+/// Version 52: A parameter list that holds a comment is printed as it is written.
+const EXPECTED_VERSION: u32 = 52;
 
 /// Source files smaller than this are not written to / read from the on-disk
 /// transpiler cache. Originally 50 KiB, which excluded almost every file in a
diff --git a/src/runtime/cli/repl.rs b/src/runtime/cli/repl.rs
index 4ff19836ca6e..63c5929e7e37 100644
--- a/src/runtime/cli/repl.rs
+++ b/src/runtime/cli/repl.rs
@@ -2147,6 +2147,7 @@ impl<'a> Repl<'a> {
             bun_ast::Loader::Tsx,
         );
         opts.repl_mode = true;
+        opts.keep_parameter_lists_as_written = true;
         opts.features.dead_code_elimination = false; // REPL needs all code
         opts.features.top_level_await = true; // Enable top-level await in REPL
         // Keep `lower_using` at its default (true) here even though JavaScriptCore
@@ -2222,6 +2223,7 @@ impl<'a> Repl<'a> {
             &source,
             bun_js_printer::Options {
                 mangled_props: None,
+                parameter_lists_as_written: ast.kept_parameter_lists(),
                 ..Default::default()
             },
         )
diff --git a/src/runtime/test_runner/expect.rs b/src/runtime/test_runner/expect.rs
index f24aacfd29cb..29d445dae46e 100644
--- a/src/runtime/test_runner/expect.rs
+++ b/src/runtime/test_runner/expect.rs
@@ -1974,6 +1974,23 @@ pub(crate) struct CustomMatcherParamsFormatter {
     pub(crate) matcher_fn: JSValue,
 }
 
+/// The names of a list that the printer wrote as the source has it (`bun_ast::parameter_list_as_written`), joined as the printer joins them: the comments are no part of a name.
+fn names_of_parameter_list_as_written(after_open_paren: &[u8]) -> Option<Vec<u8>> {
+    let text = bun_ast::parameter_list_as_written::text_to_keep(after_open_paren)?;
+    let mut names = bun_ast::parameter_list_as_written::Names::new(text);
+    let mut joined = Vec::new();
+    while let Ok(Some(name)) = names.next_name() {
+        if !joined.is_empty() {
+            joined.extend_from_slice(b", ");
+        }
+        if name.is_rest {
+            joined.extend_from_slice(b"...");
+        }
+        joined.extend_from_slice(&text[name.start..name.end]);
+    }
+    Some(joined)
+}
+
 impl fmt::Display for CustomMatcherParamsFormatter {
     fn fmt(&self, writer: &mut fmt::Formatter<'_>) -> fmt::Result {
         // try to detect param names from matcher_fn (user function) source code
@@ -1982,8 +1999,12 @@ impl fmt::Display for CustomMatcherParamsFormatter {
 
             let source: &[u8] = source_slice.slice();
             if let Some(lparen) = strings::index_of_char_usize(source, b'(') {
-                if let Some(rparen) = strings::index_of_char_pos(source, b')', lparen) {
-                    let params_str = &source[lparen + 1..rparen];
+                let as_written = names_of_parameter_list_as_written(&source[lparen + 1..]);
+                let params_str = match &as_written {
+                    Some(names) => Some(names.as_slice()),
+                    None => strings::index_of_char_pos(source, b')', lparen).map(|rparen| &source[lparen + 1..rparen]),
+                };
+                if let Some(params_str) = params_str {
                     let mut param_index: usize = 0;
                     for param_name in strings::split(params_str, b",") {
                         if param_index > 0 {
diff --git a/test/aot/parallel/errors/a-parameter-list-that-holds-a-comment-is-quoted-as-it-is-written.js b/test/aot/parallel/errors/a-parameter-list-that-holds-a-comment-is-quoted-as-it-is-written.js
new file mode 100644
index 000000000000..176cd76e463b
--- /dev/null
+++ b/test/aot/parallel/errors/a-parameter-list-that-holds-a-comment-is-quoted-as-it-is-written.js
@@ -0,0 +1,25 @@
+// An error quotes the call that failed as Bun prints it, with the functions that lie in it. Bun prints a parameter list of plain names
+// that holds a comment as it is written, so the quote has the comments of such a list. Any other list, and the list of a setter, is
+// printed without them.
+function tell(label, run) {
+  try { run(); console.log(label + ": no error"); } catch (error) { console.log(label + ": " + JSON.stringify(error.message)); }
+}
+const o = { none: null };
+
+tell("function", () => o.nothing(function (/* the token */ name, other /* after */) {}));
+tell("named function", () => o.nothing(function named(/* a */a,/* b */b) { return a + b }));
+tell("arrow", () => o.nothing((/* one */ a, /* two */ b) => a + b));
+tell("async arrow", () => o.nothing(async (/* one */ a) => { await a }));
+tell("generator", () => o.nothing(function* (/* each */ ...all) { yield all }));
+tell("method", () => o.nothing({ method(/* m */ a) {}, get value(/* none */) { return 1 }, set value(/* v */ next,) {} }));
+tell("class", () => o.nothing(class { constructor(/* c */ a) {} static make(/* s */ a) {} }));
+tell("no parameter", () => o.nothing((/* none */) => 1));
+tell("lines", () => o.nothing(function (
+    // the first
+    a,
+    b, // the second
+) {}, 2));
+tell("a read", () => (function (/* the token */ name) {}).nothing.deep);
+tell("a default value", () => o.nothing(function (/* c */ a = 1) {}));
+tell("a pattern", () => o.nothing((/* c */ { a }) => a));
+tell("comments outside the list", () => o.nothing(function /* c */ (a) /* d */ {}, async /* e */ (a) => a));
diff --git a/test/bundler/transpiler/runtime-transpiler.test.ts b/test/bundler/transpiler/runtime-transpiler.test.ts
index 27e4b71f848b..8b03c5f50c82 100644
--- a/test/bundler/transpiler/runtime-transpiler.test.ts
+++ b/test/bundler/transpiler/runtime-transpiler.test.ts
@@ -1,5 +1,6 @@
 import { beforeEach, describe, expect, test } from "bun:test";
 import { bunEnv, bunExe, isASAN, isDebug, tempDir } from "harness";
+import { join } from "node:path";
 
 test("use strict causes CommonJS", () => {
   const { stdout, exitCode } = Bun.spawnSync({
@@ -286,3 +287,554 @@ test.skipIf(isDebug || isASAN)(
     expect(exitCode).toBe(0);
   },
 );
+
+// A dependency injector reads `/* token */ name` out of `fn.toString()`: https://github.com/oven-sh/bun/issues/13451
+describe.concurrent("a parameter list that holds a comment is printed as it is written", () => {
+  async function run(files: Record<string, string>, ...args: string[]) {
+    using dir = tempDir("parameter-list-as-written", files);
+    await using proc = Bun.spawn({
+      cmd: [bunExe(), ...args],
+      env: bunEnv,
+      cwd: String(dir),
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+    const [stdout, stderr, exitCode] = await Promise.all([proc.stdout.text(), proc.stderr.text(), proc.exited]);
+    return { stdout, stderr, exitCode };
+  }
+
+  test("the injector of karma finds its tokens", async () => {
+    const { stdout, stderr, exitCode } = await run(
+      {
+        "tokens.cjs": String.raw`
+// How di@0.0.1 (lib/annotation.js), the injector of karma, finds what to inject.
+const FN_ARGS = /^function\s*[^\(]*\(\s*([^\)]*)\)/m;
+const FN_ARG = /\/\*([^\*]*)\*\//m;
+const tokensOf = fn => {
+  const list = fn.toString().match(FN_ARGS)[1];
+  return list ? list.split(",").map(arg => (arg.match(FN_ARG)?.[1] ?? arg).trim()) : [];
+};
+// The four parameter lists of karma@6.4.4 that hold tokens.
+const proxy = function (/* config */config, /* config.proxies */proxies, /* emitter */emitter) {};
+const browser = function (
+  id, fullName, /* capturedBrowsers */ collection, emitter, socket, timer,
+  /* config.browserDisconnectTimeout */ disconnectDelay,
+  /* config.browserNoActivityTimeout */ noActivityTimeout,
+  /* config.singleRun */ singleRun,
+  /* config.client */ clientConfig) {};
+function createRunnerMiddleware (emitter, fileList, capturedBrowsers, reporter, executor,
+  /* config.protocol */ protocol, /* config.hostname */ hostname, /* config.port */
+  port, /* config.urlRoot */ urlRoot, config) {}
+const captureTimeout = function (timer,
+  /* config.captureTimeout */ captureTimeout) {};
+console.log(JSON.stringify({ proxy: tokensOf(proxy), browser: tokensOf(browser), runner: tokensOf(createRunnerMiddleware), captureTimeout: tokensOf(captureTimeout) }, null, 1));
+`,
+      },
+      "tokens.cjs",
+    );
+    expect(stderr).toBe("");
+    // What Node.js prints.
+    expect(JSON.parse(stdout)).toEqual({
+      proxy: ["config", "config.proxies", "emitter"],
+      browser: [
+        "id",
+        "fullName",
+        "capturedBrowsers",
+        "emitter",
+        "socket",
+        "timer",
+        "config.browserDisconnectTimeout",
+        "config.browserNoActivityTimeout",
+        "config.singleRun",
+        "config.client",
+      ],
+      runner: [
+        "emitter",
+        "fileList",
+        "capturedBrowsers",
+        "reporter",
+        "executor",
+        "config.protocol",
+        "config.hostname",
+        "config.port",
+        "config.urlRoot",
+        "config",
+      ],
+      captureTimeout: ["timer", "config.captureTimeout"],
+    });
+    expect(exitCode).toBe(0);
+  });
+
+  // Every kind of function with every list that fits its count of parameters. Each kind is a module of its own, which has to load.
+  test.each([
+    [".cjs", "module.exports ="],
+    [".ts", "export default"],
+  ])("for every kind of function, in a %s file", async (extension, how) => {
+    // Each is an expression for the function. `LIST` is where the list goes.
+    const functions = {
+      "a function declaration": "(() => { function f(LIST) {} return f; })()",
+      "an async function declaration": "(() => { async function f(LIST) {} return f; })()",
+      "a generator declaration": "(() => { function* f(LIST) {} return f; })()",
+      "an async generator declaration": "(() => { async function* f(LIST) {} return f; })()",
+      "a function expression": "function (LIST) {}",
+      "a named function expression": "function named(LIST) {}",
+      "an async function expression": "async function (LIST) {}",
+      "a generator expression": "function* (LIST) {}",
+      "an arrow function": "(LIST) => {}",
+      "an arrow function that returns an expression": "(LIST) => 1",
+      "an async arrow function": "async (LIST) => {}",
+      "an arrow function in a class field": "new (class { field = (LIST) => {}; })().field",
+      "a function in a default value": "(function (inner = function (LIST) {}) { return inner; })()",
+      "a constructor": "class { constructor(LIST) {} }",
+      "a constructor of a derived class": "class extends Object { constructor(LIST) { super(); } }",
+      "a method": "class { method(LIST) {} }.prototype.method",
+      "a static method": "class { static method(LIST) {} }.method",
+      "a generator method": "class { *method(LIST) {} }.prototype.method",
+      "an async method": "class { async method(LIST) {} }.prototype.method",
+      "an async generator method": "class { async *method(LIST) {} }.prototype.method",
+      "a private method": "class K { #method(LIST) {} static get() { return new K().#method; } }.get()",
+      "a static private method": "class K { static #method(LIST) {} static get() { return K.#method; } }.get()",
+      "a method with a computed name": 'class { ["m" + 1](LIST) {} }.prototype.m1',
+      "a method with a string name": 'class { "a name"(LIST) {} }.prototype["a name"]',
+      "a method of an object": "{ method(LIST) {} }.method",
+      "an async method of an object": "{ async method(LIST) {} }.method",
+      "a generator method of an object": "{ *method(LIST) {} }.method",
+      "a method of an object with a computed name": '{ ["m" + 1](LIST) {} }.m1',
+    };
+    const getters = {
+      "a getter": 'Object.getOwnPropertyDescriptor(class { get value(LIST) { return 1; } }.prototype, "value").get',
+      "a static getter": 'Object.getOwnPropertyDescriptor(class { static get value(LIST) { return 1; } }, "value").get',
+      "a getter of an object": 'Object.getOwnPropertyDescriptor({ get value(LIST) { return 1; } }, "value").get',
+    };
+    // JavaScriptCore refuses `set value(a,) {}`: the list of a setter is printed as before.
+    const setters = {
+      "a setter": 'Object.getOwnPropertyDescriptor(class { set value(LIST) {} }.prototype, "value").set',
+      "a static setter": 'Object.getOwnPropertyDescriptor(class { static set value(LIST) {} }, "value").set',
+      "a private setter": "class { set #value(LIST) {} }",
+      "a setter with a computed name":
+        'Object.getOwnPropertyDescriptor(class { set ["v" + 1](LIST) {} }.prototype, "v1").set',
+      "a setter with a string name":
+        'Object.getOwnPropertyDescriptor(class { set "a name"(LIST) {} }.prototype, "a name").set',
+      "a setter of an object": 'Object.getOwnPropertyDescriptor({ set value(LIST) {} }, "value").set',
+    };
+    // [the list as it is written, the same list with no comment]
+    const lists = [
+      ["/* none */", ""],
+      ["\n  // none\n", ""],
+      ["/* c */ a", "a"],
+      ["a /* c */", "a"],
+      ["/* c */ a,", "a"],
+      ["a, /* c */", "a"],
+      ["a // c\n", "a"],
+      ["\n  // c\n  a,\n", "a"],
+      ["/** doc */ a", "a"],
+      ["/* ) => { */ a", "a"],
+      ["/* c */ a, /* d */ b", "a, b"],
+      ["a /* c */, b", "a, b"],
+      ["/* c */a,/* d */b", "a, b"],
+      ["a,\n  /* c */ b,", "a, b"],
+      ["\n  // c\n  a,\n  b, // d\n", "a, b"],
+      ["/* c */ $a, _b, c1", "$a, _b, c1"],
+      ["/* c */ ...a", "...a"],
+      ["a, ... /* c */ b", "a, ...b"],
+    ];
+    const count = (plain: string) => (plain === "" ? 0 : plain.split(",").length);
+
+    const kinds: { name: string; file: string; lists: string[]; isKept: boolean }[] = [];
+    const files: Record<string, string> = {};
+    const add = (templates: Record<string, string>, fits: (plain: string) => boolean, isKept: boolean) => {
+      for (const [name, template] of Object.entries(templates)) {
+        const file = `kind-${kinds.length}${extension}`;
+        const fitting = lists.filter(([, plain]) => fits(plain));
+        const moduleOf = (texts: string[]) =>
+          `${how} [\n${texts.map(text => template.replace("LIST", text)).join(",\n")},\n];\n`;
+        files[file] = moduleOf(fitting.map(([list]) => list));
+        if (!isKept) files["plain-" + file] = moduleOf(fitting.map(([, plain]) => plain));
+        kinds.push({ name, file, lists: fitting.map(([list]) => list), isKept });
+      }
+    };
+    add(functions, () => true, true);
+    add(getters, plain => count(plain) === 0, true);
+    add(setters, plain => count(plain) === 1 && !plain.includes("..."), false);
+    files["kinds.json"] = JSON.stringify(kinds);
+    files["main.mjs"] = `
+      import kinds from "./kinds.json";
+      const failed = [];
+      let rows = 0;
+      for (const { name, file, lists, isKept } of kinds) {
+        try {
+          const texts = (await import("./" + file)).default.map(String);
+          const plain = isKept ? [] : (await import("./plain-" + file)).default.map(String);
+          lists.forEach((list, i) => {
+            const expected = isKept ? "(" + list + ")" : plain[i];
+            if (isKept ? !texts[i].includes(expected) : texts[i] !== expected) failed.push({ name, list, text: texts[i], expected });
+            rows++;
+          });
+        } catch (error) {
+          failed.push({ name, error: String(error) });
+        }
+      }
+      console.log(JSON.stringify({ rows, failed }, null, 1));
+    `;
+
+    const { stdout, stderr, exitCode } = await run(files, "main.mjs");
+    expect(stderr).toBe("");
+    expect(JSON.parse(stdout)).toEqual({ rows: 28 * 18 + 3 * 2 + 6 * 8, failed: [] });
+    expect(exitCode).toBe(0);
+  });
+
+  test("and the rest of the function is printed as before", async () => {
+    const { stdout, stderr, exitCode } = await run(
+      {
+        "text.mjs": String.raw`
+const fn = function (/* c */ a,   b) { return a+b };
+const arrow = (/* c */ a) => a*2;
+const asyncArrow = async (/* c */ a) => { await a };
+const Class = class { constructor(/* c */ a) { this.a = a } };
+const legal = function (/*! legal */ a) {};
+console.log(JSON.stringify([fn, arrow, asyncArrow, Class, legal].map(String), null, 1));
+`,
+      },
+      "text.mjs",
+    );
+    expect(stderr).toBe("");
+    expect(JSON.parse(stdout)).toEqual([
+      "function(/* c */ a,   b) {\n  return a + b;\n}",
+      "(/* c */ a) => a * 2",
+      "async (/* c */ a) => {\n  await a;\n}",
+      "class {\n  constructor(/* c */ a) {\n    this.a = a;\n  }\n}",
+      // The printer writes a comment that starts with "!" by itself, into the body: such a list is printed as before.
+      "function(a) {\n  /*! legal */\n}",
+    ]);
+    expect(exitCode).toBe(0);
+  });
+
+  test("however the runtime loads the module", async () => {
+    const { stdout, stderr, exitCode } = await run(
+      {
+        "entry.mjs": String.raw`
+import { plugin } from "bun";
+import { createRequire } from "node:module";
+import { fn as imported } from "./imported.mjs";
+
+plugin({
+  setup(build) {
+    build.onLoad({ filter: /from-plugin\.js$/ }, () => ({
+      contents: "export function fn(/* token */ a) {}",
+      loader: "js",
+    }));
+  },
+});
+const { promise: fromWorker, resolve, reject } = Promise.withResolvers();
+const worker = new Worker(new URL("./worker.mjs", import.meta.url).href);
+worker.onmessage = event => resolve(event.data);
+worker.onerror = reject;
+
+const texts = {
+  "the entry file": String(function (/* token */ a) {}),
+  "require()": String(createRequire(import.meta.url)("./required.cjs").fn),
+  "import": String(imported),
+  "import()": String((await import("./dynamic.mjs")).fn),
+  "a TypeScript file": String((await import("./typed.ts")).fn),
+  "a TSX file": String((await import("./element.tsx")).fn),
+  "a generic arrow function in a TSX file": String((await import("./element.tsx")).generic),
+  "a Worker": await fromWorker,
+  "what a plugin's onLoad returns": String((await import("./from-plugin.js")).fn),
+};
+worker.terminate();
+console.log(JSON.stringify(Object.keys(texts).filter(name => !texts[name].includes("(/* token */ a)"))));
+`,
+        "required.cjs": String.raw`
+exports.fn = function (/* token */ a) {};
+`,
+        "imported.mjs": String.raw`
+export function fn(/* token */ a) {}
+`,
+        "dynamic.mjs": String.raw`
+export const fn = (/* token */ a) => a;
+`,
+        "typed.ts": String.raw`
+export function fn(/* token */ a) {
+  return a as unknown;
+}
+`,
+        "element.tsx": String.raw`
+/** @jsx h */
+const h = (type: string) => type;
+export function fn(/* token */ a) {
+  return <div />;
+}
+export const generic = <T,>(/* token */ a) => a;
+`,
+        "worker.mjs": String.raw`
+postMessage(String(function (/* token */ a) {}));
+`,
+        "from-plugin.js": String.raw`
+// replaced by the plugin
+`,
+      },
+      "entry.mjs",
+    );
+    expect(stderr).toBe("");
+    expect(JSON.parse(stdout)).toEqual([]);
+    expect(exitCode).toBe(0);
+  });
+
+  test("with -e", async () => {
+    const { stdout, stderr, exitCode } = await run({}, "-e", "console.log(String(function (/* token */ a) {}))");
+    expect(stderr).toBe("");
+    expect(stdout).toBe("function(/* token */ a) {}\n");
+    expect(exitCode).toBe(0);
+  });
+
+  test("in a test file", async () => {
+    const { stdout, exitCode } = await run(
+      { "list.test.js": `test("list", () => console.log(String(function (/* token */ a) {})));` },
+      "test",
+      "list.test.js",
+    );
+    expect(stdout.split("\n")).toContain("function(/* token */ a) {}");
+    expect(exitCode).toBe(0);
+  });
+
+  test("in a TypeScript file, when the list holds no type", async () => {
+    const { stdout, stderr, exitCode } = await run(
+      {
+        "tsconfig.json": `{ "compilerOptions": { "experimentalDecorators": true } }`,
+        "lists.ts": String.raw`
+const dec = (...args: unknown[]) => {};
+// Kept: the text between the parentheses holds names and comments only.
+const kept: [Function, string][] = [
+  [function (/* c */ a, /* d */ b) {}, "/* c */ a, /* d */ b"],
+  [function <T>(/* c */ a) {}, "/* c */ a"],
+  [(/* c */ a): number => a, "/* c */ a"],
+  [<T,>(/* c */ a) => a, "/* c */ a"],
+  [async <T,>(/* c */ a) => a, "/* c */ a"],
+  [
+    class {
+      method<T>(/* c */ a): void {}
+    }.prototype.method,
+    "/* c */ a",
+  ],
+];
+// Printed as before: the printer does not write the text of the source where it holds a type, a modifier or a decorator.
+class WithProperty {
+  constructor(/* c */ public a) {}
+}
+class WithoutComment {
+  constructor(public a) {}
+}
+class Decorated {
+  method(@dec /* c */ a) {}
+}
+class DecoratedWithoutComment {
+  method(@dec a) {}
+}
+const asBefore: Record<string, [Function, Function]> = {
+  "a type": [function (/* c */ a: number) {}, function (a: number) {}],
+  "a type on a later parameter": [function (/* c */ a, b: number) {}, function (a, b: number) {}],
+  "an optional parameter": [function (/* c */ a?) {}, function (a?) {}],
+  "a this parameter": [function (this: unknown, /* c */ a) {}, function (this: unknown, a) {}],
+  "a this parameter with no type": [function (this, /* c */ a) {}, function (this, a) {}],
+  // The text has a name, and the function has no parameter.
+  "a this parameter alone": [function (/* c */ this) {}, function (this) {}],
+  "an arrow function with a type": [(/* c */ a: number) => a, (a: number) => a],
+  "a parameter property": [WithProperty, WithoutComment],
+  "a decorator": [Decorated.prototype.method, DecoratedWithoutComment.prototype.method],
+};
+const text = (fn: Function) => String(fn).replace(/WithProperty|WithoutComment|DecoratedWithoutComment|Decorated/g, "C");
+console.log(
+  JSON.stringify(
+    {
+      notKept: kept.filter(([fn, list]) => !String(fn).includes("(" + list + ")")).map(([fn, list]) => ({ list, text: String(fn) })),
+      notAsBefore: Object.entries(asBefore)
+        .filter(([, [commented, plain]]) => text(commented) !== text(plain))
+        .map(([name, [commented, plain]]) => ({ name, commented: text(commented), plain: text(plain) })),
+    },
+    null,
+    1,
+  ),
+);
+`,
+      },
+      "lists.ts",
+    );
+    expect(stderr).toBe("");
+    expect(JSON.parse(stdout)).toEqual({ notKept: [], notAsBefore: [] });
+    expect(exitCode).toBe(0);
+  });
+
+  test("and a list of anything else than names is printed as before", async () => {
+    const { stdout, stderr, exitCode } = await run(
+      {
+        "declined.cjs": String.raw`
+// Each row: a function whose list is not kept, and the same function without the comment.
+const id = fn => fn;
+const rows = {
+  "a default value": [function (/* c */ a = 1) {}, function (a = 1) {}],
+  "a default value after it": [function (/* c */ a, b = 1) {}, function (a, b = 1) {}],
+  "an object pattern": [function (/* c */ { a }) {}, function ({ a }) {}],
+  "an array pattern": [function (/* c */ [a]) {}, function ([a]) {}],
+  "a comment that is not ASCII": [function (/* é */ a) {}, function (a) {}],
+  "a name that is not ASCII": [function (/* c */ é) {}, function (é) {}],
+  "a name with an escape": [function (/* c */ \u0061) {}, function (a) {}],
+  "an arrow function with a default value": [(/* c */ a = 1) => a, (a = 1) => a],
+  "a comment before the list of an arrow function": [id(/* outside */ a => a), id(a => a)],
+  "a comment before the parenthesis": [function /* c */ (a) {}, function (a) {}],
+  "a comment after async": [async /* c */ (a) => a, async (a) => a],
+  "a comment after the list": [function (a) /* c */ {}, function (a) {}],
+  "a comment before the arrow": [(a) /* c */ => a, (a) => a],
+  "a comment after a list with other spaces": [( a,b ) /* c */ => a, (a, b) => a],
+  // JavaScriptCore takes the name of the source from such a comment.
+  "a comment that starts with //#": [function (a, //# sourceURL=renamed.js
+    b) {}, function (a, b) {}],
+  "a comment that starts with //@": [function (a, //@ sourceURL=renamed.js
+    b) {}, function (a, b) {}],
+  // mock.module() takes these words, in the text of a factory, as a mention of the original module.
+  "importOriginal in a comment": [(/* importOriginal */ a) => a, (a) => a],
+  "importActual in a comment": [function (a /* vi.importActual("./a") */) {}, function (a) {}],
+  "requireActual in a comment": [function (a, // see jest.requireActual
+    b) {}, function (a, b) {}],
+  "no comment": [function (a,
+    b) {}, function (a, b) {}],
+};
+const differing = Object.entries(rows).filter(([, [commented, plain]]) => String(commented) !== String(plain));
+console.log(JSON.stringify(differing.map(([name, [commented, plain]]) => ({ name, commented: String(commented), plain: String(plain) })), null, 1));
+`,
+      },
+      "declined.cjs",
+    );
+    expect(stderr).toBe("");
+    expect(JSON.parse(stdout)).toEqual([]);
+    expect(exitCode).toBe(0);
+  });
+
+  // The parser goes on behind a missing "(". A comment then stands behind something that is no "(".
+  test.each([
+    ["no-name.cjs", "function (a /* c */) {}\n", 'error: Expected identifier but found "("'],
+    ["no-paren.cjs", "function foo {\n  // a comment\n}\n", 'error: Expected "(" but found "{"'],
+    ["no-paren.tsx", "let x = <T,>a /* c */) => 1;\n", 'error: Expected "(" but found "a"'],
+  ])("and a syntax error before a comment is reported as before: %s", async (file, source, error) => {
+    const { stdout, stderr, exitCode } = await run({ [file]: source }, file);
+    expect({ stdout, error: stderr.split("\n").find(line => line.startsWith("error: ")), exitCode }).toEqual({
+      stdout: "",
+      error,
+      exitCode: 1,
+    });
+  });
+
+  test.each([
+    ["\\n", "\n"],
+    ["\\r\\n", "\r\n"],
+    ["\\r", "\r"],
+  ])("and positions after a list of several lines stay right, with lines that end in %s", async (_, lineEnding) => {
+    const lines = [
+      "exports.first = function (",
+      "  /* one */ a,",
+      "  // two",
+      "  b,",
+      ") {",
+      "  return new Error('first').stack.split('\\n')[1];",
+      "};",
+      "exports.second = function () { return new Error('second').stack.split('\\n')[1]; };",
+    ];
+    const { stdout, stderr, exitCode } = await run(
+      {
+        "positions.cjs": lines.join(lineEnding) + lineEnding,
+        "main.cjs": `
+          const { first, second } = require("./positions.cjs");
+          const position = frame => frame.slice(frame.lastIndexOf("positions.cjs:") + "positions.cjs:".length).replace(")", "");
+          const text = String(first);
+          console.log(JSON.stringify({
+            list: text.slice(text.indexOf("("), text.indexOf(")") + 1),
+            first: position(first()),
+            second: position(second()),
+          }));
+        `,
+      },
+      "main.cjs",
+    );
+    expect(stderr).toBe("");
+    expect(JSON.parse(stdout)).toEqual({
+      // A line of the source ends with "\n" in what is printed.
+      list: "(\n  /* one */ a,\n  // two\n  b,\n)",
+      first: "6:14",
+      second: "8:43",
+    });
+    expect(exitCode).toBe(0);
+  });
+
+  // The React Compiler renames a parameter that shadows a name of the hook: `value` is `value_0` in what it writes.
+  test("unless the parameter has another name in what is printed", async () => {
+    const { stdout, exitCode } = await run(
+      {
+        "node_modules/react/package.json": JSON.stringify({
+          name: "react",
+          version: "19.0.0",
+          exports: { ".": "./index.js", "./compiler-runtime": "./compiler-runtime.js" },
+        }),
+        "node_modules/react/index.js": `export const useState = value => [value, () => {}];`,
+        "node_modules/react/compiler-runtime.js": `export const c = size => Array(size).fill(Symbol.for("react.memo_cache_sentinel"));`,
+        "hook.js": `
+          import { useState } from "react";
+          export function useCapture(/* the values */ values, /* the step */ step) {
+            const [value] = useState(1);
+            const fn = (/* shadows */ value, /* its index */ index) => value + step + index;
+            return [fn, values.map(fn)];
+          }
+        `,
+        "hook.test.js": `
+          import { useCapture } from "./hook.js";
+          test("hook", () => {
+            const [fn, mapped] = useCapture([1, 2], 10);
+            console.log(JSON.stringify({ hook: String(useCapture).split("\\n")[0], fn: String(fn), mapped }));
+          });
+        `,
+      },
+      "test",
+      "--react-compiler",
+    );
+    const { hook, fn, mapped } = JSON.parse(stdout.split("\n").find(line => line.startsWith("{"))!);
+    expect(hook).toBe("function useCapture(/* the values */ values, /* the step */ step) {");
+    expect(fn).not.toContain("/* shadows */");
+    expect(mapped).toEqual([11, 13]);
+    expect(exitCode).toBe(0);
+  });
+
+  // What `bun build` and `Bun.Transpiler` print is not loaded by the runtime: it has no such list, for any target.
+  test("but only in a module the runtime loads", async () => {
+    const source = "export const fn = function (/* token */ a) {};\n";
+    using dir = tempDir("parameter-list-not-as-written", { "fn.js": source });
+    const entrypoints = [join(String(dir), "fn.js")];
+    const printedBy = async (...args: string[]) => {
+      await using proc = Bun.spawn({
+        cmd: [bunExe(), "build", "--no-bundle", ...args, "fn.js"],
+        env: bunEnv,
+        cwd: String(dir),
+        stdout: "pipe",
+        stderr: "pipe",
+      });
+      const [stdout, stderr, exitCode] = await Promise.all([proc.stdout.text(), proc.stderr.text(), proc.exited]);
+      return { stdout, stderr, exitCode };
+    };
+    // Without the line that names the file.
+    const bundled = async (target: "browser" | "bun") =>
+      (await (await Bun.build({ entrypoints, target })).outputs[0].text()).replace(/^\/\/ .*fn\.js\n/m, "");
+
+    expect({
+      "bun build --no-bundle": await printedBy(),
+      "bun build --no-bundle --target=bun": await printedBy("--target=bun"),
+      "Bun.Transpiler": new Bun.Transpiler({ loader: "js" }).transformSync(source),
+      "Bun.Transpiler for Bun": new Bun.Transpiler({ loader: "js", target: "bun" }).transformSync(source),
+      "Bun.build": await bundled("browser"),
+      "Bun.build for Bun": await bundled("bun"),
+    }).toEqual({
+      "bun build --no-bundle": { stdout: "export const fn = function(a) {};\n", stderr: "", exitCode: 0 },
+      "bun build --no-bundle --target=bun": { stdout: "export const fn = function(a) {};\n", stderr: "", exitCode: 0 },
+      "Bun.Transpiler": "export const fn = function(a) {};\n",
+      "Bun.Transpiler for Bun": "export const fn = function(a) {};\n",
+      "Bun.build": "var fn = function(a) {};\nexport {\n  fn\n};\n",
+      "Bun.build for Bun": "// @bun\nvar fn = function(a) {};\nexport {\n  fn\n};\n",
+    });
+  });
+});
diff --git a/test/cli/run/transpiler-cache.test.ts b/test/cli/run/transpiler-cache.test.ts
index b569ec4ac6e7..4ba5b7e47365 100644
--- a/test/cli/run/transpiler-cache.test.ts
+++ b/test/cli/run/transpiler-cache.test.ts
@@ -305,6 +305,33 @@ describe("transpiler cache", () => {
     );
     expect(newCacheCount()).toBe(0);
   });
+  test("a parameter list that holds a comment is the same from the cache", async () => {
+    // Above MINIMUM_CACHE_SIZE, so the second run prints what the first one stored.
+    const padding = "\n//" + Buffer.alloc(5 * 1024, "f").toString();
+    writeFileSync(
+      join(temp_dir, "a.js"),
+      `const text = String(function (/* token */ a) {});\nconsole.log(text.slice(text.indexOf("("), text.indexOf(")") + 1));` +
+        padding,
+    );
+    expect(await bunRun(join(temp_dir, "a.js"), env)).toSpawn("(/* token */ a)");
+    expect(newCacheCount()).toBe(1);
+
+    // A run that does not take the entry writes it again. A cache hit reads the window stream of the source map only
+    // to map a position (see "cached sourcemap with a corrupted body"), so other bytes there stay if the run took the entry.
+    const entry = join(cache_dir, readdirSync(cache_dir)[0]);
+    const marked = readFileSync(entry);
+    const sourceMapAt = Number(marked.readBigUInt64LE(54));
+    const sourceMapEnd = sourceMapAt + Number(marked.readBigUInt64LE(62));
+    const streamAt = sourceMapAt + marked.readUInt32LE(sourceMapAt + 28);
+    expect(streamAt).toBeLessThan(sourceMapEnd);
+    expect(sourceMapEnd).toBeLessThanOrEqual(marked.length);
+    marked.fill(0xff, streamAt, sourceMapEnd);
+    writeFileSync(entry, marked);
+
+    expect(await bunRun(join(temp_dir, "a.js"), env)).toSpawn("(/* token */ a)");
+    expect(readFileSync(entry).equals(marked)).toBeTrue();
+    expect(newCacheCount()).toBe(0);
+  });
   test("--feature flag invalidates cache", () => {
     // feature() can only appear in an if/ternary, so wrap it
     const code = `import { feature } from "bun:bundle";\nif (feature("SUPER_SECRET")) console.log("enabled"); else console.log("disabled");`;
diff --git a/test/internal/source-lints/mock-module-words.test.ts b/test/internal/source-lints/mock-module-words.test.ts
new file mode 100644
index 000000000000..8ebe5db48022
--- /dev/null
+++ b/test/internal/source-lints/mock-module-words.test.ts
@@ -0,0 +1,23 @@
+import { expect, test } from "bun:test";
+import { readFileSync } from "node:fs";
+import path from "node:path";
+
+// The runtime prints a parameter list that holds a comment as it is written, so the comment is part of the text of
+// the function. `mentionsOriginalModule` (src/jsc/bindings/BunPlugin.cpp) searches the text of a `mock.module`
+// factory for a few words, and takes each as a mention of the original module. So a list that holds one of those
+// words is printed without its comments: `READ_BY_MOCK_MODULE` (src/ast/parameter_list_as_written.rs) is a copy of
+// the words. A word that only one of the two has brings back a mock that loads its original, with every test green.
+test("the words that keep a parameter list from being printed as written are the words that mock.module reads", () => {
+  const root = path.resolve(import.meta.dir, "..", "..", "..");
+  const read = (file: string) => readFileSync(path.join(root, file), "utf8");
+
+  const reader = read("src/jsc/bindings/BunPlugin.cpp").match(/^static bool mentionsOriginalModule\([^]*?^}/m)?.[0];
+  if (!reader) throw new Error("src/jsc/bindings/BunPlugin.cpp no longer has `static bool mentionsOriginalModule(`");
+  const writer = read("src/ast/parameter_list_as_written.rs").match(/^const READ_BY_MOCK_MODULE: .*= \[(.*)\];$/m)?.[1];
+  if (!writer) throw new Error("src/ast/parameter_list_as_written.rs no longer has `const READ_BY_MOCK_MODULE`");
+
+  const wordsOfReader = Array.from(reader.matchAll(/"(\w+)"_s/g), match => match[1]).sort();
+  const wordsOfWriter = Array.from(writer.matchAll(/b"(\w+)"/g), match => match[1]).sort();
+  expect(wordsOfReader).not.toEqual([]);
+  expect(wordsOfWriter).toEqual(wordsOfReader);
+});
diff --git a/test/js/bun/repl/repl.test.ts b/test/js/bun/repl/repl.test.ts
index 6f3ecb50cd83..a46fb0c99f44 100644
--- a/test/js/bun/repl/repl.test.ts
+++ b/test/js/bun/repl/repl.test.ts
@@ -840,6 +840,29 @@ describe.concurrent("Bun REPL", () => {
     });
   });
 
+  // As in a module: a dependency injector reads `/* token */ name` out of `fn.toString()`.
+  describe("a parameter list that holds a comment", () => {
+    test("is printed as it is written", async () => {
+      const { outputs, stderr, exitCode } = await runRepl([
+        "function declared(/* one */ a, /* two */ b) {}",
+        "String(declared)",
+        "String((/* arrow */ a) => a)",
+        "class Klass { method(/* m */ a) {} }",
+        "String(Klass.prototype.method)",
+        ".exit",
+      ]);
+      expect(outputs).toEqual([
+        "undefined",
+        '"function declared(/* one */ a, /* two */ b) {}"',
+        '"(/* arrow */ a) => a"',
+        "[class Klass]",
+        '"method(/* m */ a) {}"',
+      ]);
+      expect(stderr).toBe("");
+      expect(exitCode).toBe(0);
+    });
+  });
+
   describe("-e / --eval and -p / --print", () => {
     async function runReplWith(args: string[]) {
       await using proc = Bun.spawn({
@@ -880,6 +903,13 @@ describe.concurrent("Bun REPL", () => {
       expect(exitCode).toBe(0);
     });
 
+    test("-p prints a parameter list that holds a comment as it is written", async () => {
+      const { stdout, stderr, exitCode } = await runReplWith(["-p", "String(function (/* token */ a) {})"]);
+      expect(stdout).toBe('"function(/* token */ a) {}"\n');
+      expect(stderr).toBe("");
+      expect(exitCode).toBe(0);
+    });
+
     test("--print works like -p", async () => {
       const { stdout, stderr, exitCode } = await runReplWith(["--print", "2 * 3"]);
       expect(stdout).toBe("6\n");
diff --git a/test/js/bun/sourcemap/source-positions-corpus.ts b/test/js/bun/sourcemap/source-positions-corpus.ts
index 2da0a01062cc..3c4186e915a4 100644
--- a/test/js/bun/sourcemap/source-positions-corpus.ts
+++ b/test/js/bun/sourcemap/source-positions-corpus.ts
@@ -1152,6 +1152,92 @@ export const cases: Record<string, Case> = {
     lines: `
  1|const text = "é汉🎉"; at(); import("./lazy.mjs"); at();
  1|export { text };
+`,
+  },
+  // The runtime prints a parameter list that holds a comment as it is written, on as many lines as it has.
+  "commented-parameters.cjs": {
+    functions: "2/3",
+    lines: `
+ 1|exports.first = function (
+ 1|  /* one */ a,
+ -|  // two
+ 1|  b,
+ -|) {
+ 1|  at();
+ -|};
+ 1|exports.never = function (/* one */ a,
+ 0|  b /* two */) {
+ 0|  at();
+ -|};
+ 1|exports.first(1, 2);
+ 1|function after() {
+ 1|  at();
+ -|}
+ 1|after();
+`,
+  },
+  "commented-parameters.mjs": {
+    functions: "2/2",
+    lines: `
+ 1|export const block = (
+ 1|  /* one */ a,
+ 1|  b, // two
+ -|) => {
+ 1|  at();
+ -|};
+ 1|export const expression = (
+ -|  // one
+ 1|  a,
+ 1|  /* two */ b,
+ 1|) => [a, b, at()].length;
+ 1|block(1, 2);
+ 1|expression(1, 2);
+`,
+  },
+  "commented-parameters.ts": {
+    functions: "3/3",
+    lines: `
+ 1|class Service {
+ 1|  constructor(
+ 1|    /* config.port */ port,
+ 1|    /* config.host */ host,
+ -|  ) {
+ 1|    at();
+ -|  }
+ 1|  method(/* the first */ a,
+ 1|    b) {
+ 1|    at();
+ -|  }
+ 1|  *each(
+ -|    // every value
+ 1|    ...values
+ -|  ) {
+ 1|    at();
+ 1|    yield* values;
+ -|  }
+ -|}
+ 1|const service = new Service(80, "localhost");
+ 1|service.method(1, 2);
+ 1|[...service.each(1, 2)];
+`,
+  },
+  // The "(" of such a list is where its function starts: an error that the call itself throws is there.
+  "commented-parameters-start.ts": {
+    functions: "3/3",
+    lines: `
+ 1|const object = {
+ 1|  method
+ 1|  (/* none */) {
+ 1|    at();
+ -|  },
+ 1|};
+ 1|object.method();
+ 1|class Klass {
+ 1|  constructor(/* the first */ a) {}
+ -|}
+ 1|try { (Klass as any)(1); } catch (e) { caught(e, "(/* the first */ a)"); }
+ 1|export const one = (/* the first */ a, b /* the last */) => [a, b, at()].length;
+ 1|one(1, 2);
 `,
   },
   // Columns far from the start of the line.
@@ -1205,6 +1291,11 @@ a {
 export const snapshots = `
 import { expect, test } from "bun:test";
 type Erased = number;
+const commented = function (
+  /* one */ a,
+  // two
+  b,
+) {};
 test("snapshots", () => {
   expect(1 as Erased).toMatchInlineSnapshot(«\`1\`»); expect("two").toMatchInlineSnapshot(«\`"two"\`»);
   expect(3)
diff --git a/test/js/bun/test/expect-extend.test.js b/test/js/bun/test/expect-extend.test.js
index 1426a2c7aac5..00ca9cb937e9 100644
--- a/test/js/bun/test/expect-extend.test.js
+++ b/test/js/bun/test/expect-extend.test.js
@@ -507,6 +507,48 @@ describe("a failing custom matcher's message is thrown unchanged", () => {
   });
 });
 
+// The hint names the parameters of the matcher, read from its text. A parameter list that holds a comment is printed as it is written.
+describe("a custom matcher whose parameter list holds comments", () => {
+  const matchers = {
+    _toHaveCommentedParameters(received, /* what it should be */ expected, other /* optional */) {
+      return { pass: true };
+    },
+    _toHaveCommentedLines(
+      received,
+      // what it should be
+      expected,
+      ...rest // the others
+    ) {
+      return { pass: true };
+    },
+    _toHaveOneCommentedParameter(received /* alone */) {
+      return { pass: true };
+    },
+  };
+  expect.extend(matchers);
+
+  test.skipIf(!isBun)("has a hint of the names alone", () => {
+    const listOf = matcher => String(matcher).slice(String(matcher).indexOf("("), String(matcher).indexOf(")") + 1);
+    expect(Object.values(matchers).map(listOf)).toEqual([
+      "(received, /* what it should be */ expected, other /* optional */)",
+      "(\n      received,\n      // what it should be\n      expected,\n      ...rest // the others\n    )",
+      "(received /* alone */)",
+    ]);
+    const hintOf = name => {
+      try {
+        /** @type {any} */ (expect(1).resolves)[name](2);
+      } catch (error) {
+        return Bun.stripANSI(error.message).split("\n")[0];
+      }
+    };
+    expect(Object.keys(matchers).map(hintOf)).toEqual([
+      "expect(received).resolves._toHaveCommentedParameters(expected, other)",
+      "expect(received).resolves._toHaveCommentedLines(expected, ...rest)",
+      "expect(received).resolves._toHaveOneCommentedParameter()",
+    ]);
+  });
+});
+
 describe("MatcherContext", () => {
   describe("utils", () => {
     test("RECEIVED_COLOR is a function", () => {
diff --git a/test/js/bun/test/mock/mock-module.test.ts b/test/js/bun/test/mock/mock-module.test.ts
index bbb5cefaa49f..ea1eeb18db35 100644
--- a/test/js/bun/test/mock/mock-module.test.ts
+++ b/test/js/bun/test/mock/mock-module.test.ts
@@ -1086,6 +1086,45 @@ describe.concurrent("the original of a mocked module", () => {
       ["--preload", "./preload.ts", ...args],
     );
   });
+
+  // The factory's text is searched for a mention of the original. A parameter list that holds a comment is printed as it is written, unless the list would be such a mention.
+  test("a comment in a parameter list is no mention of the original", async () => {
+    const names = ["a", "b", "c", "d", "e", "f", "g", "h", "i", "j"];
+    const original = (name: string) => `globalThis.loaded_${name} = true; export const value = "real";`;
+    await expectFixturesToPass(
+      {
+        ...Object.fromEntries(names.map(name => [`${name}.ts`, original(name)])),
+        "comment.test.ts": `
+          import { expect, test, vi } from "vitest";
+          ${names.map(name => `import { value as ${name} } from "./${name}";`).join("\n")}
+
+          vi.mock("./a", (/* importOriginal */) => ({ value: "mocked" }));
+          vi.mock("./b", async (/* importOriginal */) => ({ value: "mocked" }));
+          vi.mock("./c", function (/* importOriginal */) { return { value: "mocked" }; });
+          vi.mock("./d", async function (/* importOriginal */) { return { value: "mocked" }; });
+          vi.mock("./e", (
+            // importOriginal
+          ) => ({ value: "mocked" }));
+          vi.mock("./f", () => ({ value: "mocked", helper: (/* importOriginal */ x) => x }));
+          vi.mock("./g", () => ({ value: "mocked", helper(x /* see vi.importActual("./g") */) {} }));
+          vi.mock("./h", () => ({ value: "mocked", helper: function (/* not jest.requireActual("./h") */ x) {} }));
+          vi.mock("./i", (/* all of them */ ...importOriginal) => ({ value: "mocked" }));
+          vi.mock("./j", (/* nothing */) => ({ value: "mocked", importOriginal: 1 }));
+
+          test("a parameter or a property of that name is one", () => {
+            expect([String((/* importOriginal */) => 1), String((/* another comment */) => 1)]).toEqual([
+              "() => 1",
+              "(/* another comment */) => 1",
+            ]);
+            expect([${names.join(", ")}]).toEqual(Array(${names.length}).fill("mocked"));
+            const loaded = Object.keys(globalThis).filter(key => key.startsWith("loaded_"));
+            expect(loaded.sort()).toEqual(["loaded_i", "loaded_j"]);
+          });
+        `,
+      },
+      1,
+    );
+  });
 });
 
 describe.concurrent("a module mocked without a factory", () => {
diff --git a/test/js/bun/test/vitest-flavor.test.ts b/test/js/bun/test/vitest-flavor.test.ts
index c343e3008134..2499610adb3a 100644
--- a/test/js/bun/test/vitest-flavor.test.ts
+++ b/test/js/bun/test/vitest-flavor.test.ts
@@ -2150,6 +2150,41 @@ describe.concurrent("aroundEach and aroundAll", () => {
     });
   });
 
+  // The parameter is read from the text of the callback, and a parameter list that holds a comment is printed as it is written.
+  test("fixtures: the parameter list of a callback can hold comments", async () => {
+    const { log, results, errors, exitCode } = await runTests({
+      "a.test.js": `
+        import { test as base, describe, aroundEach } from "vitest";
+        const test = base.extend({ one: async ({}, use) => { await use("one"); } });
+        console.log(String((/* the context */ context) => {}));
+        describe("a list with no parameter", () => {
+          test("extended", (/* nothing is used */) => console.log("test without a parameter"));
+        });
+        describe("a parameter that is not a destructuring pattern", () => {
+          aroundEach((/* runs it */ runTest, /* the context */ context) => runTest());
+          test("extended", () => console.log("unreachable"));
+        });
+        describe("the same beside a comment that the printer writes by itself", () => {
+          aroundEach((/*! runs it */ runTest, /* the context */ context) => runTest());
+          test("extended", () => console.log("unreachable"));
+        });
+      `,
+    });
+    expect({ log, results, errors, exitCode }).toEqual({
+      log: ["(/* the context */ context) => {}", "test without a parameter"],
+      results: [
+        "(pass) a list with no parameter > extended",
+        "(fail) a parameter that is not a destructuring pattern > extended",
+        "(fail) the same beside a comment that the printer writes by itself > extended",
+      ],
+      errors: [
+        `error: The parameter that fixtures are destructured from must be an object destructuring pattern, received "context"`,
+        `error: The parameter that fixtures are destructured from must be an object destructuring pattern, received "context"`,
+      ],
+      exitCode: 1,
+    });
+  });
+
   test("skip() and test.fails", async () => {
     const { log, results, exitCode } = await runTests({
       "a.test.js": `