The font comes from a chip, not from RAM that remembers

videoReset zeroed video memory and then wrote the font and the sixteen colour
schemes into it, and the comment above that said out loud what was wrong with
it: "everything here is ordinary video memory". RAM does not wake up with
anything in it. That was the last piece of magic in this device, and it looked
harmless until something wanted the font BACK - a program that redefines a glyph
had destroyed the only copy there was.

So the device has a character generator, the way the machines this one is
pretending to be really did, and the copy into RAM is a thing it DOES rather
than a state it mysteriously starts in. Command port 0x39: bit 0 for the font,
bit 1 for the schemes.

THE RAM IS STILL RAM. A program may overwrite every glyph and every colour and
should be able to, which is what makes this a tile engine rather than a text
display. What changed is that it is no longer a one way door.

NEITHER COMMAND CLEARS WHAT IT DOES NOT OWN. The font used to clear the whole of
tile memory before writing itself, which was harmless while it happened only at
reset and is wrong the moment a program can ask: a program that defined a tile
of its own and then wanted its text back would have paid for it with the tile.

The reason it is a chip rather than a file on the disk, which was the other
candidate: the boot chain prints before CosmOS exists. Stage one prints "?" when
there is nothing to boot, and if the font came off the disk then the message
about the disk having failed would be the one thing that could not be drawn. A
system that wants its own font still loads one over the top - the ROM is the
floor, not the policy.

Two things that had been worked around now simply work. The shell asks for both
whenever a program exits, so a program that redefined a letter no longer leaves
it unable to spell, and Grid no longer needs to have saved the screen to avoid
handing back green text on blue. And the fault screen asks for the glyphs first,
because a message spelled in somebody's tile graphics is no message at all.

Five video checks. Two runs each for the font and the schemes, since the map
holds a tile NUMBER and the glyph is looked up when the frame is drawn - so
restoring changes every cell using it, including ones drawn before, and what the
two runs differ by is the command. The third guards the decision not to clear:
tile 200 has to survive the font coming back.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01E2JrLzFvuFX9fgi1LDRjrW

Source/Emulator/video.c

