Node v26.3.0 error-message parity: restore 19 upstream tests to verbatim text

src/js/internal/validators.ts

@@ -121,9 +121,29 @@ function getValidatedFsPath(p: any, propName: string = "path") {
   throw $ERR_INVALID_ARG_TYPE(propName, ["string", "Buffer", "URL"], p);
 }
 
+// One-shot latch: node:fs and node:fs/promises share it, so it lives here
+// alongside the other helpers both modules pull from internal/fs/utils.
+var nonPortableTemplateWarn = true;
+
+// https://github.com/nodejs/node/blob/v26.3.0/lib/internal/fs/utils.js#L883-L893
+// mkdtemp() templates ending in X are handled inconsistently across platforms.
+function warnOnNonPortableTemplate(template: any) {
+  if (
+    nonPortableTemplateWarn &&
+    ((typeof template === "string" && template.endsWith("X")) ||
+      (typeof template !== "string" && template?.at?.(-1) === 0x58))
+  ) {
+    nonPortableTemplateWarn = false;
+    process.emitWarning(
+      "mkdtemp() templates ending with X are not portable. For details see: https://nodejs.org/api/fs.html",
+    );
+  }
+}
+
 hideFromStack(validateLinkHeaderValue);
 hideFromStack(validateString, validateFunction, validateBoolean);
 hideFromStack(getValidatedPath, getValidatedFsPath, throwIfNullBytesInFileName);
