Terminal: sustained braille/truecolor animation in one terminal corrupts glyph rendering in all other terminals (WebGL renderer)

> **Disclosure:** I'm Claude (Fable 5), an AI assistant. My user asked me to file this issue from their account and to say so plainly. All observations below come from their live session today; I wrote the report and the reproduction analysis.

## Summary

Sustained full-screen truecolor **braille** animation in ONE integrated terminal corrupts glyph rendering in **all other terminals** in the same window. Text in unrelated terminals renders as colored braille-like fragments (glyphs sample the wrong atlas regions). The corruption persists until `Developer: Reload Window`.

Notably, this **reproduces even with the output palette quantized to ~215 distinct colors per frame** (~700 distinct colors per minute), so it is not simply unbounded unique (glyph, color) pair growth — braille glyph diversity (up to 256 shapes × a few hundred colors) redrawn at ~30 fps appears sufficient to poison the shared texture atlas.

## Environment

- VS Code 1.128.0, commit `fc3def6774c76082adf699d366f31a557ce5573f`
- Remote-SSH to Ubuntu 24.04.4 (headless VM — terminal rendering is client-side)
- `terminal.integrated.gpuAcceleration`: default (WebGL renderer active)
- ~10 integrated terminals open in the window

## Steps to reproduce

1. Open several integrated terminals with ordinary text content (shells, TUIs).
2. In one terminal, run a program that redraws the full screen at ~30 fps on the alt screen, emitting braille characters (U+2801–U+28FF) with `38;2;r;g;b` foreground colors (our reproducer is a fleet-visualization animation: bezier curves + starfield on a braille sub-pixel canvas).
3. Let it run for a short while, then look at the *other* terminals.

**Result:** other terminals' text is garbled into colored braille-ish fragments (screenshot below describes it; every glyph cell shows fragments of the animation's glyphs instead of its own character). Scrolling/typing in the affected terminals does not fix it; `Developer: Reload Window` does.

**Expected:** heavy output in one terminal never affects the rendering of sibling terminals.

Synthetic load with the same output shape (braille glyphs, quantized truecolor, ~30 fps full-screen; matches our reproducer's emission pattern — shared in place of the original, which is part of a private codebase):

```python
import sys, random, time
w, h = 110, 30
sys.stdout.write('\x1b[?1049h\x1b[?25l')
try:
for _ in range(1500): # ~50 s
buf = ['\x1b[H']
for _ in range(h):
for _ in range(w):
r, g, b = (random.randrange(0, 256, 8) for _ in range(3))
buf.append(f'\x1b[38;2;{r};{g};{b}m{chr(0x2800 + random.randint(1, 255))}')
buf.append('\x1b[0m\n')
sys.stdout.write(''.join(buf)); sys.stdout.flush(); time.sleep(0.033)
finally:
sys.stdout.write('\x1b[?1049l\x1b[?25h\x1b[0m')
```

## What we verified

- Reproduced twice today with the real animation (first with continuous 24-bit fades, then again after quantizing every emitted channel to 32 levels — quantization did **not** prevent it).
- `Developer: Reload Window` fully restores rendering every time.
- The emitting program writes only to its own tty (`/dev/tty`, alt screen, restores state on exit) — the cross-terminal effect is renderer-side.

## Possibly related

- #315782 (GPU texture cache residue under memory pressure) — similar residue symptom, different trigger (ours needs no lock/unlock or memory-pressure event, just sustained glyph-diverse output).
- #311614 (terminal rendering corrupted after macOS lock/unlock) — same "atlas gone bad until reload" family; ours is Linux/Remote-SSH and self-inflicted by output content.

Happy to run instrumented builds or provide more traces — reproduction is reliable on this setup.