Notebook Lm with 300 sources. I'm adding sources every time I make a new episode. The tech talk is getting denser too, which is what i want! 

PROMPT:

```
## 015: Text is Weird - Display, Input, and Rich Text
004: UI Rosetta Stone 04: 
• Display Text vs Editable Text Primitives
• The Label Mnemonic and Password Security
• Taming Rich Text: FlowDocuments, Decorators, and Markdown

# Summary
This is Episode 004 of the mini-series “UI Rosetta Stone”.
Focus: Text display + text input controls, and rich text across WPF/XAML (and Noesis), Unreal UMG, and React/web.
Audience: Senior UI engineers.
Episode length: 12–18 minutes spoken.

## Must cover:
This is the key information to be presented this episode, and MUST be covered!
- **Display vs Input (WPF/Noesis):** Contrast the lightweight `TextBlock` (which inherits from `FrameworkElement` and is highly performant) with the heavier `TextBox` (for user input and selection). Briefly cover the `Label` (`ContentControl`): explain that it exists specifically to handle access keys/mnemonics and link focus to an input `Target`, rather than just displaying static text.
- **Display vs Input (UMG):** Standard `TextBlock` for display. Contrast `EditableText` (the lightweight, raw text base) versus `EditableTextBox` (which adds a border, background styling, and interaction states like hover/focus). 
- **Display vs Input (Web/React):** The `` and `` elements, conceptually covering controlled components (React state drives value) versus uncontrolled components (DOM holds value).
- **Rich Text (WPF):** Explain the `RichTextBox` as a host for a `FlowDocument` (Paragraphs, Runs). Mention that it requires interacting with `TextRange` and `TextPointer` objects rather than simple string properties. 
- **Rich Text (UMG):** The `RichTextBlock` concept. Explain that it relies on a Data Table Asset (`RichTextStyleRow`) for styling and how it uses `URichTextBlockDecorator` classes to map markup tags (like ``) directly to custom Slate widgets.
- **Rich Text (Web):** HTML markup, Markdown rendering pipelines, and a brief nod to why `contentEditable` is a uniquely chaotic beast.
- **Password Input (brief):** The `PasswordBox` concept. Explain the security/UX gotchas (e.g., in WPF, `PasswordBox` is a sealed, separate control rather than just a TextBox property to prevent memory interception and UI tree snooping).
- **Debugging text issues:** Binding vs state bugs, layout clipping vs font fallback, and practical approaches per stack.
- **Best Practices vs Traps:** 
- *Trap:* Formatting text via property bindings that fire every single frame (specifically CPU-heavy in UMG; advocate for event-driven updates).
- *Trap:* Mixing layout logic into text generation.
- *Trap:* Overusing rich text when a composed widget/component is better, or vice versa.

## Topics already covered:
This is information already covered in previous episodes or coming up in future episodes, and you cannot cover it again. For reference, I have provided the episodes where it was spoken of, and you may ask listeners to go back.
- 00: WPF Runtime and dispatcher
- 00: Unreal runtime and what slate is
- 00: Web runtime and browser DOM + Javascript engine + Node Server
- 00: Dev environments, Visual studio vs unreal vs visual studio code
- 00: Source control, Git, perforce etc…
- 01: Definition of a control, user control, component etc…
- 01: Button element\control and Textbox\label controls
- 01: MVVM and importance of separation of concerns
- 02: Layout controls that are not "panels" including overlay, canvas
- 012: One-Dimensional vs Two-Dimensional Layouts (StackPanels, Flexbox, Grids)
- 012: Fluid Design and Responsive Spaces
- 012: Pixel Density, DPI Scaling, and Screen Adaptation
- 013: Non-stacking layout primitives: overlays/layers, canvas/absolute positioning, and decorator-style wrappers.

## Output format:
Generate the podcast script using the following exact structure:
1) Title
2) Episode description (podcast listing)
3) Segment outline + timestamps
4) Script (no code)
5) Crosswalk table: display text vs editable text vs rich text (per stack)
6) “Do / Don’t” list (max 12 bullets)

Rules:
- Keep it pragmatic: focus on decision-making and maintainability.
- Keep it controls-level, not engine internals.
- Don’t deep dive into IME internals, but acknowledge it exists and affects control choice.
- Keep examples conceptual.

```

This episode includes AI-generated content.