font: the console draws outlines now, and a byte could not have held Ą

"Ą Ę Ś Ł Ż" drew as "?????" and the obvious diagnosis -- the font has no
glyphs for them -- was wrong twice over. `struct vtcell.ch` was **one byte**
holding a CP437 index, and the console mapped UTF-8 down to it on the way in.
U+0104 does not fit in a byte. No font could have fixed that; the cell had to
get wider first.

So: `ch` is a uint32 codepoint, the mapping on the way in is gone, and the cell
draws through kernel/dev/ttf.c against JetBrains Mono linked into the image.
Cell size comes from the font's measured advance instead of a hardcoded 8x16.
The grid costs 864 KB of BSS instead of 432 KB, which is the honest price of
holding a codepoint per cell for six terminals at 240x75.

The rasteriser needed three fixes before it could be trusted with this.

**21 KB of locals on a 4 KB kernel stack.** `ttf_render` held an outline (512
points as three arrays) and a raster (1024 edges) as automatics. KSTACKSIZE is
4096. They walked off the bottom of the stack into whatever was underneath,
which surfaced as user processes faulting on addresses they never touched and
then a panic inside freevm() on an overwritten page directory. Nothing pointed
anywhere near a font.

**And then again, recursively.** load_outline() held a 4736-byte outline as a
local *and recursed* for composite glyphs. Composite glyphs are exactly Ą, Ę,
Ś, Ł, Ż -- so the second crash arrived the moment the first fix let Unicode
reach the screen, looking like a fresh bug. Now a static outline per recursion
level with a depth cap of 4 (the font's deepest real nesting is 2), and the
leaf parse split into load_simple() so its 512-byte flag array is not
multiplied by the depth. Worst chain measured from the object file: ~2.3 KB.

Neither showed in tools/ttftest, which has an 8 MB stack. That is the standing
hazard of one source file built for host and kernel: the host is most forgiving
about exactly the resource the kernel is strictest about.

**Component transforms were being skipped**, on the stated theory that a wrong
transform is worse than none. It is not. `‘` in this font is the comma glyph
with a scale of -1 -- a 180-degree rotation -- and the offset that ships with
it only lands correctly after the rotation. Without it the mark went twelve
pixels into a ten-pixel cell and was clipped away entirely, so the character
read as missing from the font rather than as misplaced. F2Dot14 2x2 now, with
SCALED_COMPONENT_OFFSET honoured.

The glyph cache was ASCII-only, so every accented letter re-rasterised on every
repaint: a screenful of Polish did hundreds of bezier flattenings per scroll
where the same screenful of English did none. 95 reserved ASCII slots plus 224
shared slots keyed by codepoint, 64 KB pool. Verified 13680 cached renders
byte-identical to direct ones across collisions and a pool flush.

tools/ttftest speaks UTF-8 now. Iterating bytes meant it could only ever ask
for ASCII, and ASCII is entirely simple glyphs -- it could not reach the code
path that mattered.

Also: resolvconf's success line moves behind /proc/bootmode, same rule as
vgpud. A quiet boot opened with "resolvconf: nameserver 10.0.2.3" where the
one line was supposed to be "Welcome to SchOS!". Failures stay loud.

Verified on screen, not just on the host: Ą Ę Ś Ł Ż ć ń ó ź, Ω λ π Œ Ð Æ ß,
∞ ‘x’ → ≤ all render, panic=0 across four boots.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

docs/architecture/terminals.md

@@ -45,23 +45,29 @@ switched away from mid-sequence comes back wrong.
 
 ## A cell
 
-Four bytes:
+Eight bytes:
 
 | | |
 |---|---|
-| `ch` | the glyph the font draws — **not** a codepoint |
+| `ch` | the Unicode codepoint, 32 bits |
 | `fg`, `bg` | palette indices, 0-15 ANSI plus two theme defaults |
 | `attr` | reverse video; room for underline and the rest |
+| `pad` | to eight, so the grid indexes without a multiply |
 
-`ch` stores the glyph rather than the codepoint because the console maps UTF-8
-to CP437 before it gets here, and that is what `include/font.h` contains.
-Storing the codepoint would mean re-running the mapping on every repaint and
-getting a different answer for anything the font cannot draw.
+`ch` was one byte holding a CP437 glyph, not a codepoint: the console mapped
+UTF-8 down to CP437 on the way in, because that is what `include/font.h`
+contained. Widening it to the codepoint is what made Ą, Ę, Ś, Ω and the rest
+possible, and no font change could have done it alone — a byte cannot *hold*
+U+0104 whatever is drawing it. Mapping on the way in also meant the decision
+was made once, at write time, and a later font could not revisit it.
 
-The colours are indices rather than RGB because a cell holding two 32-bit
-colours would be twelve bytes instead of four, and the grids are static: six
-terminals at 240x75 is 432 KB of BSS, paid once at link time rather than failed
-to pay at run time. There is no contiguous multi-page allocator to ask.
+The cost is real: the grid went from four bytes per cell to eight, and six
+terminals at 240x75 is 864 KB of BSS rather than 432 KB. Paid once at link
+time, which is the only way to pay it — there is no contiguous multi-page
+allocator to ask.
+
+The colours stay indices rather than RGB, for the same reason they always
+were: a cell holding two 32-bit colours would be sixteen bytes.
 
 ## What is per-terminal
 
@@ -316,5 +322,16 @@ waiting for a different editor.
 - **Only 240x75 of any screen.** Larger framebuffers work; the grid is clamped
   and the remainder stays background. Raising `VT_MAXCOLS`/`VT_MAXROWS` is the
   fix, and costs BSS.
-- **No UTF-8 the font lacks.** CP437 has ~256 glyphs. Anything else draws as
-  `?`, which is deliberate: drawing a *different* character would be worse.
+- **No UTF-8 the font lacks.** The console draws through the TrueType
+  rasteriser now, so the limit is the font's `cmap` rather than a 256-entry
+  table — Latin, Latin Extended, Greek, Cyrillic and the common punctuation and
+  maths symbols all render. Anything genuinely absent still draws as `?`, which
+  is deliberate: drawing a *different* character would be worse.
+- **No shaping, and no wide characters.** One codepoint is one cell of one
+  advance. Combining marks land on top of their own cell rather than the
+  preceding one, and CJK draws at half the width it wants. Both need a
+  width table and a cell that can span two columns.
+- **Typed input above U+07FF is unreliable.** Two-byte UTF-8 arrives intact;
+  three-byte sequences typed at the shell come through mangled. The console's
+  own decoder is not the problem — the same characters `cat`ed from a file
+  render correctly — so this belongs with keyboard and locale handling.