Currently the M5EPD library only supports a single loaded TTF font.
For most applications this is fine, but for something like an eReader or web browser it is limiting, as it means you can't have bold/italic/monospaced text.
For my own use, I've modified the library to allow multiple loaded TTF fonts, and I thought I'd share in case it is of use to anyone else.
This is still very experimental, so there may be issues I haven't encountered yet.
The way I've added this support to to use the textfont variable, which isn't currently used when TTF fonts are active. Calling setTextFont switches the currently active TTF font slot, and any subsequent loadFont/createRender/drawString calls will use that slot, until you change it again.
Each loaded font has its own set of render caches, and you can render each font at multiple, different, sizes.
You must call setTextSize each time you call setTextFont, as that is what selects the correct render for the font you have chosen.
This works with either file fonts or header fonts.
Example sketch:

#include "M5EPD.h"

#define USE_HEADER_FONTS 0

#if USE_HEADER_FONTS
#include "OpenSans_Regular.ttf.h"
#include "OpenSans_ExtraBold.ttf.h"
#include "OpenSans_Italic.ttf.h"
#include "OpenSans_ExtraBoldItalic.ttf.h"

std::vector<std::pair<const unsigned char*,uint32_t>> fonts = 
  {{OpenSans_Regular_ttf,sizeof(OpenSans_Regular_ttf)}
  ,{OpenSans_ExtraBold_ttf,sizeof(OpenSans_ExtraBold_ttf)}
  ,{OpenSans_Italic_ttf,sizeof(OpenSans_Italic_ttf)}
  ,{OpenSans_ExtraBoldItalic_ttf,sizeof(OpenSans_ExtraBoldItalic_ttf)}};
#else
std::vector<String> fonts = {"/Fonts/OpenSans-Regular.ttf","/Fonts/OpenSans-ExtraBold.ttf","/Fonts/OpenSans-Italic.ttf","/Fonts/OpenSans-ExtraBoldItalic.ttf"};
#endif

M5EPD_Canvas Canvas(&M5.EPD);

void setup() { 
  M5.begin();
  M5.EPD.SetRotation(90);
  M5.EPD.Clear(true);
  M5.TP.SetRotation(90);
  M5.RTC.begin();

  Canvas.createCanvas(540,960);

  Canvas.useFreetypeFont(true);
  Canvas.setFreeFont(nullptr);

  for( int font = 1 ; font <= 4 ; font++ )
  {
    Canvas.setTextFont(font); 
#if USE_HEADER_FONTS
    Canvas.loadFont(fonts[font-1].first,fonts[font-1].second); 
#else
    Canvas.loadFont(fonts[font-1],SD); 
#endif
    Canvas.createRender(48,32);
  }

  Canvas.setTextColor(15);
  Canvas.setTextDatum(TL_DATUM);

  int xPos = 64;
  for( int font = 1 ; font <= 4 ; font++ )
  {
    Canvas.setTextFont(font);
    Canvas.setTextSize(48);
    xPos += Canvas.drawString("Test ",xPos,64);
  }
  
  Canvas.pushCanvas(0,0,UPDATE_MODE_GC16);
}

void loop() {}

In this example I have loaded each font and created its render together, and created all fonts before using any of them. Neither of those is required, you can load fonts and create renders at any time, as long as you select the correct textfont before each operation. You can also delete renders, unload fonts and load a new font into the slot, as long as no canvases are using that slot.

Edit: The updated M5EPD library is available at https://github.com/murraypaul/M5EPD

@felmue You can load a single TTF font and pre-render at different sizes in different canvases, that works fine. The problem only occurs with deleteRender, loadFont or unloadFont.

Yes, re-loading the font each time works, provided the performance is acceptable.
Loading the GenSenRounded font takes around 220 ms for me, while Roboto takes only around 50 ms, so depending on the font this isn't something you would want to be doing lots of times per page on an application that needs to be user-responsive. The timings are consistent, so it isn't something that improves with repeated calls due to caching. (Obviously the actual timings will depend on your SD card.)

Some other options:

a) Convert the TTF files to headers and include them in your project. This drops the loadFont times to 13/3 ms (and also drops the createRender times, but they are already pretty fast).
Downside is that GenSensRounded uses a huge amount of memory. The sample project with the two fonts included uses over 4MB of the 6.5MB available program memory.

