Unhandled stream error terminates Node process in gulp.src pipeline

Answer

No. An error listener on gulp.dest() only protects the destination stream and errors that upstream plugins explicitly forward to it. It does not catch errors emitted by gulp.src() or intermediate transform streams, because Node stream error events are scoped to the stream that emits them and .pipe() does not forward them automatically. Wrapping the pipeline in gulp.series() does not change this behavior; it only determines whether the next task runs after the current task fails.

Confirmed behavior

• Node.js streams emit error on the instance where the failure occurs.
• .pipe() connects data flow, not error flow, unless the upstream implementation forwards errors.
• An unhandled stream error can crash the Node process.
• Gulp 4 tracks a task only if the task function returns the stream, a promise, or calls the callback.
• gulp.series() aborts remaining tasks when a task errors, but it does not alter how errors move through a single pipeline.

Likely explanation

Whether a gulp.dest() listener sees an upstream error depends on the plugin. Some transform plugins forward errors downstream; others emit locally, swallow them, or reformat them. That variation makes a dest-only handler unreliable for this case.

Steps for this case

1. Return the pipeline from the Gulp 4 task so Gulp can track completion.
2. Attach one error handler as early as practical, ideally on gulp.src(), or use gulp-plumber after src to forward errors downstream instead of crashing.
3. Keep a dest-side listener only if you also need to handle errors originating in the write destination itself.

const { src, dest, series } = require('gulp');
const plumber = require('gulp-plumber');

function build() {
  return src('src/**/*')
    .on('error', function (err) {
      console.error('Pipeline error:', err.message);
      this.emit('end');
    })
    .pipe(plumber({ errorHandler: (err) => {
      console.error('Plumber error:', err.message);
      this.emit('end');
    } }))
    .pipe(dest('dist'));
}

exports.default = series(build, function next() {
  console.log('next task');
});

Using both .on('error') on src and plumber is redundant; choose one approach per pipeline. The example shows the pattern, not a recommendation to stack handlers.

gulp.series() effect

gulp.series(build, next) runs next only when build signals success. If build returns a stream that emits an unhandled error, Gulp aborts the series and next does not run. Handling the error inside build and emitting end lets the series continue.

Verification

• Run gulp -v and confirm the major version is 4.
• Create a minimal task with a transform that throws, attach .on('error') only to dest(), and confirm the process exits.
• Repeat with a handler on src() or plumber and confirm the process stays alive and the handler runs.
• Wrap both variants in gulp.series() with a second logging task to confirm abort versus continue behavior.

One diagnostic detail that changes the recommendation: which transform plugin is throwing and whether it forwards errors through through2 or stream.pipeline. Plugin-specific documentation determines whether a dest-only listener could ever be sufficient.