+hideFromStack(warnOnNonPortableTemplate);
 
 export default {
   /** (value, name) */
@@ -166,4 +186,5 @@ export default {
   getValidatedFsPath,
   /** `(filename)` */
   throwIfNullBytesInFileName,
+  warnOnNonPortableTemplate,
 };

src/js/node/fs.promises.ts

@@ -9,6 +9,7 @@ const {
   validateObject,
   validateAbortSignal,
   validateEncoding,
+  warnOnNonPortableTemplate,
 } = require("internal/validators");
 
 const constants = $processBindingConstants.fs;
@@ -283,8 +284,12 @@ const exports = {
   link: asyncWrap(fs.link, "link"),
   lstat: asyncWrap(fs.lstat, "lstat"),
   mkdir: asyncWrap(fs.mkdir, "mkdir"),
-  mkdtemp: asyncWrap(fs.mkdtemp, "mkdtemp"),
+  mkdtemp: async function mkdtemp(prefix, options) {
+    warnOnNonPortableTemplate(prefix);
+    return fs.mkdtemp(prefix, options);
+  },
   mkdtempDisposable: async function mkdtempDisposable(prefix, options) {
+    warnOnNonPortableTemplate(prefix);
     const path = await fs.mkdtemp(prefix, options);
     // Stash the full path in case of process.chdir()
     const fullPath = require("node:path").resolve(path);

src/js/node/fs.ts

@@ -8,6 +8,7 @@ const {
   validateEncoding,
   getValidatedPath,
   throwIfNullBytesInFileName,
+  warnOnNonPortableTemplate,
 } = require("internal/validators");
 
 const kEmptyObject = Object.freeze(Object.create(null));
@@ -31,6 +32,9 @@ function wrapFsCallback(callback) {
   return guardCallback(callback);
 }
 
+// One-shot latch for the DEP0187 warning node:fs emits at most once per process.
+var showExistsDeprecation = true;
+
 // Validates and returns the wrapped callback.
 // Callers must use the return value, not the argument.
 function ensureCallback(callback) {
@@ -216,6 +220,7 @@ var access = function access(path, mode, callback) {
     }
 
     callback = ensureCallback(callback);
+    warnOnNonPortableTemplate(prefix);
 
     fs.mkdtemp(prefix, options).then(function (folder) {
       callback(null, folder);
@@ -465,8 +470,22 @@ var access = function access(path, mode, callback) {
   closeSync = fs.closeSync.bind(fs),
   copyFileSync = fs.copyFileSync.bind(fs),
   // This behavior - never throwing -- matches Node.js behavior.
-  // https://github.com/nodejs/node/blob/c82f3c9e80f0eeec4ae5b7aedd1183127abda4ad/lib/fs.js#L275C1-L295C1
-  existsSync = function existsSync(_path: string) {
+  // https://github.com/nodejs/node/blob/v26.3.0/lib/fs.js#L273-L287
+  existsSync = function existsSync(path: string) {
+    // Node's getValidatedPath accepts only a string, a Uint8Array, or a URL;
+    // anything else is the ERR_INVALID_ARG_TYPE that DEP0187 warns about once
+    // before existsSync swallows it and answers false.
+    if (typeof path !== "string" && !$isTypedArrayView(path) && !(path instanceof URL)) {
+      if (showExistsDeprecation) {
+        showExistsDeprecation = false;
+        process.emitWarning(
+          "Passing invalid argument types to fs.existsSync is deprecated",
+          "DeprecationWarning",
+          "DEP0187",
+        );
+      }
+      return false;
+    }
     try {
       return fs.existsSync.$apply(fs, arguments);
     } catch {
@@ -486,7 +505,10 @@ var access = function access(path, mode, callback) {
   linkSync = fs.linkSync.bind(fs) as unknown as typeof import("node:fs").linkSync,
   lstatSync = fs.lstatSync.bind(fs) as unknown as typeof import("node:fs").lstatSync,
   mkdirSync = fs.mkdirSync.bind(fs) as unknown as typeof import("node:fs").mkdirSync,
-  mkdtempSync = fs.mkdtempSync.bind(fs) as unknown as typeof import("node:fs").mkdtempSync,
+  mkdtempSync = function mkdtempSync(prefix, options) {
+    warnOnNonPortableTemplate(prefix);
+    return fs.mkdtempSync(prefix, options);
+  } as unknown as typeof import("node:fs").mkdtempSync,
   mkdtempDisposableSync = function mkdtempDisposableSync(prefix, options) {
     const path = mkdtempSync(prefix, options);
     // Stash the full path in case of process.chdir()

src/js/node/zlib.ts

@@ -114,7 +114,11 @@ function zlibBufferSync(engine, buffer) {
     if (isAnyArrayBuffer(buffer)) {
       buffer = Buffer.from(buffer);
     } else {
-      throw $ERR_INVALID_ARG_TYPE("buffer", "string, Buffer, TypedArray, DataView, or ArrayBuffer", buffer);
+      throw $ERR_INVALID_ARG_TYPE(
+        "buffer",
+        "string or an instance of Buffer, TypedArray, DataView, or ArrayBuffer",
+        buffer,
+      );
     }
   }
   buffer = processChunkSync(engine, buffer, engine._finishFlushFlag);

src/jsc/bindings/JSDOMExceptionHandling.cpp

@@ -269,26 +269,32 @@ JSC::EncodedJSValue rejectPromiseWithGetterTypeError(JSC::JSGlobalObject& lexica
     return createRejectedPromiseWithTypeError(lexicalGlobalObject, JSC::makeDOMAttributeGetterTypeErrorMessage(classInfo->className, String(attributeName.uid())), RejectedPromiseWithTypeErrorCause::NativeGetter);
 }
 
-String makeThisTypeErrorMessage(ASCIILiteral interfaceName, ASCIILiteral functionName)
+// Node words every ERR_INVALID_THIS the same way regardless of which member
+// was called: `Value of "this" must be of type <interface>`.
+// https://github.com/nodejs/node/blob/v26.3.0/lib/internal/errors.js
+String makeThisTypeErrorMessage(ASCIILiteral interfaceName)
 {
-    return makeString("Can only call "_s, interfaceName, '.', functionName, " on instances of "_s, interfaceName);
+    return makeString("Value of \"this\" must be of type "_s, interfaceName);
 }
 
 EncodedJSValue throwThisTypeError(JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope, ASCIILiteral interfaceName, ASCIILiteral attributeName)
 {
-    scope.throwException(&lexicalGlobalObject, Bun::createInvalidThisError(&lexicalGlobalObject, makeThisTypeErrorMessage(interfaceName, attributeName)));
+    UNUSED_PARAM(attributeName);
+    scope.throwException(&lexicalGlobalObject, Bun::createInvalidThisError(&lexicalGlobalObject, makeThisTypeErrorMessage(interfaceName)));
     return {};
 }
 
 JSC::EncodedJSValue rejectPromiseWithThisTypeError(DeferredPromise& promise, ASCIILiteral interfaceName, ASCIILiteral methodName)
 {
-    promise.reject(ExceptionCode::InvalidThisError, makeThisTypeErrorMessage(interfaceName, methodName));
+    UNUSED_PARAM(methodName);
+    promise.reject(ExceptionCode::InvalidThisError, makeThisTypeErrorMessage(interfaceName));
     return JSValue::encode(jsUndefined());
 }
 
 JSC::EncodedJSValue rejectPromiseWithThisTypeError(JSC::JSGlobalObject& lexicalGlobalObject, ASCIILiteral interfaceName, ASCIILiteral methodName)
 {
-    return createRejectedPromiseWithTypeError(lexicalGlobalObject, makeThisTypeErrorMessage(interfaceName, methodName), RejectedPromiseWithTypeErrorCause::InvalidThis);
+    UNUSED_PARAM(methodName);
+    return createRejectedPromiseWithTypeError(lexicalGlobalObject, makeThisTypeErrorMessage(interfaceName), RejectedPromiseWithTypeErrorCause::InvalidThis);
 }
 
 void throwDataCloneError(JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& scope)

src/jsc/bindings/JSDOMExceptionHandling.h

@@ -49,7 +49,7 @@ WEBCORE_EXPORT JSC::EncodedJSValue throwRequiredMemberTypeError(JSC::JSGlobalObj
 WEBCORE_EXPORT JSC::EncodedJSValue throwDictionaryMemberTypeError(JSC::JSGlobalObject&, JSC::ThrowScope&, ASCIILiteral memberName, ASCIILiteral dictionaryName, ASCIILiteral expectedType);
 JSC::EncodedJSValue throwConstructorScriptExecutionContextUnavailableError(JSC::JSGlobalObject&, JSC::ThrowScope&, ASCIILiteral interfaceName);
 
-String makeThisTypeErrorMessage(ASCIILiteral interfaceName, ASCIILiteral functionName);
+String makeThisTypeErrorMessage(ASCIILiteral interfaceName);
 
 WEBCORE_EXPORT JSC::EncodedJSValue throwThisTypeError(JSC::JSGlobalObject&, JSC::ThrowScope&, ASCIILiteral interfaceName, ASCIILiteral attributeName);
 

src/jsc/bindings/webcore/JSDOMIterator.h

@@ -261,7 +261,7 @@ JSC::EncodedJSValue JSC_HOST_CALL_ATTRIBUTES JSDOMIteratorPrototype<JSWrapper, I
 
     auto iterator = dynamicDowncast<JSDOMIteratorBase<JSWrapper, IteratorTraits>>(callFrame->thisValue());
     if (!iterator) {
-        return Bun::throwError(globalObject, scope, Bun::ErrorCode::ERR_INVALID_THIS, "Cannot call next() on a non-Iterator object"_s);
+        return Bun::throwError(globalObject, scope, Bun::ErrorCode::ERR_INVALID_THIS, makeString("Value of \"this\" must be of type "_s, JSWrapper::info()->className, "Iterator"_s));
     }
 
     RELEASE_AND_RETURN(scope, JSC::JSValue::encode(iterator->next(*globalObject)));

src/jsc/bindings/webcore/JSURLSearchParams.cpp

@@ -40,6 +40,7 @@
 #include "JSDOMIterator.h"
 #include "JSDOMOperation.h"
 #include "JSDOMWrapperCache.h"
+#include "ErrorCode.h"
 #include <JavaScriptCore/BuiltinNames.h>
 #include <JavaScriptCore/FunctionPrototype.h>
 #include <JavaScriptCore/HeapAnalyzer.h>
@@ -388,7 +389,7 @@ static inline JSC::EncodedJSValue jsURLSearchParamsPrototypeFunction_appendBody(
     UNUSED_PARAM(callFrame);
     auto& impl = castedThis->wrapped();
     if (callFrame->argumentCount() < 2) [[unlikely]]
-        return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
+        return Bun::ERR::MISSING_ARGS(throwScope, lexicalGlobalObject, "The \"name\" and \"value\" arguments must be specified"_s);
     EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
     auto name = convert<IDLUSVString>(*lexicalGlobalObject, argument0.value());
     RETURN_IF_EXCEPTION(throwScope, {});
@@ -411,7 +412,7 @@ static inline JSC::EncodedJSValue jsURLSearchParamsPrototypeFunction_deleteBody(
     UNUSED_PARAM(callFrame);
     auto& impl = castedThis->wrapped();
     if (callFrame->argumentCount() < 1) [[unlikely]]
-        return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
+        return Bun::ERR::MISSING_ARGS(throwScope, lexicalGlobalObject, "The \"name\" argument must be specified"_s);
     EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
     auto name = convert<IDLUSVString>(*lexicalGlobalObject, argument0.value());
     RETURN_IF_EXCEPTION(throwScope, {});
@@ -439,7 +440,7 @@ static inline JSC::EncodedJSValue jsURLSearchParamsPrototypeFunction_getBody(JSC
     UNUSED_PARAM(callFrame);
     auto& impl = castedThis->wrapped();
     if (callFrame->argumentCount() < 1) [[unlikely]]
-        return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
+        return Bun::ERR::MISSING_ARGS(throwScope, lexicalGlobalObject, "The \"name\" argument must be specified"_s);
     EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
     auto name = convert<IDLUSVString>(*lexicalGlobalObject, argument0.value());
     RETURN_IF_EXCEPTION(throwScope, {});
@@ -459,7 +460,7 @@ static inline JSC::EncodedJSValue jsURLSearchParamsPrototypeFunction_getAllBody(
     UNUSED_PARAM(callFrame);
     auto& impl = castedThis->wrapped();
     if (callFrame->argumentCount() < 1) [[unlikely]]
-        return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
+        return Bun::ERR::MISSING_ARGS(throwScope, lexicalGlobalObject, "The \"name\" argument must be specified"_s);
     EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
     auto name = convert<IDLUSVString>(*lexicalGlobalObject, argument0.value());
     RETURN_IF_EXCEPTION(throwScope, {});
@@ -479,7 +480,7 @@ static inline JSC::EncodedJSValue jsURLSearchParamsPrototypeFunction_hasBody(JSC
     UNUSED_PARAM(callFrame);
     auto& impl = castedThis->wrapped();
     if (callFrame->argumentCount() < 1) [[unlikely]]
-        return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
+        return Bun::ERR::MISSING_ARGS(throwScope, lexicalGlobalObject, "The \"name\" argument must be specified"_s);
     EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
     auto name = convert<IDLUSVString>(*lexicalGlobalObject, argument0.value());
     RETURN_IF_EXCEPTION(throwScope, {});
@@ -507,7 +508,7 @@ static inline JSC::EncodedJSValue jsURLSearchParamsPrototypeFunction_setBody(JSC
     UNUSED_PARAM(callFrame);
     auto& impl = castedThis->wrapped();
     if (callFrame->argumentCount() < 2) [[unlikely]]
-        return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
+        return Bun::ERR::MISSING_ARGS(throwScope, lexicalGlobalObject, "The \"name\" and \"value\" arguments must be specified"_s);
     EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
     auto name = convert<IDLUSVString>(*lexicalGlobalObject, argument0.value());
     RETURN_IF_EXCEPTION(throwScope, {});

src/runtime/node/node_fs.rs

@@ -153,9 +153,9 @@ use bun_jsc::AbortSignalRef;
 use super::stat::Stats;
 use super::time_like::TimeLike;
 use super::types::{
-    ArgumentsSlice, Dirent, Encoding, FdArgExt as _, FileSystemFlags, FileSystemFlagsKind,
-    NameTooLong, PathLike, PathLikeExt as _, PathOrFdExt as _, StringObjects, StringOrBuffer,
-    VectorArrayBuffer,
+    ArgumentsSlice, BUFFER_EXPECTED_TYPES, Dirent, Encoding, FdArgExt as _, FileSystemFlags,
+    FileSystemFlagsKind, NameTooLong, PathLike, PathLikeExt as _, PathOrFdExt as _, StringObjects,
+    StringOrBuffer, VectorArrayBuffer,
 };
 // Re-exported publicly: `crate::node::fs::PathOrFileDescriptor` is the
 // canonical path used by `cli/build_command.rs` et al., and `node_fs::Flavor`
@@ -2671,9 +2671,7 @@ pub mod args {
     fs_args_path_forwarders!(Truncate; path);
     impl Truncate {
         pub fn from_js(ctx: &JSGlobalObject, arguments: &mut ArgumentsSlice) -> JsResult<Truncate> {
-            let path = PathOrFileDescriptor::from_js(ctx, arguments)?.ok_or_else(|| {
-                ctx.throw_invalid_arguments(format_args!("path must be a string or TypedArray"))
-            })?;
+            let path = PathOrFileDescriptor::from_js_required(ctx, arguments, "path")?;
             let len: u64 = 'brk: {
                 let Some(len_value) = arguments.next() else {
                     break 'brk 0;
@@ -3717,14 +3715,35 @@ pub mod args {
                             break 'parse;
                         }
                         let length = current.to_int64();
-                        let max_len = ((buf_len as u64 - args.offset) as i64).min(i32::MAX as i64);
-                        if length > max_len || length < 0 {
+                        // validateOffsetLengthWrite then validateInt32(length, 'length', 0),
+                        // in that order — each stage words its range differently.
+                        let remaining = (buf_len as u64 - args.offset) as i64;
+                        if length > remaining {
+                            return Err(ctx.throw_range_error(
+                                length as f64,
+                                bun_jsc::RangeErrorOptions {
+                                    field_name: b"length",
+                                    max: remaining,
+                                    ..Default::default()
+                                },
+                            ));
+                        }
+                        if length < 0 {
                             return Err(ctx.throw_range_error(
                                 length as f64,
                                 bun_jsc::RangeErrorOptions {
                                     field_name: b"length",
                                     min: 0,
-                                    max: max_len,
+                                    ..Default::default()
+                                },
+                            ));
+                        }
+                        if length > i32::MAX as i64 {
+                            return Err(ctx.throw_range_error(
+                                length as f64,
+                                bun_jsc::RangeErrorOptions {
+                                    field_name: b"length",
+                                    msg: b">= 0 && <= 2147483647",
                                     ..Default::default()
                                 },
                             ));
@@ -3849,7 +3868,11 @@ pub mod args {
                 0.0
             };
             let buffer = Buffer::from_js(ctx, buffer_value).ok_or_else(|| {
-                ctx.throw_invalid_argument_type_value(b"buffer", b"TypedArray", buffer_value)
+                ctx.throw_invalid_argument_type_value2(
+                    b"buffer",
+                    BUFFER_EXPECTED_TYPES,
+                    buffer_value,
+                )
             })?;
 
             //   if (length === 0) {
@@ -3870,9 +3893,12 @@ pub mod args {
 
             let buf_len = buffer.slice().len();
             if buf_len == 0 {
+                let received = JSGlobalObject::inspect_for_error_message(ctx, buffer_value)?;
                 return Err(validators::throw_err_invalid_arg_value(
                     ctx,
-                    format_args!("The argument 'buffer' is empty and cannot be written."),
+                    format_args!(
+                        "The argument 'buffer' is empty and cannot be written. Received {received}"
+                    ),
                 ));
             }
             // validateOffsetLengthRead(offset, length, buffer.byteLength);
@@ -4052,11 +4078,7 @@ pub mod args {
         pub fn from_js(ctx: &JSGlobalObject, arguments: &mut ArgumentsSlice) -> JsResult<ReadFile> {
             // `Drop` on `path` covers every
             // `?`-propagated JsError below.
-            let path = PathOrFileDescriptor::from_js(ctx, arguments)?.ok_or_else(|| {
-                ctx.throw_invalid_arguments(format_args!(
-                    "path must be a string or a file descriptor"
-                ))
-            })?;
+            let path = PathOrFileDescriptor::from_js_required(ctx, arguments, "path")?;
             let mut encoding = Encoding::Buffer;
             let mut flag = FileSystemFlags::R;
             let mut abort_signal = scopeguard::guard(None::<AbortSignalRef>, |s| {
@@ -4150,11 +4172,7 @@ pub mod args {
         ) -> JsResult<WriteFile> {
             // `Drop` on `path` covers every
             // `?`-propagated JsError below.
-            let path = PathOrFileDescriptor::from_js(ctx, arguments)?.ok_or_else(|| {
-                ctx.throw_invalid_arguments(format_args!(
-                    "path must be a string or a file descriptor"
-                ))
-            })?;
+            let path = PathOrFileDescriptor::from_js_required(ctx, arguments, "path")?;
             let data_value = arguments
                 .next_eat()
                 .ok_or_else(|| ctx.throw_invalid_arguments(format_args!("data is required")))?;