b) If you know in advance the font sizes you want to use, convert the TTF fonts to header-stored GFXFF fonts. These are massively smaller, and there is no cross-canvas interference, so you can just load the correct font once for each canvas and not worry about it after that.

Both options are discussed in this thread: https://community.m5stack.com/topic/2732/m5paper-text/19

In general, if you have a simple UI and know in advance which fonts and sizes you want to use, the GFXFF font approach is better, it is fast, uses little memory and doesn't depend on having files stored on the SD card.

Someone had asked in another thread whether there was an easy way to take a screenshot of the M5Paper.
I've put together a function to do that.
It can take a screenshot in two formats. 16 colour (4bpp) BMP makes the most sense, as that is what the device can actually display, and only takes about 250KB, but full colour (24bpp) BMP is the format that the device can easily read back in again, and takes about 1.5MB.
This is recording what is stored in the canvas framebuffer, not what is actually displayed on the screen. They will be different if you have called drawing functions and not yet called pushCanvas, or if you are using multiple canvases.
Taking a full screen 24bpp screenshot is quite slow, taking about 10 seconds on my SD card.

bool takeScreenshot( M5EPD_Canvas& canvas, String filename, bool bFull24bpp = true, int xPos = 0, int yPos = 0, int xSize = -1, int ySize = -1 )
{
  File bmpFile = SD.open(filename,FILE_WRITE);
  if( !bmpFile )
  {
    log_e("Failed to open '%s' for write",filename);
    return false;
  }
  
  xSize = max( 1, min( xSize == -1 ? canvas.width() : xSize, canvas.width() - xPos ) ); 
  ySize = max( 1, min( ySize == -1 ? canvas.height() : ySize, canvas.height() - yPos ) ); 
  if( !bFull24bpp && xSize % 2 == 1 ) xSize++;
  
  log_d("Taking %d x %d screenshot to '%s'", xSize, ySize, filename);

  size_t bytes_written = 0;
  auto write8 = [&file=bmpFile,&bytes_written]( uint8_t data )
  {
    bytes_written += file.write(data); 
  };
  auto write16 = [&file=bmpFile,&bytes_written]( uint16_t data )
  {
    bytes_written += file.write(((uint8_t *)&data)[0]); 
    bytes_written += file.write(((uint8_t *)&data)[1]);  
  };
  auto write32 = [&file=bmpFile,&bytes_written]( uint32_t data )
  {
    bytes_written += file.write(((uint8_t *)&data)[0]); 
    bytes_written += file.write(((uint8_t *)&data)[1]);  
    bytes_written += file.write(((uint8_t *)&data)[2]);  
    bytes_written += file.write(((uint8_t *)&data)[3]);  
  };
  auto writeN = [&file=bmpFile,&bytes_written]( uint8_t* data, size_t N )
  {
    bytes_written += file.write(data,N); 
  };  

  uint8_t bpp = bFull24bpp ? 24 : 4;
  size_t bmpHeaderSize = 14;
  size_t dibHeaderSize = 40;
  size_t colourTableSize = bpp == 24 ? 0 : pow(2,bpp)*4;
  size_t gap1Size = 2;
  size_t rowSize = ceil(bpp * xSize / 32.0) * 4;
  size_t rowGap = rowSize - (bpp * xSize / 32.0) * 4;
  size_t pixelArraySize = rowSize * ySize;
  size_t pixelArrayOffset = bmpHeaderSize + dibHeaderSize + colourTableSize + gap1Size;
  size_t expectedSize = pixelArrayOffset + pixelArraySize;
//  log_d("Expected size %d, row size %d, row gap %d, pixel array offset %d, pixel array size = %d",expectedSize, rowSize, rowGap, pixelArrayOffset, pixelArraySize);
  
  write16( 0x4D42 );
  write32( expectedSize );
  write32( 0 );
  write32( pixelArrayOffset );
  
  write32( dibHeaderSize );
  write32( xSize );
  write32( ySize );
  write16( 1 );
  write16( bpp );
  write32( 0 );
  write32( 0 );
  write32( 9252 );
  write32( 9252 );
  write32( 0 );
  write32( 0 );

  // From M5EPD_Canvas.cpp
  const uint8_t alphamap[16] = {0, 17, 34, 51, 68, 85, 102, 119, 136, 153, 170, 187, 204, 221, 238, 255};
  if( bpp == 4 )
  {
    uint8_t buffer[16*4];
    int iCount = 0;
    for( int i = 0 ; i < 16 ; i++ )
    {
      uint8_t value = 255-alphamap[i];
      buffer[iCount++] = value;
      buffer[iCount++] = value;
      buffer[iCount++] = value;
      buffer[iCount++] = 0;
    }
    writeN(buffer,iCount);
  }
  for( int i = 0 ; i < gap1Size ; i++ )
    write8( 0 );

  uint8_t buffer[960*3];
//  log_d("After headers, bytes_written = %d",bytes_written);
  for( int y = ySize + yPos - 1; y >= yPos ; y-- )
  {
    int iCount = 0; 
    for( int x = xPos ; x < xSize + xPos ; x++ )
    {
      uint16_t pixel = canvas.readPixel(x,y);
      uint8_t value = min(pixel,(uint16_t)15); 
      switch( bpp )
      {
        case 24:
        default:
          value = alphamap[15-min(value,(uint8_t)15)];
          buffer[iCount++] = value;
          buffer[iCount++] = value;
          buffer[iCount++] = value;
          break;
        case 4:
          if( (x-xPos) % 2 == 0 )
            buffer[iCount] = (value << 4) & 0xf0;
          else
          {
            buffer[iCount] |= value & 0x0f;          
            iCount++;
          }
          break;
      }
    }
    for( int gap = 0 ; gap < rowGap ; gap++ )
      buffer[iCount++] = 0;
    writeN(buffer,iCount);
  }

  bmpFile.close();

  if( bytes_written != expectedSize )
    log_e("Total bytes written %d vs expected %d",bytes_written,expectedSize);
  
  log_d("Screenshot done");
  
  return true;
}

