prezo 2026.1.3__py3-none-any.whl → 2026.2.1__py3-none-any.whl

prezo/__init__.py

@@ -78,6 +78,16 @@ def _validate_file(path: Path, must_exist: bool = True) -> Path:
     return resolved
 
 
+def _get_version() -> str:
+    """Get the package version from metadata."""
+    from importlib.metadata import version  # noqa: PLC0415
+
+    try:
+        return version("prezo")
+    except Exception:
+        return "unknown"
+
+
 def main() -> None:
     """Entry point for Prezo."""
     parser = argparse.ArgumentParser(
@@ -85,6 +95,12 @@ def main() -> None:
         description="TUI-based presentation tool for Markdown slides",
         epilog="For more information, visit: https://github.com/abilian/prezo",
     )
+    parser.add_argument(
+        "-v",
+        "--version",
+        action="version",
+        version=f"%(prog)s {_get_version()}",
+    )
     parser.add_argument(
         "file",
         nargs="?",
@@ -159,6 +175,18 @@ def main() -> None:
         choices=["auto", "kitty", "sixel", "iterm", "ascii", "none"],
         help="Image rendering mode (auto, kitty, sixel, iterm, ascii, none)",
     )
+    parser.add_argument(
+        "-I",
+        "--incremental",
+        action="store_true",
+        help="Display lists incrementally, one item at a time (like Pandoc)",
+    )
+    parser.add_argument(
+        "--time-budget",
+        metavar="MINUTES",
+        type=int,
+        help="Time budget in minutes for pacing indicator (shows if ahead/behind)",
+    )
 
     args = parser.parse_args()
 
@@ -236,4 +264,10 @@ def main() -> None:
         if args.file:
             file_path = _validate_file(Path(args.file))
 
-        run_app(file_path, watch=not args.no_watch, config=config)
+        run_app(
+            file_path,
+            watch=not args.no_watch,
+            config=config,
+            incremental=args.incremental,
+            time_budget=args.time_budget,
+        )

prezo/app.py

@@ -5,6 +5,7 @@ from __future__ import annotations
 import base64
 import contextlib
 import os
+import re
 import subprocess
 import sys
 import tempfile
@@ -66,6 +67,7 @@ prezo <presentation.md>
 | **t** | Table of contents |
 | **p** | Toggle notes |
 | **c** | Toggle clock |
+| **s** | Start/stop timer |
 | **b** | Blackout screen |
 | **e** | Edit current slide |
 | **r** | Reload file |
@@ -109,6 +111,121 @@ def _format_recent_files(recent_files: list[str], max_files: int = 5) -> str:
     return "\n".join(lines)
 
 
+# -----------------------------------------------------------------------------
+# Incremental List Helpers
+# -----------------------------------------------------------------------------
+
+# Pattern matching markdown list items (unordered and ordered)
+_LIST_ITEM_PATTERN = re.compile(r"^(\s*)([-*+]|\d+\.)\s+")
+
+# Pattern matching layout directive markers (:::)
+_LAYOUT_MARKER_PATTERN = re.compile(r"^\s*:::")
+
+
+def count_list_items(content: str) -> int:
+    """Count the number of top-level list items in markdown content.
+
+    Args:
+        content: Markdown content to analyze.
+
+    Returns:
+        Number of top-level list items found.
+
+    """
+    count = 0
+    for line in content.split("\n"):
+        match = _LIST_ITEM_PATTERN.match(line)
+        if match:
+            # Only count top-level items (no leading whitespace)
+            indent = match.group(1)
+            if not indent:
+                count += 1
+    return count
+
+
+# Braille Pattern Blank - invisible character with width, behaves like text for layout
+_INVISIBLE_CHAR = "\u2800"
+
+
+def _make_placeholder(text: str) -> str:
+    """Create an invisible placeholder that matches the visual width of text.
+
+    Uses Braille Pattern Blank characters which are invisible but have
+    width and wrap like normal text.
+    """
+    return _INVISIBLE_CHAR * len(text) if text else _INVISIBLE_CHAR
+
+
+def filter_list_items(content: str, max_items: int) -> str:
+    """Filter content to show only the first N list items.
+
+    Preserves layout directive markers (:::) and other structural elements.
+    Hidden items are replaced with placeholder text of the same length
+    to maintain visual height when text wraps.
+
+    Args:
+        content: Markdown content to filter.
+        max_items: Maximum number of top-level list items to show.
+
+    Returns:
+        Filtered content with only the first N list items visible.
+
+    """
+    if max_items < 0:
+        return content  # Show all
+
+    lines = content.split("\n")
+    result_lines = []
+    item_count = 0
+    in_hidden_item = False
+
+    for line in lines:
+        # Always preserve layout markers (:::)
+        if _LAYOUT_MARKER_PATTERN.match(line):
+            result_lines.append(line)
+            # Reset hidden state when entering/exiting a block
+            in_hidden_item = False
+            continue
+
+        match = _LIST_ITEM_PATTERN.match(line)
+
+        if match:
+            indent = match.group(1)  # Leading whitespace
+            marker = match.group(2)  # List marker (-, *, +, 1.)
+            text_start = match.end()
+            text = line[text_start:]  # The actual text content
+
+            if len(indent) == 0:
+                # Top-level item
+                item_count += 1
+                if item_count <= max_items:
+                    result_lines.append(line)
+                    in_hidden_item = False
+                else:
+                    # Replace with same-length placeholder
+                    placeholder = _make_placeholder(text)
+                    result_lines.append(f"{indent}{marker} {placeholder}")
+                    in_hidden_item = True
+            elif in_hidden_item:
+                # Nested item under hidden parent - also hide
+                placeholder = _make_placeholder(text)
+                result_lines.append(f"{indent}{marker} {placeholder}")
+            else:
+                # Nested item - show if parent is visible
+                result_lines.append(line)
+        elif in_hidden_item:
+            # Content continuation of hidden item - preserve length
+            stripped = line.lstrip()
+            leading = line[: len(line) - len(stripped)]
+            placeholder = _make_placeholder(stripped)
+            result_lines.append(f"{leading}{placeholder}")
+        else:
+            # Non-list line (could be continuation or other content)
+            result_lines.append(line)
+
+    return "\n".join(result_lines)
+
+
 class PrezoCommands(Provider):
     """Command provider for Prezo actions."""
 
