Flat String creation failing where it worked reliably before

I had re-flashed to 2.00

Are you uploading the exact same code you did with the exact same firmware when it worked?

The compiler shouldn't be an issue - it was a config problem on the server but the compiler itself didn't change.

If you were to 'save on send' to 'direct to flash' that would give you a bunch more available memory. If you'd had that on before, and had changed it back, that would have broken things.

I should add that it's not just that saving to flash gives you more memory, but it also doesn't save the function declarations to the command history, which means there's far less fragmentation.

Stack

Espruino doesn't allocate variables on the stack - they're all in one chunk of statically allocated memory. stackEndAddress really isn't a useful number for you to look at.

E.getSizeOf()

This scans the whole variable and everything it links (like if you ran trace(var)) - it's showing you the size of the object, all variables, all functions, and even any variables/functions in scopes that those functions were defined in.

When you go down a level to output data, you might have two functions that are defined in the same scope. Both of those functions will bring in the same scope so will be more or less the same (huge) size.

Is running process.memory() even needed as the board is just powered up, and the first initial 'send' is performed before any other tasks?

Yes - because the act of sending (which is creating loads of functions and even executing them) can fragment memory.

process.memory().free

It's most likely fragmentation - especially as you're using over 2/3 of your memory. The quick explanation is:

Unfragmented:  
"XXXXXXXX        "
allocating "XXXX" in one long chunk is easy

Fragmented:  
"X X X X X X X X "
allocating "XXXX" in one long chunk can't be done

In both cases there's the same amount of free memory, and the same amount used.

This is one of the reasons I suggest that you just leave Espruino to do its own thing. If you created arrays the normal way:

    this.ad = new Uint8ClampedArray(256);
    this.ar = new Uint8ClampedArray(nArySizeRGB);
    this.ab = new Uint8ClampedArray(nArySizeRGB);
    this.ac = new Uint8ClampedArray(nArySizeRGB));
    this.af = new Uint8ClampedArray(nArySizeRGB);
    this.ag = new Uint8ClampedArray(nArySizeRGB);

Espruino would automatically allocate flat strings for all those arrays, except if it couldn't find a big enough block of memory - in which case it would just allocate a normal String and continue perfectly fine, just a little bit slower.

Of course if you are trying to write C code to access the raw data as a char array then you'll hit problems - but if you're using compiled JS or just normal JS you'll be fine.