Source available here: https://github.com/murraypaul/M5Sudoku

M5Sudoku

Sudoku application for M5Paper

Can generate uniquely solveable Sudoku puzzles, targetting a given number of clues, to act as a difficulty setting.

At any point, can validate that the puzzle is still solvable.

Can mark squares as either a known value, or a set of possible values.

Can save and reload current state to EEPROM.

Will automatically shutdown and save state after 5 minutes of inactivity.

Notes:

• Selecting a square in the large grid will display it in the small grid on the right
• The selected square is highlighted in the large grid
• You can use the small grid to either set a single known value for the square, or select multiple possible values
• It may not be possible to generate a uniquely solveable puzzle of the given numbers of clues in the time requested
• In this situation, the puzzle with the lowest number of clues that still gives a unqiue solution will be returned
• The fewer target clues you ask for, the longer it will take to generate the puzzle
• The 'Validate' button will confirm that the puzzle is still uniquely solveable
• The 'Clue' button will fill in one randon unsolved square
• Over time the screen may get a bit muddy, due to the fast refresh option used on the EPD screen
• The 'Validate' button will also do a full screen slow refresh, which will clean up the display

The most likely issue is that the filename you pass doesn't start with '/', which is required by the SD library.

To view the logging output, assuming you are using the Arduino UI, first do Tools->Core Debug Level->Set to Debug or Verbose. Then do Tools->Serial Monitor.
You will see debug output from the M5Paper appear in the serial monitor window.

Just received the following notification from Digi-Key:

You have purchased the following part number from Digi-Key within the last two years. The manufacturer has announced an update to the part status.
Part Affected
Manufacturer M5STACK TECHNOLOGY CO., LTD
Description M5PAPER ESP32 DEV KIT 4.7"E-INK
Manufacturer Part Number K049
Digi-Key Part Number 2221-K049-ND
Status Obsolete
Substitutes Please click here

Digging around leads to: https://media.digikey.com/pdf/PCNs/M5Stack/PCN20210513-01.pdf

Which contains: "The display driver chipset for K049 cannot be purchased and supplier from our vendor any more. We will look for new display driver as the alternative material. This version will stop for sale. "