@@ -142,6 +259,7 @@ class PrezoCommands(Provider):
                 ("Search Slides", "search", "Search slides by content (/)"),
                 ("Toggle Notes", "toggle_notes", "Show/hide presenter notes (p)"),
                 ("Toggle Clock", "toggle_clock", "Cycle clock display mode (c)"),
+                ("Start/Stop Timer", "toggle_timer", "Start or stop elapsed timer (S)"),
                 ("Help", "show_help", "Show keyboard shortcuts (?)"),
             ]
         )
@@ -330,6 +448,8 @@ class PrezoApp(App):
         Binding("t", "show_toc", "TOC", show=True),
         Binding("p", "toggle_notes", "Notes", show=True),
         Binding("c", "toggle_clock", "Clock", show=False),
+        Binding("s", "toggle_timer", "Timer", show=False),
+        Binding("S", "toggle_timer", "Timer", show=False),
         Binding("T", "cycle_theme", "Theme", show=False),
         Binding("b", "blackout", "Blackout", show=False),
         Binding("w", "whiteout", "Whiteout", show=False),
@@ -342,6 +462,7 @@ class PrezoApp(App):
     current_slide: reactive[int] = reactive(0)
     notes_visible: reactive[bool] = reactive(False)
     app_theme: reactive[str] = reactive("dark")
+    reveal_index: reactive[int] = reactive(-1)  # -1 = show all, 0+ = show up to index
 
     TITLE = "Prezo"
 
@@ -351,6 +472,8 @@ class PrezoApp(App):
         *,
         watch: bool | None = None,
         config: Config | None = None,
+        incremental: bool = False,
+        time_budget: int | None = None,
     ) -> None:
         """Initialize the Prezo application.
 
@@ -358,6 +481,8 @@ class PrezoApp(App):
             presentation_path: Path to the Markdown presentation file.
             watch: Whether to enable file watching for live reload.
             config: Optional config override. Uses global config if None.
+            incremental: Whether to display lists incrementally (-I flag).
+            time_budget: Time budget in minutes for pacing indicator.
 
         """
         super().__init__()
@@ -367,6 +492,12 @@ class PrezoApp(App):
         self.presentation_path = Path(presentation_path) if presentation_path else None
         self.presentation: Presentation | None = None
 
+        # Incremental lists: CLI flag overrides config
+        self.incremental_cli = incremental
+
+        # Time budget: CLI flag overrides config/presentation directives
+        self.time_budget_cli = time_budget
+
         # Use config for watch if not explicitly set
         if watch is None:
             self.watch_enabled = self.config.behavior.auto_reload
@@ -436,11 +567,20 @@ class PrezoApp(App):
             return
 
         old_slide = self.current_slide
+        old_reveal = self.reveal_index
         self.presentation = parse_presentation(self.presentation_path)
 
         if old_slide >= self.presentation.total_slides:
-            self.current_slide = max(0, self.presentation.total_slides - 1)
+            target_slide = max(0, self.presentation.total_slides - 1)
+            self._init_reveal_for_slide(target_slide, show_all=False)
+            self.current_slide = target_slide
         else:
+            # Preserve reveal position if still valid
+            list_count = self._get_list_count(old_slide)
+            if self._is_incremental_enabled(old_slide) and list_count > 0:
+                self.reveal_index = max(0, min(old_reveal, list_count - 1))
+            else:
+                self.reveal_index = -1
             self._update_display()
 
         self.notify("Presentation reloaded", timeout=2)
@@ -453,12 +593,16 @@ class PrezoApp(App):
         # Restore last position or start at 0
         abs_path = str(self.presentation_path.absolute())
         last_pos = self.state.get_position(abs_path)
-        if last_pos < self.presentation.total_slides:
-            self.current_slide = last_pos
+        target_slide = last_pos if last_pos < self.presentation.total_slides else 0
+
+        # Set the slide - the watcher will initialize reveal state
+        if self.current_slide == target_slide:
+            # Watcher won't fire, so initialize manually
+            self._init_reveal_for_slide(target_slide, show_all=False)
+            self._update_display()
         else:
-            self.current_slide = 0
+            self.current_slide = target_slide
 
-        self._update_display()
         self._update_progress_bar()
 
         if self.presentation.title:
@@ -479,6 +623,81 @@ class PrezoApp(App):
         self._apply_timer_config(status_bar)
         status_bar.reset_timer()
 
+    def _is_incremental_enabled(self, slide_index: int | None = None) -> bool:
+        """Check if incremental mode is enabled for a slide.
+
+        Priority: per-slide directive > CLI flag > config > presentation directive
+
+        Args:
+            slide_index: Slide index to check. Uses current_slide if None.
+
+        Returns:
+            True if incremental lists should be enabled.
+
+        """
+        if not self.presentation or not self.presentation.slides:
+            return False
+
+        idx = slide_index if slide_index is not None else self.current_slide
+        if idx < 0 or idx >= len(self.presentation.slides):
+            return False
+
+        slide = self.presentation.slides[idx]
+
+        # Per-slide directive takes highest priority
+        if slide.incremental is not None:
+            return slide.incremental
+
+        # CLI flag overrides config and presentation directives
+        if self.incremental_cli:
+            return True
+
+        # Presentation directive (from <!-- prezo --> block)
+        if self.presentation.directives.incremental_lists is not None:
+            return self.presentation.directives.incremental_lists
+
+        # Fall back to config
+        return self.config.behavior.incremental_lists
+
+    def _get_list_count(self, slide_index: int | None = None) -> int:
+        """Get the number of top-level list items in a slide.
+
+        Args:
+            slide_index: Slide index to check. Uses current_slide if None.
+
+        Returns:
+            Number of top-level list items.
+
+        """
+        if not self.presentation or not self.presentation.slides:
+            return 0
+
+        idx = slide_index if slide_index is not None else self.current_slide
+        if idx < 0 or idx >= len(self.presentation.slides):
+            return 0
+
+        slide = self.presentation.slides[idx]
+        return count_list_items(slide.content)
+
+    def _init_reveal_for_slide(
+        self, slide_index: int, *, show_all: bool = False
+    ) -> None:
+        """Initialize reveal state for a specific slide.
+
+        Args:
+            slide_index: The slide to initialize for.
+            show_all: If True, reveal all items. If False, start with first item.
+
+        """
+        if self._is_incremental_enabled(slide_index):
+            list_count = self._get_list_count(slide_index)
+            if list_count > 0:
+                self.reveal_index = (list_count - 1) if show_all else 0
+            else:
+                self.reveal_index = -1  # No list items, show all content
+        else:
+            self.reveal_index = -1  # Incremental disabled, show all
+
     def _apply_presentation_directives(self) -> None:
         """Apply presentation-specific directives on top of config."""
         if not self.presentation:
