prezo 0.3.2__tar.gz → 2026.1.2__tar.gz

{prezo-0.3.2 → prezo-2026.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: prezo
-Version: 0.3.2
+Version: 2026.1.2
 Summary: A TUI-based presentation tool for the terminal, built with Textual.
 Author: Stefane Fermigier
 Author-email: Stefane Fermigier <sf@fermigier.com>
@@ -16,9 +16,10 @@ A TUI-based presentation tool for the terminal, built with [Textual](https://tex
 
 Display presentations written in Markdown using conventions similar to those of [MARP](https://marp.app/) or [Deckset](https://www.deckset.com/).
 
-## Features (v0.3)
+## Features
 
 - **Markdown presentations** - MARP/Deckset format with `---` slide separators
+- **Column layouts** - Pandoc-style fenced divs for multi-column slides (`::: columns`)
 - **Live reload** - Auto-refresh when file changes (1s polling)
 - **Keyboard navigation** - Vim-style keys, arrow keys, and more
 - **Slide overview** - Grid view for quick navigation (`o`)
@@ -130,11 +131,33 @@ Presenter notes go here (after ???)
 
 # Third Slide
 
+::: columns
+::: column
+**Left Column**
+- Point A
+- Point B
+:::
+
+::: column
+**Right Column**
+- Point C
+- Point D
+:::
+:::
+
+---
+
+# Fourth Slide
+
 <!-- notes: Alternative notes syntax -->
 
-More content...
+::: center
+**Centered content**
+:::
 ```
 
+See the [Writing Presentations in Markdown](docs/tutorial.md) tutorial for a complete guide on creating presentations, including column layouts, images, presenter notes, and configuration directives.
+
 ## Themes
 
 Available themes: `dark`, `light`, `dracula`, `solarized-dark`, `nord`, `gruvbox`

{prezo-0.3.2 → prezo-2026.1.2}/README.md

@@ -4,9 +4,10 @@ A TUI-based presentation tool for the terminal, built with [Textual](https://tex
 
 Display presentations written in Markdown using conventions similar to those of [MARP](https://marp.app/) or [Deckset](https://www.deckset.com/).
 
-## Features (v0.3)
+## Features
 
 - **Markdown presentations** - MARP/Deckset format with `---` slide separators
+- **Column layouts** - Pandoc-style fenced divs for multi-column slides (`::: columns`)
 - **Live reload** - Auto-refresh when file changes (1s polling)
 - **Keyboard navigation** - Vim-style keys, arrow keys, and more
 - **Slide overview** - Grid view for quick navigation (`o`)
@@ -118,11 +119,33 @@ Presenter notes go here (after ???)
 
 # Third Slide
 
+::: columns
+::: column
+**Left Column**
+- Point A
+- Point B
+:::
+
+::: column
+**Right Column**
+- Point C
+- Point D
+:::
+:::
+
+---
+
+# Fourth Slide
+
 <!-- notes: Alternative notes syntax -->
 
-More content...
+::: center
+**Centered content**
+:::
 ```
 
+See the [Writing Presentations in Markdown](docs/tutorial.md) tutorial for a complete guide on creating presentations, including column layouts, images, presenter notes, and configuration directives.
+
 ## Themes
 
 Available themes: `dark`, `light`, `dracula`, `solarized-dark`, `nord`, `gruvbox`

{prezo-0.3.2 → prezo-2026.1.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "prezo"
-version = "0.3.2"
+version = "2026.1.2"
 description = "A TUI-based presentation tool for the terminal, built with Textual."
 readme = "README.md"
 authors = [
@@ -36,6 +36,12 @@ export = [
 testpaths = ["tests"]
 asyncio_mode = "auto"
 asyncio_default_fixture_loop_scope = "function"
+markers = [
+    "unit: Unit tests (fast, isolated, no I/O)",
+    "integration: Integration tests (component interactions, file I/O)",
+    "e2e: End-to-end tests (full app/CLI workflows)",
+    "slow: Slow tests that can be skipped with -m 'not slow'",
+]
 
 [build-system]
 requires = ["uv_build>=0.8.4,<0.9.0"]
@@ -46,7 +52,7 @@ build-backend = "uv_build"
 missing-source-for-stubs = false  # markdown stubs bundled but source not found
 missing-import = false  # libsixel optional dependency
 missing-attribute = false  # PIL.Image.ADAPTIVE
-no-matching-overload = false  # PIL getdata() type issues
+no-matching-overload = false  # PIL type stub issues
 bad-argument-type = false  # LiteralString strictness with string append
 bad-override = false  # Textual COMMANDS type override
 

{prezo-0.3.2 → prezo-2026.1.2}/src/prezo/app.py

@@ -39,7 +39,7 @@ from .screens import (
 )
 from .terminal import ImageCapability, detect_image_capability
 from .themes import get_next_theme, get_theme
-from .widgets import ImageDisplay, StatusBar
+from .widgets import ImageDisplay, SlideContent, StatusBar
 
 WELCOME_MESSAGE = """\
 # Welcome to Prezo
@@ -242,12 +242,12 @@ class PrezoApp(App):
     #slide-container {
         width: 1fr;
         height: 100%;
-        padding: 1 4;
+        padding: 0 4 1 4;
     }
 
     #slide-content {
         width: 100%;
-        padding: 1 2;
+        padding: 0 2;
     }
 
     /* Image container - hidden by default */
@@ -389,7 +389,7 @@ class PrezoApp(App):
                             yield ImageDisplay(id="slide-image")
                         # Text container
                         with VerticalScroll(id="slide-container"):
-                            yield Markdown("", id="slide-content")
+                            yield SlideContent("", id="slide-content")
                 with Vertical(id="notes-panel"):
                     yield Static("Notes", id="notes-title")
                     yield Markdown("", id="notes-content")
@@ -519,7 +519,7 @@ class PrezoApp(App):
         recent_section = _format_recent_files(self.state.recent_files)
         if recent_section:
             welcome += recent_section
-        self.query_one("#slide-content", Markdown).update(welcome)
+        self.query_one("#slide-content", SlideContent).set_content(welcome)
         status = self.query_one("#status-bar", StatusBar)
         status.current = 0
         status.total = 1
@@ -591,7 +591,9 @@ class PrezoApp(App):
                 image_widget.clear()
 
         # Use cleaned content (bg images already removed by parser)
-        self.query_one("#slide-content", Markdown).update(slide.content.strip())
+        self.query_one("#slide-content", SlideContent).set_content(
+            slide.content.strip()
+        )
 
         container = self.query_one("#slide-container", VerticalScroll)
         container.scroll_home(animate=False)

{prezo-0.3.2 → prezo-2026.1.2}/src/prezo/export.py

@@ -16,7 +16,8 @@ from rich.panel import Panel
 from rich.style import Style
 from rich.text import Text
 
-from .parser import parse_presentation
+from .layout import has_layout_blocks, parse_layout, render_layout
+from .parser import clean_marp_directives, extract_notes, parse_presentation
 from .themes import get_theme
 
 # Export result types
@@ -48,7 +49,7 @@ SVG_FORMAT_NO_CHROME = """\
     }}
 
     .{unique_id}-matrix {{
-        font-family: Fira Code, monospace;
+        font-family: Fira Code, "Apple Color Emoji", "Segoe UI Emoji", "Noto Color Emoji", monospace;
         font-size: {char_height}px;
         line-height: {line_height}px;
         font-variant-east-asian: full-width;
@@ -113,13 +114,17 @@ def render_slide_to_svg(
     # Base style for the entire slide (background color)
     base_style = Style(color=theme.text, bgcolor=theme.background)
 
-    # Render the markdown content
-    md = Markdown(content)
+    # Render the content (with layout support)
+    if has_layout_blocks(content):
+        blocks = parse_layout(content)
+        slide_content = render_layout(blocks)
+    else:
+        slide_content = Markdown(content)
 
     # Create a panel with the slide content (height - 2 for status bar and padding)
     panel_height = height - 2
     panel = Panel(
-        md,
+        slide_content,
         title=f"[{theme.text_muted}]Slide {slide_num + 1}/{total_slides}[/]",
         title_align="right",
         border_style=Style(color=theme.primary),
@@ -149,6 +154,13 @@ def render_slide_to_svg(
     else:
         svg = console.export_svg(code_format=SVG_FORMAT_NO_CHROME)
 
+    # Add emoji font fallbacks to font-family declarations
+    # Rich only specifies "Fira Code, monospace" which lacks emoji glyphs
+    svg = svg.replace(
+        "font-family: Fira Code, monospace",
+        'font-family: Fira Code, "Apple Color Emoji", "Segoe UI Emoji", "Noto Color Emoji", monospace',
+    )
+
     # Add background color to SVG (Rich doesn't set it by default)
     # Insert a rect element right after the opening svg tag
     bg_rect = f'<rect width="100%" height="100%" fill="{theme.background}"/>'
@@ -386,6 +398,16 @@ HTML_TEMPLATE = """\
             max-width: 100%;
             height: auto;
         }}
+        /* Multi-column layouts */
+        .columns {{
+            display: flex;
+            gap: 2rem;
+            align-items: flex-start;
+        }}
+        .columns > div {{
+            flex: 1;
+            min-width: 0;
+        }}
         .notes {{
             margin-top: 2rem;
             padding: 1rem;
@@ -500,7 +522,10 @@ def export_to_html(
     # Render each slide
     slides_html = []
     for i, slide in enumerate(presentation.slides):
-        content_html = render_slide_to_html(slide.content)
+        # Use raw_content and clean with keep_divs=True to preserve column layouts
+        slide_content, _ = extract_notes(slide.raw_content)
+        cleaned_content = clean_marp_directives(slide_content, keep_divs=True)
+        content_html = render_slide_to_html(cleaned_content)
 
         # Handle notes
         notes_html = ""

{prezo-0.3.2 → prezo-2026.1.2}/src/prezo/images/ascii.py

@@ -4,6 +4,7 @@ from __future__ import annotations
 
 from functools import lru_cache
 from pathlib import Path
+from typing import cast
 
 # ASCII characters from dark to light
 ASCII_CHARS = " .:-=+*#%@"
@@ -68,8 +69,8 @@ class AsciiRenderer:
         # Resize
         img = img.resize((new_width, new_height))
 
-        # Convert to ASCII
-        pixels = list(img.getdata())
+        # Convert to ASCII (grayscale values 0-255)
+        pixels = cast("list[int]", list(img.get_flattened_data()))
         lines = []
 
         for y in range(new_height):
@@ -127,8 +128,8 @@ class ColorAsciiRenderer(AsciiRenderer):
         # Resize
         img = img.resize((new_width, new_height))
 
-        # Convert to colored ASCII
-        pixels = list(img.getdata())
+        # Convert to colored ASCII (RGB tuples)
+        pixels = cast("list[tuple[int, int, int]]", list(img.get_flattened_data()))
         lines = []
 
         for y in range(new_height):
@@ -190,7 +191,8 @@ class HalfBlockRenderer:
         new_height = new_height - (new_height % 2)
 
         img = img.resize((new_width, new_height))
-        pixels = list(img.getdata())
+        # RGB tuples for half-block rendering
+        pixels = cast("list[tuple[int, int, int]]", list(img.get_flattened_data()))
 
         lines = []
         for y in range(0, new_height, 2):

{prezo-0.3.2 → prezo-2026.1.2}/src/prezo/images/sixel.py

@@ -2,7 +2,7 @@
 
 from __future__ import annotations
 
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, cast
 
 if TYPE_CHECKING:
     from pathlib import Path
@@ -108,12 +108,12 @@ class SixelRenderer:
 
         img = img.resize((pixel_width, pixel_height))
 
-        # Get palette
+        # Get palette and pixel data (palette indices 0-255)
         palette = img.getpalette()
-        pixels = list(img.getdata())
+        pixels = cast("list[int]", list(img.get_flattened_data()))
 
         # Build sixel output
-        output = []
+        output: list[str] = []
 
         # Start sixel sequence
         output.append("\x1bPq")

prezo-2026.1.2/src/prezo/layout.py

@@ -0,0 +1,464 @@
+"""Layout parsing and rendering for multi-column slides.
+
+Supports Pandoc-style fenced div syntax:
+
+    ::: columns
+    ::: column
+    Left content
+    :::
+    ::: column
+    Right content
+    :::
+    :::
+
+"""
+
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass, field
+from io import StringIO
+from typing import TYPE_CHECKING, Literal
+
+from rich.console import Console, ConsoleOptions, Group, RenderResult
+from rich.markdown import Markdown
+from rich.measure import Measurement
+from rich.text import Text
+
+if TYPE_CHECKING:
+    from rich.console import RenderableType
+
+# -----------------------------------------------------------------------------
+# Data Types
+# -----------------------------------------------------------------------------
+
+
+@dataclass
+class LayoutBlock:
+    """A block of content with layout information."""
+
+    type: Literal["plain", "columns", "column", "center"]
+    content: str = ""  # Raw markdown content (for leaf blocks)
+    children: list[LayoutBlock] = field(default_factory=list)
+    width_percent: int = 0  # For column blocks (0 = auto/equal)
+
+
+# -----------------------------------------------------------------------------
+# Parser
+# -----------------------------------------------------------------------------
+
+# Pattern for opening fenced div: ::: type [width]
+OPEN_PATTERN = re.compile(r"^:::\s*(\w+)(?:\s+(\d+))?\s*$")
+# Pattern for closing fenced div: :::
+CLOSE_PATTERN = re.compile(r"^:::\s*$")
+
+
+def parse_layout(content: str) -> list[LayoutBlock]:
+    """Parse markdown content into layout blocks.
+
+    Detects Pandoc-style fenced divs and builds a tree of LayoutBlocks.
+    Content outside fenced divs becomes plain blocks.
+
+    Args:
+        content: Markdown content possibly containing fenced divs.
+
+    Returns:
+        List of LayoutBlock objects representing the content structure.
+
+    """
+    lines = content.split("\n")
+    blocks: list[LayoutBlock] = []
+    i = 0
+
+    while i < len(lines):
+        line = lines[i]
+        match = OPEN_PATTERN.match(line)
+
+        if match:
+            block_type = match.group(1).lower()
+            width = int(match.group(2)) if match.group(2) else 0
+
+            # Find matching close and nested content
+            block, end_idx = _parse_fenced_block(lines, i, block_type, width)
+            if block:
+                blocks.append(block)
+                i = end_idx + 1
+                continue
+            # Unclosed block - treat as plain text, skip the opening line
+            i += 1
+            continue
+
+        # Not a fenced div - accumulate plain content
+        plain_lines = []
+        while i < len(lines):
+            if OPEN_PATTERN.match(lines[i]):
+                break
+            plain_lines.append(lines[i])
+            i += 1
+
+        if plain_lines:
+            plain_content = "\n".join(plain_lines).strip()
+            if plain_content:
+                blocks.append(LayoutBlock(type="plain", content=plain_content))
+
+    return blocks
+
+
+def _parse_fenced_block(
+    lines: list[str], start: int, block_type: str, width: int
+) -> tuple[LayoutBlock | None, int]:
+    """Parse a fenced div block starting at the given line.
+
+    Args:
+        lines: All lines of content.
+        start: Starting line index (the opening :::).
+        block_type: The type from ::: type.
+        width: Width percentage if specified.
+
+    Returns:
+        Tuple of (LayoutBlock or None, end line index).
+
+    """
+    depth = 1
+    i = start + 1
+    content_lines: list[str] = []
+
+    while i < len(lines) and depth > 0:
+        line = lines[i]
+
+        if CLOSE_PATTERN.match(line):
+            depth -= 1
+            if depth == 0:
+                break
+            content_lines.append(line)
+        elif OPEN_PATTERN.match(line):
+            depth += 1
+            content_lines.append(line)
+        else:
+            content_lines.append(line)
+        i += 1
+
+    if depth != 0:
+        # Unclosed block - treat as plain text
+        return None, start
+
+    inner_content = "\n".join(content_lines)
+
+    # For columns/column types, parse children
+    if block_type in ("columns", "column", "center"):
+        block = LayoutBlock(
+            type=block_type,  # type: ignore[arg-type]
+            width_percent=width,
+        )
+
+        if block_type == "columns":
+            # Parse children (should be column blocks)
+            block.children = parse_layout(inner_content)
+        elif block_type == "column":
+            # Column contains markdown content, but might have nested structure
+            # For now, treat as plain content
+            block.content = inner_content.strip()
+        elif block_type == "center":
+            block.content = inner_content.strip()
+
+        return block, i
+
+    # Unknown block type - treat content as plain
+    return LayoutBlock(type="plain", content=inner_content.strip()), i
+
+
+def has_layout_blocks(content: str) -> bool:
+    """Check if content contains any layout directives.
+
+    Quick check to avoid parsing overhead for simple slides.
+
+    Args:
+        content: Markdown content to check.
+
+    Returns:
+        True if content contains ::: directives.
+
+    """
+    return ":::" in content
+
+
+# -----------------------------------------------------------------------------
+# Renderer
+# -----------------------------------------------------------------------------
+
+
+class ColumnsRenderable:
+    """Rich renderable that displays columns side-by-side."""
+
+    def __init__(
+        self,
+        columns: list[LayoutBlock],
+        gap: int = 2,
+    ) -> None:
+        """Initialize columns renderable.
+
+        Args:
+            columns: List of column LayoutBlocks.
+            gap: Number of spaces between columns.
+
+        """
+        self.columns = columns
+        self.gap = gap
+
+    def __rich_console__(
+        self, console: Console, options: ConsoleOptions
+    ) -> RenderResult:
+        """Render columns side-by-side."""
+        if not self.columns:
+            return
+
+        # Blank line before columns
+        yield Text("")
+
+        max_width = options.max_width
+        num_cols = len(self.columns)
+
+        # Calculate column widths
+        widths = self._calculate_widths(max_width, num_cols)
+
+        # Render each column to lines
+        column_outputs: list[list[str]] = []
+        for col, width in zip(self.columns, widths, strict=False):
+            lines = self._render_column(col, width, console)
+            column_outputs.append(lines)
+
+        # Merge columns side-by-side
+        merged = self._merge_columns(column_outputs, widths)
+
+        for line in merged:
+            yield Text.from_ansi(line)
+
+        # Blank line after columns
+        yield Text("")
+
+    def _calculate_widths(self, total_width: int, num_cols: int) -> list[int]:
+        """Calculate width for each column.
+
+        Args:
+            total_width: Total available width.
+            num_cols: Number of columns.
+
+        Returns:
+            List of widths for each column.
+
+        """
+        # Account for gaps between columns
+        total_gap = self.gap * (num_cols - 1)
+        available = total_width - total_gap
+
+        # Check if any columns have explicit widths
+        explicit_widths = [c.width_percent for c in self.columns]
+        total_explicit = sum(w for w in explicit_widths if w > 0)
+
+        if total_explicit > 0:
+            # Use explicit percentages
+            widths = []
+            remaining = available
+            auto_count = sum(1 for w in explicit_widths if w == 0)
+
+            for w in explicit_widths:
+                if w > 0:
+                    col_width = max(1, (available * w) // 100)
+                    widths.append(col_width)
+                    remaining -= col_width
+                else:
+                    widths.append(0)  # Placeholder
+
+            # Distribute remaining to auto columns
+            if auto_count > 0:
+                auto_width = remaining // auto_count
+                widths = [w if w > 0 else auto_width for w in widths]
+        else:
+            # Equal distribution
+            col_width = available // num_cols
+            widths = [col_width] * num_cols
+
+        return widths
+
+    def _render_column(
+        self, column: LayoutBlock, width: int, console: Console
+    ) -> list[str]:
+        """Render a single column to a list of lines.
+
+        Args:
+            column: The column LayoutBlock.
+            width: Width in characters.
+            console: Rich console for rendering.
+
+        Returns:
+            List of rendered lines (with ANSI codes).
+
+        """
+        # Create a console with fixed width for rendering
+        col_console = Console(
+            width=width,
+            force_terminal=True,
+            color_system=console.color_system,
+            record=True,
+            file=StringIO(),
+        )
+
+        # Render markdown content
+        if column.content:
+            md = Markdown(column.content)
+            col_console.print(md)
+
+        # Get rendered lines
+        output = col_console.export_text(styles=True)
+        lines = output.split("\n")
+
+        # Ensure each line is padded to column width
+        # Note: This is tricky with ANSI codes. For now, we'll do basic padding.
+        padded = []
+        for line in lines:
+            # Strip trailing whitespace but preserve ANSI
+            stripped = line.rstrip()
+            padded.append(stripped)
+
+        return padded
+
+    def _merge_columns(
+        self, column_outputs: list[list[str]], widths: list[int]
+    ) -> list[str]:
+        """Merge column outputs side-by-side.
+
+        Args:
+            column_outputs: List of line lists for each column.
+            widths: Width of each column.
+
+        Returns:
+            Merged lines.
+
+        """
+        if not column_outputs:
+            return []
+
+        # Find max height
+        max_height = max(len(col) for col in column_outputs)
+
+        # Pad shorter columns
+        for col in column_outputs:
+            while len(col) < max_height:
+                col.append("")
+
+        # Merge line by line
+        result = []
+        gap_str = " " * self.gap
+
+        for row_idx in range(max_height):
+            parts = []
+            for col_idx, col in enumerate(column_outputs):
+                line = col[row_idx] if row_idx < len(col) else ""
+                # Pad to column width (accounting for ANSI codes)
+                visible_len = _visible_length(line)
+                padding = widths[col_idx] - visible_len
+                if padding > 0:
+                    line = line + " " * padding
+                parts.append(line)
+
+            result.append(gap_str.join(parts))
+
+        return result
+
+    def __rich_measure__(
+        self, console: Console, options: ConsoleOptions
+    ) -> Measurement:
+        """Return the measurement of this renderable."""
+        return Measurement(1, options.max_width)
+
+
+class CenterRenderable:
+    """Rich renderable that centers content horizontally."""
+
+    def __init__(self, content: str) -> None:
+        """Initialize center renderable.
+
+        Args:
+            content: Markdown content to center.
+
+        """
+        self.content = content
+
+    def __rich_console__(
+        self, console: Console, options: ConsoleOptions
+    ) -> RenderResult:
+        """Render centered content."""
+        # Blank line before centered content
+        yield Text("")
+
+        # Use Markdown with center justification
+        md = Markdown(self.content, justify="center")
+        yield md
+
+        # Blank line after centered content
+        yield Text("")
+
+    def __rich_measure__(
+        self, console: Console, options: ConsoleOptions
+    ) -> Measurement:
+        """Return the measurement of this renderable."""
+        return Measurement(1, options.max_width)
+
+
+def render_layout(
+    blocks: list[LayoutBlock],
+) -> RenderableType:
+    """Render layout blocks to a Rich renderable.
+
+    Args:
+        blocks: List of LayoutBlocks from parse_layout().
+
+    Returns:
+        Rich renderable representing the layout.
+
+    """
+    renderables: list[RenderableType] = []
+
+    for block in blocks:
+        match block.type:
+            case "plain":
+                renderables.append(Markdown(block.content))
+            case "columns":
+                # Filter to only column children
+                columns = [c for c in block.children if c.type == "column"]
+                if columns:
+                    renderables.append(ColumnsRenderable(columns))
+                # Also render any non-column children (plain text between columns)
+                for child in block.children:
+                    if child.type == "plain":
+                        renderables.append(Markdown(child.content))
+            case "center":
+                renderables.append(CenterRenderable(block.content))
+            case "column":
+                # Standalone column (shouldn't happen normally)
+                renderables.append(Markdown(block.content))
+
+    if len(renderables) == 1:
+        return renderables[0]
+    return Group(*renderables)
+
+
+# -----------------------------------------------------------------------------
+# Utilities
+# -----------------------------------------------------------------------------
+
+# ANSI escape sequence pattern
+_ANSI_PATTERN = re.compile(r"\x1b\[[0-9;]*m")
+
+
+def _visible_length(text: str) -> int:
+    """Calculate visible length of text, excluding ANSI codes.
+
+    Args:
+        text: Text possibly containing ANSI escape codes.
+
+    Returns:
+        Visible character count.
+
+    """
+    return len(_ANSI_PATTERN.sub("", text))

{prezo-0.3.2 → prezo-2026.1.2}/src/prezo/parser.py

@@ -346,13 +346,19 @@ def _parse_marp_image_directive(alt_text: str) -> _ImageDirectives:
     return result
 
 
-def clean_marp_directives(content: str) -> str:
+def clean_marp_directives(content: str, *, keep_divs: bool = False) -> str:
     """Remove MARP-specific directives that don't render in TUI.
 
     Cleans up:
     - MARP HTML comments (<!-- _class: ... -->, <!-- _header: ... -->, etc.)
     - MARP image directives (![bg ...])
     - Empty HTML divs with only styling
+    - All HTML divs (unless keep_divs=True for HTML export)
+
+    Args:
+        content: Slide content to clean.
+        keep_divs: If True, preserve structural divs (for HTML export).
+
     """
     # Remove MARP directive comments
     content = re.sub(r"<!--\s*_\w+:.*?-->\s*\n?", "", content)
@@ -363,9 +369,10 @@ def clean_marp_directives(content: str) -> str:
     # Remove empty divs with only style attributes
     content = re.sub(r'<div[^>]*style="[^"]*"[^>]*>\s*</div>\s*\n?', "", content)
 
-    # Remove inline HTML divs (keep the content)
-    content = re.sub(r"<div[^>]*>\s*\n?", "", content)
-    content = re.sub(r"\s*</div>", "", content)
+    if not keep_divs:
+        # Remove inline HTML divs (keep the content) - for TUI display
+        content = re.sub(r"<div[^>]*>\s*\n?", "", content)
+        content = re.sub(r"\s*</div>", "", content)
 
     # Clean up multiple blank lines
     return re.sub(r"\n{3,}", "\n\n", content)

{prezo-0.3.2 → prezo-2026.1.2}/src/prezo/widgets/__init__.py

@@ -4,6 +4,14 @@ from __future__ import annotations
 
 from .image_display import ImageDisplay
 from .slide_button import SlideButton
+from .slide_content import SlideContent
 from .status_bar import ClockDisplay, ProgressBar, StatusBar
 
-__all__ = ["ClockDisplay", "ImageDisplay", "ProgressBar", "SlideButton", "StatusBar"]
+__all__ = [
+    "ClockDisplay",
+    "ImageDisplay",
+    "ProgressBar",
+    "SlideButton",
+    "SlideContent",
+    "StatusBar",
+]

prezo-2026.1.2/src/prezo/widgets/slide_content.py

@@ -0,0 +1,81 @@
+"""Slide content widget with layout support."""
+
+from __future__ import annotations
+
+from rich.markdown import Markdown as RichMarkdown
+from textual.widgets import Static
+
+from prezo.layout import has_layout_blocks, parse_layout, render_layout
+
+
+class SlideContent(Static):
+    """Widget that renders slide content with optional layout support.
+
+    Handles both plain markdown and Pandoc-style fenced div layouts:
+    - Plain markdown is rendered using Rich's Markdown
+    - Layout blocks (columns, center) are rendered using the layout module
+
+    Inherits from Static to properly handle Rich renderable display.
+    """
+
+    DEFAULT_CSS = """
+    SlideContent {
+        width: 100%;
+        height: auto;
+    }
+    """
+
+    def __init__(
+        self,
+        content: str = "",
+        *,
+        name: str | None = None,
+        id: str | None = None,
+        classes: str | None = None,
+    ) -> None:
+        """Initialize the slide content widget.
+
+        Args:
+            content: Markdown content to display.
+            name: Widget name.
+            id: Widget ID.
+            classes: CSS classes.
+
+        """
+        # Initialize Static with the rendered content
+        super().__init__("", name=name, id=id, classes=classes)
+        self._raw_content = content
+        if content:
+            self._update_renderable()
+
+    @property
+    def raw_content(self) -> str:
+        """Get the current raw markdown content."""
+        return self._raw_content
+
+    def set_content(self, content: str) -> None:
+        """Set the markdown content and refresh the widget.
+
+        Args:
+            content: New markdown content to display.
+
+        """
+        self._raw_content = content
+        self._update_renderable()
+
+    def _update_renderable(self) -> None:
+        """Update the internal renderable based on content."""
+        if not self._raw_content:
+            super().update("")
+            return
+
+        # Check for layout directives
+        if has_layout_blocks(self._raw_content):
+            blocks = parse_layout(self._raw_content)
+            renderable = render_layout(blocks)
+        else:
+            # Plain markdown
+            renderable = RichMarkdown(self._raw_content)
+
+        # Use Static's update to set the renderable
+        super().update(renderable)