@@ -119,11 +119,15 @@ void videoTick(unsigned long now) {
 }
 
 void videoLoadFont(void) {
-    // One bit a pixel becomes one byte a pixel: index 1 where the font has a dot and 0
-    // where it does not, which is what makes the two palette entries below mean ink and
-    // paper. Glyphs the font does not have are left blank rather than left as whatever was
-    // in tile memory.
-    memset(videoRAM + VIDEO_TILE_BASE, 0, (size_t)VIDEO_TILE_COUNT * VIDEO_TILE_BYTES);
+    // One bit a pixel becomes one byte a pixel: index 1 where the font has a dot and 0 where
+    // it does not, which is what makes the two palette entries of a scheme mean ink and
+    // paper.
+    //
+    // ONLY THE GLYPHS THE ROM HAS. Tile memory used to be cleared first, on the grounds that
+    // a glyph the font does not have should be blank rather than whatever was there - which
+    // was fine while this happened at reset and nothing else, and is wrong now that a program
+    // can ask for it. A program that defined a tile of its own above the font and then wanted
+    // its text back would have lost the tile to get it.
     for (int glyph = 0; glyph < CONSOLE_FONT_GLYPHS && glyph < VIDEO_TILE_COUNT; glyph++) {
         uint8_t *tile = videoRAM + VIDEO_TILE_BASE + glyph * VIDEO_TILE_BYTES;
         for (int y = 0; y < CONSOLE_FONT_BYTES; y++) {
@@ -133,6 +137,9 @@ void videoLoadFont(void) {
             }
         }
     }
+}
+
+void videoLoadPalette(void) {
     uint8_t *palette = videoRAM + VIDEO_PALETTE_BASE;
     for (int bank = 0; bank < 8; bank++) {
         // Colour on black, and then the same colour as paper with black ink, sixteen banks
@@ -187,9 +194,11 @@ void videoReset(void) {
     frameWaiting = 0;
     frameInterrupts = 0;
     clearInterrupt(PORT_VIDEO);
-    // A machine wakes up able to show text. Everything here is ordinary video memory that a
-    // program may overwrite the moment it wants the screen for something else.
+    // A machine wakes up able to show text, and it does so by COPYING from the character
+    // generator into ordinary video memory - which a program may overwrite the moment it
+    // wants the screen for something else, and can ask back afterwards.
     videoLoadFont();
+    videoLoadPalette();
 }
 
 uint8_t *videoMemory(uint32_t *capacity) {
@@ -235,6 +244,25 @@ uint8_t videoWrite(uint8_t value, uint8_t port) {
         case VIDEO_FINE_Y:
             fineY = (uint8_t)(value & VIDEO_FINE_MASK);
         break;
+        case VIDEO_COMMAND:
+            // ---- Asking the character generator for its contents ----
+            //
+            // Written, and it happens at once - the same shape as the console's Command port
+            // and the controller's, rather than a bit in a register that otherwise holds
+            // state. There is nothing to read back: what a copy did is visible in the memory
+            // it copied into.
+            //
+            // IN BITMAP MODE THE TILES ARE THE PICTURE, so asking for the font there draws
+            // glyphs across the top of it. That is not a special case being ignored; it is
+            // what the memory means in that mode, and a caller that wants text has to be in
+            // a mode that has some.
+            if (value & VIDEO_COMMAND_FONT) {
+                videoLoadFont();
+            }
+            if (value & VIDEO_COMMAND_PALETTE) {
+                videoLoadPalette();
+            }
+        break;
         default:
             // Everything else is read only or not there yet. Writing does nothing rather
             // than refusing: a port block reserved for later should be quiet, not fatal.
@@ -272,6 +300,10 @@ uint8_t videoRead(uint8_t port) {
         case VIDEO_SCROLL_COLUMN: return scrollColumn;
         case VIDEO_FINE_X:  return fineX;
         case VIDEO_FINE_Y:  return fineY;
+        case VIDEO_COMMAND:
+            // Write only, like the console's. A device that does something when told does
+            // not take instructions and hand out state through the same hole.
+            return 0;
         // Asked rather than assumed. A program that wants to know how wide the screen is
         // should be able to find out, the same way it asks the console what mode it is in.
         case VIDEO_COLUMNS: return (uint8_t)columnsFor(mode);

Source/Emulator/video.h

@@ -124,6 +124,31 @@ int videoTextRows(void);
 #define VIDEO_FINE_X        0x37
 #define VIDEO_FINE_Y        0x38
 
+// ---- The character generator, which is a chip and not a memory that remembers ----
+//
+// The font and the sixteen colour schemes used to be WRITTEN INTO VIDEO RAM at reset, and
+// that was the one piece of magic left in this device: RAM does not wake up with anything
+// in it. It looked harmless until something needed the font BACK - a program that redefines
+// a tile has overwritten a glyph, and there was nowhere to get it from, because the only
+// copy was the one that had just been drawn over.
+//
+// So the device has a ROM, the way the machines this one is pretending to be really did,
+// and the copy into RAM is a thing it DOES rather than a state it mysteriously starts in.
+// Reset performs it, and a program can ask for it again.
+//
+// THE RAM IS STILL RAM. A program may overwrite every glyph and every colour, and should be
+// able to: that is what makes a tile engine a tile engine rather than a text display. What
+// has changed is that doing so is no longer a one way door.
+//
+// A SYSTEM THAT WANTS ITS OWN FONT still loads one over the top. This is the floor, not the
+// policy - it is what makes a machine with no disk able to say so, and what lets a program
+// with no system behind it put readable text on a screen.
+#define VIDEO_COMMAND         0x39
+// Copy the 135 glyphs back into the tiles they live in, leaving every other tile alone.
+#define VIDEO_COMMAND_FONT    0x01
+// Copy the sixteen ink and paper pairs back, leaving the rest of the palette alone.
+#define VIDEO_COMMAND_PALETTE 0x02
+
 // Eight pixels to a cell, so three bits say where inside one the view begins.
 #define VIDEO_FINE_MASK 0x07
 
@@ -163,7 +188,16 @@ void videoReset(void);
 //
 // The font is expanded into tile memory at reset rather than stored expanded: 1,088 bytes
 // of one-bit rows against 16 kilobytes of tiles.
+// Copies the character generator ROM into the tiles the console draws from, and the default
+// schemes into the palette entries they live in. Reset does both; the Command port is how a
+// program asks for either afterwards.
+//
+// NEITHER CLEARS WHAT IT DOES NOT OWN. The font writes glyphs 0 to 134 and stops, so a tile
+// a program defined above them survives; the palette writes the two entries of each of the
+// sixteen schemes and stops, so a program's own colours in between survive. Asking for the
+// font back should not cost a program the tile it was drawing with.
 void videoLoadFont(void);
+void videoLoadPalette(void);
 
 // ---- The cursor ----
 //