@@ -496,6 +715,7 @@ class PrezoApp(App):
         show_clock = self.config.timer.show_clock
         show_elapsed = self.config.timer.show_elapsed
         countdown = self.config.timer.countdown_minutes
+        time_budget = self.config.timer.time_budget_minutes
 
         # Override with presentation directives if specified
         if self.presentation:
@@ -506,12 +726,19 @@ class PrezoApp(App):
                 show_elapsed = directives.show_elapsed
             if directives.countdown_minutes is not None:
                 countdown = directives.countdown_minutes
+            if directives.time_budget_minutes is not None:
+                time_budget = directives.time_budget_minutes
+
+        # CLI flag takes highest priority for time budget
+        if self.time_budget_cli is not None:
+            time_budget = self.time_budget_cli
 
         # Apply to status bar
         status_bar.show_clock = show_clock
         status_bar.show_elapsed = show_elapsed
         status_bar.countdown_minutes = countdown
         status_bar.show_countdown = countdown > 0
+        status_bar.time_budget_minutes = time_budget
 
     def _show_welcome(self) -> None:
         """Show welcome message when no presentation is loaded."""
@@ -583,9 +810,13 @@ class PrezoApp(App):
                 image_widget.clear()
 
         # Use cleaned content (bg images already removed by parser)
-        self.query_one("#slide-content", SlideContent).set_content(
-            slide.content.strip()
-        )
+        content = slide.content.strip()
+
+        # Apply incremental filtering if enabled
+        if self._is_incremental_enabled() and self.reveal_index >= 0:
+            content = filter_list_items(content, self.reveal_index + 1)
+
+        self.query_one("#slide-content", SlideContent).set_content(content)
 
         container = self.query_one("#slide-container", VerticalScroll)
         container.scroll_home(animate=False)
@@ -594,7 +825,7 @@ class PrezoApp(App):
         self._update_notes()
 
     def _update_progress_bar(self) -> None:
-        """Update the progress bar."""
+        """Update the progress bar and reveal indicator."""
         if not self.presentation:
             return
 
@@ -602,6 +833,19 @@ class PrezoApp(App):
         status.current = self.current_slide
         status.total = self.presentation.total_slides
 
+        # Update reveal indicator
+        if self._is_incremental_enabled():
+            list_count = self._get_list_count()
+            if list_count > 0 and self.reveal_index >= 0:
+                status.reveal_current = self.reveal_index
+                status.reveal_total = list_count
+            else:
+                status.reveal_current = -1
+                status.reveal_total = 0
+        else:
+            status.reveal_current = -1
+            status.reveal_total = 0
+
     def _update_notes(self) -> None:
         """Update the notes panel content."""
         if not self.presentation or not self.presentation.slides:
@@ -617,6 +861,9 @@ class PrezoApp(App):
 
     def watch_current_slide(self, old_value: int, new_value: int) -> None:
         """React to slide changes."""
+        # Determine direction and initialize reveal state appropriately
+        going_back = new_value < old_value
+        self._init_reveal_for_slide(new_value, show_all=going_back)
         self._update_display()
         self._save_position()
 
@@ -636,15 +883,41 @@ class PrezoApp(App):
             notes_panel.remove_class("visible")
 
     def action_next_slide(self) -> None:
-        """Go to the next slide."""
-        if (
-            self.presentation
-            and self.current_slide < self.presentation.total_slides - 1
-        ):
+        """Go to the next slide or reveal next list item."""
+        if not self.presentation:
+            return
+
+        # Check if we should reveal next item instead of advancing slide
+        if self._is_incremental_enabled():
+            list_count = self._get_list_count()
+            if (
+                list_count > 0
+                and self.reveal_index >= 0
+                and self.reveal_index < list_count - 1
+            ):
+                self.reveal_index += 1
+                self._update_display()
+                self._update_progress_bar()
+                return
+
+        # No more items to reveal, go to next slide
+        if self.current_slide < self.presentation.total_slides - 1:
+            # The watcher will initialize reveal_index for the new slide
             self.current_slide += 1
 
     def action_prev_slide(self) -> None:
-        """Go to the previous slide."""
+        """Go to the previous slide or hide last revealed item."""
+        if not self.presentation:
+            return
+
+        # Check if we should hide last item instead of going back
+        if self._is_incremental_enabled() and self.reveal_index > 0:
+            self.reveal_index -= 1
+            self._update_display()
+            self._update_progress_bar()
+            return
+
+        # Go to previous slide (watcher will show all items)
         if self.current_slide > 0:
             self.current_slide -= 1
 
@@ -721,6 +994,10 @@ class PrezoApp(App):
         """Cycle through clock display modes."""
         self.query_one("#status-bar", StatusBar).toggle_clock()
 
+    def action_toggle_timer(self) -> None:
+        """Start or stop the elapsed timer."""
+        self.query_one("#status-bar", StatusBar).toggle_timer()
+
     def action_cycle_theme(self) -> None:
         """Cycle through available themes."""
         self.app_theme = get_next_theme(self.app_theme)
@@ -931,6 +1208,8 @@ def run_app(
     *,
     watch: bool | None = None,
     config: Config | None = None,
+    incremental: bool = False,
+    time_budget: int | None = None,
 ) -> None:
     """Run the Prezo application.
 
@@ -938,7 +1217,15 @@ def run_app(
         presentation_path: Path to the presentation file.
         watch: Whether to watch for file changes. Uses config default if None.
         config: Optional config override. Uses global config if None.
+        incremental: Whether to display lists incrementally (-I flag).
+        time_budget: Time budget in minutes for pacing indicator.
 
     """
-    app = PrezoApp(presentation_path, watch=watch, config=config)
+    app = PrezoApp(
+        presentation_path,
+        watch=watch,
+        config=config,
+        incremental=incremental,
+        time_budget=time_budget,
+    )
     app.run()

prezo/config.py

@@ -61,6 +61,7 @@ class TimerConfig:
     show_clock: bool = True
     show_elapsed: bool = True
     countdown_minutes: int = 0
+    time_budget_minutes: int = 0  # Total time budget for pacing indicator
 
 
 @dataclass
@@ -69,6 +70,7 @@ class BehaviorConfig:
 
     auto_reload: bool = True
     reload_interval: float = 1.0
+    incremental_lists: bool = False  # Display lists one item at a time
 
 
 @dataclass

prezo/export/svg.py

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 import io
+import re
 
 from rich.console import Console
 from rich.markdown import Markdown
@@ -13,66 +14,62 @@ from rich.text import Text
 from prezo.layout import has_layout_blocks, parse_layout, render_layout
 from prezo.themes import get_theme
 
-# SVG template without window chrome (for printing)
-# Uses Rich's template format: {var} for substitution, {{ }} for literal braces
-SVG_FORMAT_NO_CHROME = """\
-<svg class="rich-terminal" viewBox="0 0 {width} {height}" xmlns="http://www.w3.org/2000/svg">
-    <!-- Generated with Rich https://www.textualize.io -->
-    <style>
-
-    @font-face {{
-        font-family: "Fira Code";
-        src: local("FiraCode-Regular"),
-                url("https://cdnjs.cloudflare.com/ajax/libs/firacode/6.2.0/woff2/FiraCode-Regular.woff2") format("woff2"),
-                url("https://cdnjs.cloudflare.com/ajax/libs/firacode/6.2.0/woff/FiraCode-Regular.woff") format("woff");
-        font-style: normal;
-        font-weight: 400;
-    }}
-    @font-face {{
-        font-family: "Fira Code";
-        src: local("FiraCode-Bold"),
-                url("https://cdnjs.cloudflare.com/ajax/libs/firacode/6.2.0/woff2/FiraCode-Bold.woff2") format("woff2"),
-                url("https://cdnjs.cloudflare.com/ajax/libs/firacode/6.2.0/woff/FiraCode-Bold.woff") format("woff");
-        font-style: bold;
-        font-weight: 700;
-    }}
-
-    .{{unique_id}}-matrix {{
-        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;
-        /* Disable ligatures and ensure consistent character widths */
-        font-feature-settings: "liga" 0, "calt" 0, "dlig" 0;
-        font-variant-ligatures: none;
-        letter-spacing: 0;
-        word-spacing: 0;
-        white-space: pre;
-    }}
-
-    .{{unique_id}}-matrix text {{
-        /* Force uniform character spacing for box-drawing chars */
-        text-rendering: geometricPrecision;
-    }}
-
-    {{styles}}
-    </style>
-
-    <defs>
-    <clipPath id="{{unique_id}}-clip-terminal">
-      <rect x="0" y="0" width="{{width}}" height="{{height}}" />
-    </clipPath>
-    {{lines}}
-    </defs>
-
-    <g transform="translate(0, 0)" clip-path="url(#{{unique_id}}-clip-terminal)">
-    {{backgrounds}}
-    <g class="{{unique_id}}-matrix">
-    {{matrix}}
-    </g>
-    </g>
-</svg>
-"""
+# Patterns for stripping window chrome from SVG
+# Window border rect with rounded corners
+_WINDOW_BORDER_PATTERN = re.compile(
+    r'<rect fill="[^"]*" stroke="rgba\(255,255,255,[^"]*\)" '
+    r'stroke-width="1" x="1" y="1" [^/]*/>'
+)
+# Title text element
+_TITLE_TEXT_PATTERN = re.compile(r'<text class="[^"]*-title"[^>]*>[^<]*</text>')
+# Traffic light buttons group
+_TRAFFIC_LIGHTS_PATTERN = re.compile(
+    r'<g transform="translate\(26,22\)">\s*'
+    r"<circle[^/]*/>\s*<circle[^/]*/>\s*<circle[^/]*/>\s*</g>"
+)
+# Content group transform (to adjust offset)
+_CONTENT_TRANSFORM_PATTERN = re.compile(
+    r'<g transform="translate\((\d+(?:\.\d+)?), (\d+(?:\.\d+)?)\)" '
+    r'clip-path="url\(#([^"]+)\)">'
+)
+
+
+def _strip_window_chrome(svg: str) -> str:
+    """Remove window decorations from SVG for printing.
+
+    Removes:
+    - Window border (rounded rect with stroke)
+    - Title text
+    - Traffic light buttons (red/yellow/green circles)
+
+    Also adjusts the content position to start at origin.
+
+    Args:
+        svg: SVG string with window chrome.
+
+    Returns:
+        SVG string without window chrome.
+
+    """
+    # Remove window border
+    svg = _WINDOW_BORDER_PATTERN.sub("", svg)
+
+    # Remove title text
+    svg = _TITLE_TEXT_PATTERN.sub("", svg)
+
+    # Remove traffic lights
+    svg = _TRAFFIC_LIGHTS_PATTERN.sub("", svg)
+
+    # Adjust content transform to remove offset
+    # The content is typically at translate(9, 41) with chrome
+    # Move it to translate(0, 0) for clean output
+    def adjust_transform(match: re.Match) -> str:
+        clip_id = match.group(3)
+        return f'<g transform="translate(0, 0)" clip-path="url(#{clip_id})">'
+
+    svg = _CONTENT_TRANSFORM_PATTERN.sub(adjust_transform, svg)
+
+    return svg
 
 
 def render_slide_to_svg(
@@ -121,8 +118,11 @@ def render_slide_to_svg(
     else:
         slide_content = Markdown(content)
 
-    # Create a panel with the slide content (height - 2 for status bar and padding)
-    panel_height = height - 2
+    # Create a panel with the slide content
+    # Panel takes full height minus status bar line
+    # Note: Rich's export_svg adds chrome which takes ~2 lines at top
+    # So we use height to maximize content area
+    panel_height = height
     panel = Panel(
         slide_content,
         title=f"[{theme.text_muted}]Slide {slide_num + 1}/{total_slides}[/]",
@@ -134,8 +134,8 @@ def render_slide_to_svg(
         height=panel_height,
     )
 
-    # Print to the recording console with background
-    console.print(panel, style=base_style)
+    # Print to the recording console with background (no trailing newline)
+    console.print(panel, style=base_style, end="")
 
     # Add status bar at the bottom
     progress = (slide_num + 1) / total_slides
@@ -146,13 +146,10 @@ def render_slide_to_svg(
     # Pad status bar to full width
     status_text = status_text.ljust(width)
     status = Text(status_text, style=Style(bgcolor=theme.primary, color=theme.text))
-    console.print(status, style=base_style)
+    console.print(status, style=base_style, end="")
 
-    # Export to SVG
-    if chrome:
-        svg = console.export_svg(title=f"Slide {slide_num + 1}")
-    else:
-        svg = console.export_svg(code_format=SVG_FORMAT_NO_CHROME)
+    # Export to SVG (always with Rich's default chrome first)
+    svg = console.export_svg(title=f"Slide {slide_num + 1}")
 
     # Add emoji font fallbacks to font-family declarations
     # Rich only specifies "Fira Code, monospace" which lacks emoji glyphs
@@ -164,7 +161,13 @@ def render_slide_to_svg(
     # 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}"/>'
-    return svg.replace(
+    svg = svg.replace(
         'xmlns="http://www.w3.org/2000/svg">',
         f'xmlns="http://www.w3.org/2000/svg">\n    {bg_rect}',
     )
+
+    # Remove window chrome if requested (for printing)
+    if not chrome:
+        svg = _strip_window_chrome(svg)
+
+    return svg

prezo/layout.py

@@ -538,11 +538,9 @@ class BoxRenderable:
         self, console: Console, options: ConsoleOptions
     ) -> RenderResult:
         """Render content in a bordered panel."""
-        yield Text("")
-        md = Markdown(self.content)
-        panel = Panel(md, title=self.title if self.title else None)
+        content = _render_box_content(self.content)
+        panel = Panel(content, title=self.title if self.title else None)
         yield panel
-        yield Text("")
 
     def __rich_measure__(
         self, console: Console, options: ConsoleOptions
@@ -644,7 +642,10 @@ def render_layout(
     """
     renderables: list[RenderableType] = []
 
-    for block in blocks:
+    for i, block in enumerate(blocks):
+        # Add spacing before box blocks (except the first one)
+        if block.type == "box" and i > 0:
+            renderables.append(Text(""))
         renderables.extend(_render_block(block))
 
     if len(renderables) == 1:
@@ -656,6 +657,96 @@ def render_layout(
 # Utilities
 # -----------------------------------------------------------------------------
 
+# Pattern for **bold** text
+_BOLD_PATTERN = re.compile(r"\*\*(.+?)\*\*")
+
+# Pattern for bullet list items
+_BULLET_PATTERN = re.compile(r"^[-*+]\s+(.*)$")
+
+# Pattern for numbered list items
+_NUMBERED_PATTERN = re.compile(r"^(\d+\.)\s+(.*)$")
+
+
+def _parse_inline_formatting(text: str) -> Text:
+    """Parse inline markdown formatting like **bold**.
+
+    Args:
+        text: Text with possible **bold** markers.
+
+    Returns:
+        Rich Text object with appropriate styling.
+
+    """
+    result = Text()
+    last_end = 0
+
+    for match in _BOLD_PATTERN.finditer(text):
+        # Add text before match
+        if match.start() > last_end:
+            result.append(text[last_end : match.start()])
+        # Add bold text
+        result.append(match.group(1), style="bold")
+        last_end = match.end()
+
+    # Add remaining text
+    if last_end < len(text):
+        result.append(text[last_end:])
+
+    return result
+
+
+def _render_box_content(content: str) -> Text:
+    """Render box content with compact spacing.
+
+    Handles the common pattern of a title line followed by a bullet list,
+    without the extra blank line that Rich's Markdown adds.
+
+    Args:
+        content: Markdown content for the box.
+
+    Returns:
+        Rich Text object with compact formatting.
+
+    """
+    lines = content.strip().split("\n")
+    if not lines:
+        return Text()
+
+    result = Text()
+
+    for i, line in enumerate(lines):
+        stripped = line.strip()
+
+        if not stripped:
+            # Blank line - add single newline
+            if i > 0:
+                result.append("\n")
+            continue
+
+        # Add newline before this line (except first)
+        if i > 0 and result.plain and not result.plain.endswith("\n"):
+            result.append("\n")
+
+        # Check for bullet list item
+        bullet_match = _BULLET_PATTERN.match(stripped)
+        if bullet_match:
+            result.append("  • ")
+            result.append(_parse_inline_formatting(bullet_match.group(1)))
+            continue
+
+        # Check for numbered list item
+        numbered_match = _NUMBERED_PATTERN.match(stripped)
+        if numbered_match:
+            result.append(f"  {numbered_match.group(1)} ")
+            result.append(_parse_inline_formatting(numbered_match.group(2)))
+            continue
+
+        # Regular text line
+        result.append(_parse_inline_formatting(stripped))
+
+    return result
+
+
 # ANSI escape sequence pattern
 _ANSI_PATTERN = re.compile(r"\x1b\[[0-9;]*m")
 

prezo/parser.py

@@ -40,6 +40,7 @@ class Slide:
     raw_content: str = ""  # Original content for editing
     notes: str = ""
     images: list[ImageRef] = field(default_factory=list)
+    incremental: bool | None = None  # Per-slide override for incremental lists
 
 
 @dataclass
@@ -50,7 +51,9 @@ class PresentationConfig:
     show_clock: bool | None = None
     show_elapsed: bool | None = None
     countdown_minutes: int | None = None
+    time_budget_minutes: int | None = None  # Time budget for pacing indicator
     image_mode: str | None = None
+    incremental_lists: bool | None = None
 
     def merge_to_dict(self) -> dict[str, Any]:
         """Convert non-None values to a config dict for merging."""
@@ -63,8 +66,16 @@ class PresentationConfig:
             result.setdefault("timer", {})["show_elapsed"] = self.show_elapsed
         if self.countdown_minutes is not None:
             result.setdefault("timer", {})["countdown_minutes"] = self.countdown_minutes
+        if self.time_budget_minutes is not None:
+            result.setdefault("timer", {})["time_budget_minutes"] = (
+                self.time_budget_minutes
+            )
         if self.image_mode is not None:
             result.setdefault("images", {})["mode"] = self.image_mode
+        if self.incremental_lists is not None:
+            result.setdefault("behavior", {})["incremental_lists"] = (
+                self.incremental_lists
+            )
         return result
 
 
@@ -170,6 +181,24 @@ def extract_notes(content: str) -> tuple[str, str]:
     return content, ""
 
 
+def extract_slide_incremental(content: str) -> bool | None:
+    """Extract per-slide incremental directive from content.
+
+    Looks for:
+    - <!-- incremental --> to enable incremental lists for this slide
+    - <!-- no-incremental --> to disable incremental lists for this slide
+
+    Returns:
+        True if incremental enabled, False if disabled, None if not specified.
+
+    """
+    if re.search(r"<!--\s*incremental\s*-->", content, re.IGNORECASE):
+        return True
+    if re.search(r"<!--\s*no-incremental\s*-->", content, re.IGNORECASE):
+        return False
+    return None
+
+
 def extract_prezo_directives(content: str) -> PresentationConfig:
     """Extract Prezo-specific directives from presentation content.
 
@@ -215,8 +244,13 @@ def extract_prezo_directives(content: str) -> PresentationConfig:
         elif key in ("countdown_minutes", "countdown", "countdownminutes"):
             with contextlib.suppress(ValueError):
                 config.countdown_minutes = int(value)
+        elif key in ("time_budget", "time_budget_minutes", "timebudget"):
+            with contextlib.suppress(ValueError):
+                config.time_budget_minutes = int(value)
         elif key in ("image_mode", "imagemode", "images"):
             config.image_mode = value
+        elif key in ("incremental_lists", "incremental", "incrementallists"):
+            config.incremental_lists = value.lower() in ("true", "1", "yes", "on")
 
     return config
 
@@ -420,6 +454,8 @@ def _parse_content(text: str, source_path: Path | None) -> Presentation:
         slide_content, notes = extract_notes(raw_slide)
         # Extract images BEFORE cleaning (clean_marp_directives removes bg images)
         images = extract_images(slide_content)
+        # Extract per-slide incremental setting
+        incremental = extract_slide_incremental(slide_content)
         cleaned_content = clean_marp_directives(slide_content).strip()
         slide = Slide(
             content=cleaned_content,
@@ -427,6 +463,7 @@ def _parse_content(text: str, source_path: Path | None) -> Presentation:
             raw_content=raw_slide,
             notes=notes.strip(),
             images=images,
+            incremental=incremental,
         )
         presentation.slides.append(slide)
 

prezo/screens/help.py

@@ -35,9 +35,11 @@ HELP_CONTENT = """\
 |-----|--------|
 | **p** | Toggle presenter notes |
 | **c** | Cycle clock/timer modes |
+| **s** | Start/stop timer |
 | **T** | Cycle through themes |
 | **b** | Blackout screen |
 | **w** | Whiteout screen |
+| **i** | View image (native quality) |
 
 ## Editing & Files
 
@@ -81,6 +83,8 @@ countdown_minutes: 45
 - `show_clock`: true/false
 - `show_elapsed`: true/false
 - `countdown_minutes`: number
+- `time_budget`: minutes (shows pacing indicator)
+- `incremental`: true/false (reveal list items one at a time)
 
 ## Documentation
 

prezo/widgets/status_bar.py

@@ -5,6 +5,7 @@ from __future__ import annotations
 from datetime import datetime, timezone
 from typing import TYPE_CHECKING
 
+from rich.text import Text
 from textual.reactive import reactive
 from textual.widgets import Static
 
@@ -56,11 +57,19 @@ class StatusBar(Static):
     show_elapsed: reactive[bool] = reactive(True)
     show_countdown: reactive[bool] = reactive(False)
     countdown_minutes: reactive[int] = reactive(0)
+    # Incremental reveal indicator
+    reveal_current: reactive[int] = reactive(-1)  # -1 = not in reveal mode
+    reveal_total: reactive[int] = reactive(0)
+    # Timer running state
+    timer_running: reactive[bool] = reactive(True)
+    # Time budget for pacing indicator (0 = disabled)
+    time_budget_minutes: reactive[int] = reactive(0)
 
     def __init__(self, **kwargs) -> None:
         """Initialize the status bar."""
         super().__init__(**kwargs)
         self._start_time: datetime | None = None
+        self._elapsed_when_paused: float = 0.0  # Accumulated time when paused
         self._timer: Timer | None = None
 
     def on_mount(self) -> None:
@@ -72,11 +81,26 @@ class StatusBar(Static):
         """Timer callback to refresh the display."""
         self.refresh()
 
-    def render(self) -> str:
+    def render(self) -> Text:
         """Render the status bar content."""
+        result = Text()
+
         # Progress part
         bar = format_progress_bar(self.current, self.total, width=20)
-        progress = f"{bar} {self.current + 1}/{self.total}"
+        progress = f" {bar} {self.current + 1}/{self.total}"
+        result.append(progress)
+
+        # Reveal indicator (shows remaining list items)
+        if self.reveal_current >= 0 and self.reveal_total > 0:
+            remaining = self.reveal_total - self.reveal_current - 1
+            if remaining > 0:
+                result.append(f" [+{remaining}]")
+
+        # Pacing indicator (if time budget is set)
+        pacing = self._get_pacing_indicator()
+        if pacing:
+            result.append("    ")
+            result.append_text(pacing)
 
         # Clock part
         clock_parts = []
@@ -86,26 +110,100 @@ class StatusBar(Static):
             )
 
         if self.show_elapsed and self._start_time:
-            elapsed = datetime.now(tz=timezone.utc) - self._start_time
-            elapsed_secs = int(elapsed.total_seconds())
-            clock_parts.append(f"+{format_time(elapsed_secs)}")
+            elapsed_secs = self._get_elapsed_seconds()
+            # Show pause indicator when timer is stopped
+            pause_indicator = " ⏸" if not self.timer_running else ""
+            clock_parts.append(f"+{format_time(elapsed_secs)}{pause_indicator}")
 
         if self.show_countdown and self.countdown_minutes > 0 and self._start_time:
             total_secs = self.countdown_minutes * 60
-            elapsed = datetime.now(tz=timezone.utc) - self._start_time
-            remaining = total_secs - int(elapsed.total_seconds())
+            elapsed_secs = self._get_elapsed_seconds()
+            remaining = total_secs - elapsed_secs
             clock_parts.append(f"-{format_time(remaining)}")
 
-        clock = " │ ".join(clock_parts) if clock_parts else ""
+        if clock_parts:
+            # Add separator if we have pacing or progress
+            result.append("    ")
+            result.append(" │ ".join(clock_parts))
+
+        result.append(" ")
+        return result
+
+    def _get_pacing_indicator(self) -> Text | None:
+        """Get the pacing indicator with color based on time budget.
 
-        # Combine with spacing
-        if clock:
-            return f" {progress}    {clock} "
-        return f" {progress} "
+        Returns colored indicator:
+        - Green (▲ -Xm) if more than 10% ahead
+        - Red (▼ +Xm) if more than 10% behind
+        - None if no time budget or on track
+
+        """
+        if self.time_budget_minutes <= 0 or self.total <= 0:
+            return None
+
+        elapsed_secs = self._get_elapsed_seconds()
+        total_budget_secs = self.time_budget_minutes * 60
+
+        # Expected time for current slide position
+        # (current is 0-indexed, so current+1 gives slides completed)
+        expected_secs = (total_budget_secs / self.total) * (self.current + 1)
+
+        # Calculate difference (positive = behind, negative = ahead)
+        diff_secs = elapsed_secs - expected_secs
+        diff_pct = diff_secs / expected_secs if expected_secs > 0 else 0
+
+        # More than 10% threshold
+        if diff_pct > 0.1:
+            # Behind schedule - need to speed up (red background, white text)
+            diff_mins = int(abs(diff_secs) / 60)
+            diff_remaining = int(abs(diff_secs) % 60)
+            if diff_mins > 0:
+                indicator = f" ▼ +{diff_mins}m{diff_remaining:02d}s "
+            else:
+                indicator = f" ▼ +{diff_remaining}s "
+            return Text(indicator, style="bold white on red")
+        if diff_pct < -0.1:
+            # Ahead of schedule (green background, white text)
+            diff_mins = int(abs(diff_secs) / 60)
+            diff_remaining = int(abs(diff_secs) % 60)
+            if diff_mins > 0:
+                indicator = f" ▲ -{diff_mins}m{diff_remaining:02d}s "
+            else:
+                indicator = f" ▲ -{diff_remaining}s "
+            return Text(indicator, style="bold white on green")
+
+        # On track - no indicator needed
+        return None
+
+    def _get_elapsed_seconds(self) -> int:
+        """Get total elapsed seconds, accounting for pauses."""
+        if not self._start_time:
+            return 0
+        if self.timer_running:
+            current_elapsed = datetime.now(tz=timezone.utc) - self._start_time
+            return int(current_elapsed.total_seconds() + self._elapsed_when_paused)
+        # When paused, just return the accumulated time
+        return int(self._elapsed_when_paused)
 
     def reset_timer(self) -> None:
         """Reset the elapsed timer."""
         self._start_time = datetime.now(tz=timezone.utc)
+        self._elapsed_when_paused = 0.0
+        self.timer_running = True
+        self.refresh()
+
+    def toggle_timer(self) -> None:
+        """Start or stop the elapsed timer."""
+        if self.timer_running:
+            # Pausing: save current elapsed time
+            if self._start_time:
+                current_elapsed = datetime.now(tz=timezone.utc) - self._start_time
+                self._elapsed_when_paused += current_elapsed.total_seconds()
+            self.timer_running = False
+        else:
+            # Resuming: reset start time (accumulated time is preserved)
+            self._start_time = datetime.now(tz=timezone.utc)
+            self.timer_running = True
         self.refresh()
 
     def toggle_clock(self) -> None:
@@ -142,6 +240,22 @@ class StatusBar(Static):
         """React to elapsed time visibility changes."""
         self.refresh()
 
+    def watch_reveal_current(self, value: int) -> None:
+        """React to reveal indicator changes."""
+        self.refresh()
+
+    def watch_reveal_total(self, value: int) -> None:
+        """React to reveal total changes."""
+        self.refresh()
+
+    def watch_timer_running(self, value: bool) -> None:
+        """React to timer running state changes."""
+        self.refresh()
+
+    def watch_time_budget_minutes(self, value: int) -> None:
+        """React to time budget changes."""
+        self.refresh()
+
 
 # Keep these for backwards compatibility and separate use
 class ProgressBar(Static):

{prezo-2026.1.3.dist-info → prezo-2026.2.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: prezo
-Version: 2026.1.3
+Version: 2026.2.1
 Summary: A TUI-based presentation tool for the terminal, built with Textual.
 Author: Stefane Fermigier
 Author-email: Stefane Fermigier <sf@fermigier.com>
@@ -20,6 +20,7 @@ Display presentations written in Markdown using conventions similar to those of
 
 - **Markdown presentations** - MARP/Deckset format with `---` slide separators
 - **Column layouts** - Pandoc-style fenced divs for multi-column slides (`::: columns`)
+- **Incremental lists** - Reveal list items one at a time (`-I` flag, like Pandoc)
 - **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`)
@@ -71,6 +72,9 @@ prezo -c myconfig.toml presentation.md
 # Set image rendering mode
 prezo --image-mode ascii presentation.md   # Options: auto, kitty, sixel, iterm, ascii, none
 
+# Incremental list reveal (reveal items one at a time)
+prezo -I presentation.md
+
 # Export to PDF
 prezo -e pdf presentation.md
 
@@ -92,6 +96,7 @@ prezo -e pdf presentation.md --theme light --size 100x30 --no-chrome
 | `t` | Table of contents |
 | `p` | Toggle notes panel |
 | `c` | Cycle clock display |
+| `s` | Start/stop timer |
 | `T` | Cycle theme |
 | `b` | Blackout screen |
 | `w` | Whiteout screen |

{prezo-2026.1.3.dist-info → prezo-2026.2.1.dist-info}/RECORD

@@ -1,12 +1,12 @@
-prezo/__init__.py,sha256=RDpFh0F3DGdMB08n7G3HM-c14JAoqvElq4DyXLSPDQg,6740
-prezo/app.py,sha256=3RPSx56hjyyG55ueNWHvuUNe-KkQ3ZzidNgBRc3I2WQ,31713
-prezo/config.py,sha256=DLHUQkThxhmYXQE1AgpWkPvtNlDwOxQRSNjRrfJJEew,6646
+prezo/__init__.py,sha256=-w5od4EwSOtxdqJGhmeGm_lncSQUdY_OCsH06Ha8hAQ,7598
+prezo/app.py,sha256=MwNfymSXEIQm42wXCgLw7VV_98EM1ngSdjGrrNrK9Ds,42440
+prezo/config.py,sha256=iViAqEqv48uK4OpqfoD8uiVWFpmPUV18Dhz58tK-b3U,6793
 prezo/export/__init__.py,sha256=jdf4Xu71aUKPBXUt8k8TEUzgMee4bfEh71iJGZXtVKE,1010
 prezo/export/common.py,sha256=W9Gn2_wjd3EPuenAECrs6pqsJEWFBJHtGs8y6-4VEKQ,2451
 prezo/export/html.py,sha256=GLRjTvZUEmvee6F2NlU3sn94H47PqLTLpaC3Ab_kxo8,8787
 prezo/export/images.py,sha256=TNTGIYNRTxwVjbHqZXYjIj0gouV_Dy1_DtenMlxsquE,7410
 prezo/export/pdf.py,sha256=9rzybk8o1vEu_JwvKB2abzrYoKfpEA8IP5pEFJHF5WM,13942
-prezo/export/svg.py,sha256=gxhRXpLiKcVr4NSF8nwaid74p8f9dvj4RwXwvMP0EbU,5698
+prezo/export/svg.py,sha256=xRr4wMRkPGJrS0Ue69ldjA6VneZ3D7oYRvDbZocwrHs,5539
 prezo/images/__init__.py,sha256=xrWSR3z0SXYpLtjIvR2VOMxiJGkxEsls5-EOs9GecFA,324
 prezo/images/ascii.py,sha256=aNz02jN4rkDw0WzmkGDrAGw1R1dY5QGREvIIPI6jwow,7613
 prezo/images/base.py,sha256=STuS57AVSJ2lzwyn0QrIceGaSd2IWEiLGN-elT3u3AM,2749
@@ -16,13 +16,13 @@ prezo/images/kitty.py,sha256=mWR-tIE_WDP5BjOkQydPpxWBBGNaZL8PkMICesWQid8,10883
 prezo/images/overlay.py,sha256=lWIAvINxZrKembtB0gzWWaUoedNt7beFU4OhErfwWaw,9600
 prezo/images/processor.py,sha256=zMcfwltecup_AX2FhUIlPdO7c87a9jw7P9tLTIkr54U,4069
 prezo/images/sixel.py,sha256=2IeKDiMsWU1Tn3HYI3PC972ygxKGqpfz6tnhQcM_sVM,5604
-prezo/layout.py,sha256=xy-UaZvU2ZDe0H7XjMCDb30tog4LRdZKB5OUh_r0aqo,19929
-prezo/parser.py,sha256=f1eJtr9xVnxa35jgQ3GvKwNa6TvaXrIKQWgBB_geVAI,15058
+prezo/layout.py,sha256=FN-nMX902jx9MA7TnySbPskmnyWAiziv_xBvTTYrFd0,22463
+prezo/parser.py,sha256=bD3CFoFZ_vCa5x8US1vsKD1u6kJDC7d1sRqnLh8ZVUU,16680
 prezo/screens/__init__.py,sha256=xHG9jNJz4vi1tpneSEVlD0D9I0M2U4gAGk6-R9xbUf4,508
 prezo/screens/base.py,sha256=2n6Uj8evfIbcpn4AVYNG5iM_k7rIJ3Vwmor_xrQPU9E,2057
 prezo/screens/blackout.py,sha256=wPSdD9lgu8ykAIQjU1OesnmjQoQEn9BdC4TEpABYxW4,1640
 prezo/screens/goto.py,sha256=l9q6RAU8GX8WIALvbaPE3rcszrYWsJob8lGIDvUaWFM,2687
-prezo/screens/help.py,sha256=fjwHp9qPMmyRIaME-Bcz-g6bn8UrtbL_Dk269QSU-zs,2987
+prezo/screens/help.py,sha256=Sulw8nljnLbNZRwF7w3zFbaIe56Vx1mU7uuCWCJG0H4,3168
 prezo/screens/overview.py,sha256=s9-ifbcnXYhbxb_Kl2UhpB3IE7msInX6LWB-J1dazLo,5382
 prezo/screens/search.py,sha256=3YG9WLGEIKW3YHpM0K1lgwhuqBveXd8ZoQZ178_zGd4,7809
 prezo/screens/toc.py,sha256=8WYb5nbgP9agY-hUTATxLU4X1uka_bc2MN86hFW4aRg,8241
@@ -32,8 +32,8 @@ prezo/widgets/__init__.py,sha256=6qAbVVWG2fb4DLv0EzMQ-Qbi74SviXIo-7D7DyDwnrI,378
 prezo/widgets/image_display.py,sha256=8IKncaoC2iWebmJQp_QomF7UVgRxD4WThOshN1Nht2M,3361
 prezo/widgets/slide_button.py,sha256=g5mvtCZSorTIZp_PXgHYeYeeCSNFy0pW3K7iDlZu7yA,2012
 prezo/widgets/slide_content.py,sha256=AO3doIuPBSo5vec_d1xE5F8YMJWxzOq5IFO7gSYSWNw,2300
-prezo/widgets/status_bar.py,sha256=Wcun71kg2Q4s5aduPwTvS4kDHZj5p-zDmD7Cx3_ZFP4,8136
-prezo-2026.1.3.dist-info/WHEEL,sha256=eh7sammvW2TypMMMGKgsM83HyA_3qQ5Lgg3ynoecH3M,79
-prezo-2026.1.3.dist-info/entry_points.txt,sha256=74ShZJ_EKjzi63JyPynVnc0uCHGNjIWjAVs8vU_qTyA,38
-prezo-2026.1.3.dist-info/METADATA,sha256=mv3i3_l0Rq03cmGDQzwBeZ9FiUIJ6enFmJNSvm83v2I,5320
-prezo-2026.1.3.dist-info/RECORD,,
+prezo/widgets/status_bar.py,sha256=wt7jrijSsnYDBnpVZDqgztBcbA30HdOXnUiEIhw93yQ,12695
+prezo-2026.2.1.dist-info/WHEEL,sha256=eh7sammvW2TypMMMGKgsM83HyA_3qQ5Lgg3ynoecH3M,79
+prezo-2026.2.1.dist-info/entry_points.txt,sha256=74ShZJ_EKjzi63JyPynVnc0uCHGNjIWjAVs8vU_qTyA,38
+prezo-2026.2.1.dist-info/METADATA,sha256=lQHxjNBic-uFI2SRk_B7fC1vF5FFlcLipMa_28nCfaE,5511
+prezo-2026.2.1.dist-info/RECORD,,