przn 0.1.6 → 0.3.0

data/lib/przn/renderer.rb

@@ -18,37 +18,62 @@ module Przn
     def initialize(terminal, base_dir: '.', theme: nil)
       @terminal = terminal
       @base_dir = base_dir
-      @theme = theme
+      @theme = theme || Theme.default
+      @image_cache = {}
+      @kitty_uploads = {}
+      @mutex = Mutex.new
     end
 
     def render(slide, current:, total:)
-      @terminal.clear
-      w = @terminal.width
-      h = @terminal.height
+      @mutex.synchronize do
+        @terminal.clear
+        apply_slide_background(slide)
+        w = @terminal.width
+        h = @terminal.height
+
+        row = if current == 0
+          content_height = calculate_height(slide.blocks, w)
+          usable_height = h - 1
+          [(usable_height - content_height) / 2 + 1, 1].max
+        else
+          2
+        end
 
-      row = if current == 0
-        content_height = calculate_height(slide.blocks, w)
-        usable_height = h - 1
-        [(usable_height - content_height) / 2 + 1, 1].max
-      else
-        2
+        pending_align = nil
+        slide.blocks.each do |block|
+          if block[:type] == :align
+            pending_align = block[:align]
+          else
+            row = render_block(block, w, row, align: pending_align)
+            pending_align = nil
+          end
+        end
+
+        status = " #{current + 1} / #{total} "
+        @terminal.move_to(h, w - status.size)
+        @terminal.write "#{ANSI[:dim]}#{status}#{ANSI[:reset]}"
+
+        @terminal.flush
       end
+    end
 
-      pending_align = nil
-      slide.blocks.each do |block|
-        if block[:type] == :align
-          pending_align = block[:align]
-        else
-          row = render_block(block, w, row, align: pending_align)
-          pending_align = nil
+    # Warm caches for a slide we expect to navigate to soon. Uploads any PNG
+    # images on the Kitty Graphics Protocol so the next render only needs a
+    # placement command. Safe to call from a background thread; serialized
+    # against `render` via the renderer's mutex so terminal writes don't
+    # interleave.
+    def preload(slide)
+      return unless ImageUtil.kitty_terminal?
+
+      @mutex.synchronize do
+        slide.blocks.each do |block|
+          next unless block[:type] == :image
+          path = resolve_image_path(block[:path])
+          next unless File.exist?(path) && ImageUtil.png?(path)
+          ensure_kitty_uploaded(path)
         end
+        @terminal.flush
       end
-
-      status = " #{current + 1} / #{total} "
-      @terminal.move_to(h, w - status.size)
-      @terminal.write "#{ANSI[:dim]}#{status}#{ANSI[:reset]}"
-
-      @terminal.flush
     end
 
     private
@@ -65,32 +90,67 @@ module Przn
       when :table           then render_table(block, width, row)
       when :image           then render_image(block, width, row)
       when :blank           then row + DEFAULT_SCALE
+      when :bg              then row
       else row + 1
       end
     end
 
+    # Emit Echoes' OSC 7772 to set a slide-specific solid color or gradient,
+    # or clear any previous override. A `<bg .../>` block on the slide wins;
+    # otherwise the theme's `bg:` section is used as the deck-wide default.
+    # Other terminals ignore the OSC code, so this is a no-op outside Echoes.
+    def apply_slide_background(slide)
+      block = slide.blocks.find { |b| b[:type] == :bg }
+      attrs = block ? block[:attrs] : (@theme.background || {})
+
+      @terminal.write "\e]7772;bg-clear\a"
+      return if attrs.empty?
+
+      if (color = attrs[:color])
+        @terminal.write "\e]7772;bg-color;#{color}\a"
+        return
+      end
+
+      colors = [attrs[:from], attrs[:to]].compact
+      return if colors.size < 2
+
+      type = attrs[:type] || 'linear'
+      angle = attrs[:angle] || 0
+      @terminal.write "\e]7772;bg-gradient;type=#{type}:angle=#{angle}:colors=#{colors.join(',')}\a"
+    end
+
     def render_heading(block, width, row)
       text = block[:content]
 
       if block[:level] == 1
-        scale = KittyText::HEADING_SCALES[1]
-        visible_width = display_width(text) * scale
-        pad = [(width - visible_width) / 2, 0].max
-        @terminal.move_to(row, pad + 1)
-        @terminal.write "#{ANSI[:bold]}#{KittyText.sized(text, s: scale)}#{ANSI[:reset]}"
-        row + scale + 4
+        title = @theme.title || {}
+        scale = (title[:size] && Parser::SIZE_SCALES[title[:size].to_s]) || KittyText::HEADING_SCALES[1]
+        face = title[:family]
+        color = title[:color]
+        max_w = max_text_width(width, 0, scale)
+        segments = Parser.parse_inline(text)
+        wrapped = wrap_segments(segments, max_w, scale)
+
+        wrapped.each do |line_segs|
+          vis = segments_visible_cells(line_segs, scale)
+          pad = [(width - vis) / 2, 0].max
+          @terminal.move_to(row, pad + 1)
+          @terminal.write "#{ANSI[:bold]}#{render_segments_scaled(line_segs, scale, default_face: face, default_h: 2, default_color: color)}#{ANSI[:reset]}"
+          row += scale
+        end
+        row + 4
       else
         left = content_left(width)
-        prefix = "・"
+        prefix = @theme.bullet[:text]
         prefix_w = display_width(prefix)
         max_w = max_text_width(width, left, DEFAULT_SCALE) - prefix_w
         segments = Parser.parse_inline(text)
-        wrapped = wrap_segments(segments, max_w)
+        wrapped = wrap_segments(segments, max_w, DEFAULT_SCALE)
 
         wrapped.each_with_index do |line_segs, li|
           @terminal.move_to(row, left)
           if li == 0
-            @terminal.write "#{KittyText.sized(prefix, s: DEFAULT_SCALE)}#{render_segments_scaled(line_segs, DEFAULT_SCALE)}"
+            @terminal.write "#{render_bullet(prefix)}#{render_segments_scaled(line_segs, DEFAULT_SCALE)}"
           else
             @terminal.write "#{KittyText.sized(" " * prefix_w, s: DEFAULT_SCALE)}#{render_segments_scaled(line_segs, DEFAULT_SCALE)}"
           end
@@ -112,7 +172,7 @@ module Przn
 
       max_w = max_text_width(width, left, scale)
       segments = Parser.parse_inline(text)
-      wrapped = wrap_segments(segments, max_w)
+      wrapped = wrap_segments(segments, max_w, scale)
 
       wrapped.each do |line_segs|
         @terminal.move_to(row, left + 1)
@@ -147,17 +207,17 @@ module Przn
       block[:items].each do |item|
         depth = item[:depth] || 0
         indent = "  " * depth
-        prefix = "#{indent}・"
+        prefix = "#{indent}#{@theme.bullet[:text]}"
         prefix_w = display_width(prefix)
         max_w = max_text_width(width, left, DEFAULT_SCALE) - prefix_w
 
         segments = Parser.parse_inline(item[:text])
-        wrapped = wrap_segments(segments, max_w)
+        wrapped = wrap_segments(segments, max_w, DEFAULT_SCALE)
 
         wrapped.each_with_index do |line_segs, li|
           @terminal.move_to(row, left)
           if li == 0
-            @terminal.write "#{KittyText.sized(prefix, s: DEFAULT_SCALE)}#{render_segments_scaled(line_segs, DEFAULT_SCALE)}"
+            @terminal.write "#{render_bullet(prefix)}#{render_segments_scaled(line_segs, DEFAULT_SCALE)}"
           else
             @terminal.write "#{KittyText.sized(" " * prefix_w, s: DEFAULT_SCALE)}#{render_segments_scaled(line_segs, DEFAULT_SCALE)}"
           end
@@ -178,7 +238,7 @@ module Przn
         max_w = max_text_width(width, left, DEFAULT_SCALE) - prefix_w
 
         segments = Parser.parse_inline(item[:text])
-        wrapped = wrap_segments(segments, max_w)
+        wrapped = wrap_segments(segments, max_w, DEFAULT_SCALE)
 
         wrapped.each_with_index do |line_segs, li|
           @terminal.move_to(row, left)
@@ -199,7 +259,7 @@ module Przn
       max_w = max_text_width(width, left, DEFAULT_SCALE)
 
       segments = Parser.parse_inline(block[:term])
-      wrapped = wrap_segments(segments, max_w)
+      wrapped = wrap_segments(segments, max_w, DEFAULT_SCALE)
       wrapped.each do |line_segs|
         @terminal.move_to(row, left)
         @terminal.write "#{ANSI[:bold]}#{render_segments_scaled(line_segs, DEFAULT_SCALE)}#{ANSI[:reset]}"
@@ -209,7 +269,7 @@ module Przn
       def_max_w = [max_w - 4, 1].max
       block[:definition].each_line do |line|
         segments = Parser.parse_inline(line.chomp)
-        wrapped = wrap_segments(segments, def_max_w)
+        wrapped = wrap_segments(segments, def_max_w, DEFAULT_SCALE)
         wrapped.each do |line_segs|
           @terminal.move_to(row, left + 4)
           @terminal.write render_segments_scaled(line_segs, DEFAULT_SCALE)
@@ -228,7 +288,7 @@ module Przn
       block[:content].each_line do |line|
         text = line.chomp
         segments = [[:text, text]]
-        wrapped = wrap_segments(segments, max_w)
+        wrapped = wrap_segments(segments, max_w, DEFAULT_SCALE)
 
         wrapped.each_with_index do |line_segs, li|
           @terminal.move_to(row, left + 1)
@@ -303,14 +363,18 @@ module Przn
 
       x = [(width - target_cols) / 2, 0].max
 
-      if ImageUtil.kitty_terminal?
-        data = ImageUtil.kitty_icat(path, cols: target_cols, rows: target_rows, x: x, y: row - 1)
+      if ImageUtil.kitty_terminal? && ImageUtil.png?(path)
+        image_id = ensure_kitty_uploaded(path)
+        @terminal.move_to(row, x + 1)
+        @terminal.write ImageUtil.kitty_place(image_id: image_id, cols: target_cols, rows: target_rows)
+      elsif ImageUtil.kitty_terminal?
+        data = cached_kitty_icat(path, cols: target_cols, rows: target_rows, x: x, y: row - 1)
         @terminal.write data if data && !data.empty?
       elsif ImageUtil.sixel_available?
         @terminal.move_to(row, x + 1)
         target_pixel_w = target_cols * cell_w
         target_pixel_h = target_rows * cell_h
-        sixel = ImageUtil.sixel_encode(path, width: target_pixel_w, height: target_pixel_h)
+        sixel = cached_sixel_encode(path, width: target_pixel_w, height: target_pixel_h)
         @terminal.write sixel if sixel && !sixel.empty?
       end
 
@@ -322,6 +386,39 @@ module Przn
       File.expand_path(path, @base_dir)
     end
 
+    # Memoize the encoded escape-sequence bytes so revisiting a slide
+    # skips both the subprocess fork and the image decode/encode work.
+    # Keyed by file mtime so edits to the source image invalidate.
+    def cached_kitty_icat(path, cols:, rows:, x:, y:)
+      key = [:kitty, path, image_mtime(path), cols, rows, x, y]
+      return @image_cache[key] if @image_cache.key?(key)
+      @image_cache[key] = ImageUtil.kitty_icat(path, cols: cols, rows: rows, x: x, y: y)
+    end
+
+    def cached_sixel_encode(path, width:, height:)
+      key = [:sixel, path, image_mtime(path), width, height]
+      return @image_cache[key] if @image_cache.key?(key)
+      @image_cache[key] = ImageUtil.sixel_encode(path, width: width, height: height)
+    end
+
+    def image_mtime(path)
+      File.mtime(path).to_f
+    rescue Errno::ENOENT
+      nil
+    end
+
+    # Upload a PNG to the Kitty terminal once and return the assigned image
+    # id. Subsequent renders of the same file (same mtime) reuse the id and
+    # only emit a small placement command, skipping the file-transfer cost.
+    def ensure_kitty_uploaded(path)
+      key = [path, image_mtime(path)]
+      return @kitty_uploads[key] if @kitty_uploads.key?(key)
+
+      image_id = @kitty_uploads.size + 1
+      @terminal.write ImageUtil.kitty_upload_png(path, image_id: image_id)
+      @kitty_uploads[key] = image_id
+    end
+
     def content_left(width)
       width / 16
     end
@@ -364,81 +461,165 @@ module Przn
       end
     end
 
-    def render_segments_scaled(segments, para_scale)
-      segments.map { |segment|
+    # Render the list/heading bullet. When `bullet_size` is smaller than the
+    # body scale, use OSC 66 fractional scaling (n/d) with v=2 to keep the
+    # glyph's cell footprint at body scale but draw a smaller dot vertically
+    # centered. Plain `s=N` for a smaller bullet would top-align it inside
+    # the row, which looks wrong against the larger body text.
+    def render_bullet(prefix)
+      size = @theme.bullet[:size]
+      if size && size < DEFAULT_SCALE
+        KittyText.sized(prefix, s: DEFAULT_SCALE, n: size, d: DEFAULT_SCALE, v: 2)
+      else
+        KittyText.sized(prefix, s: size || DEFAULT_SCALE)
+      end
+    end
+
+    # Render a <font face="..." size="..." color="..."> run. The face goes out
+    # via OSC 66 f= (Echoes extension); the size resolves through the same
+    # SIZE_SCALES table that <size=N> uses; the color wraps in the same ANSI
+    # escape that <color=NAME> uses.
+    def render_font_segment(content, attrs, para_scale, default_face: nil, default_h: nil)
+      scale = (attrs[:size] && Parser::SIZE_SCALES[attrs[:size]]) || para_scale
+      base = KittyText.sized(content, s: scale, f: attrs[:face] || default_face, h: default_h)
+      color = attrs[:color]
+      return base unless color
+      "#{color_code(color)}#{base}#{ANSI[:reset]}"
+    end
+
+    # `default_face:` / `default_color:` let a caller (currently h1 rendering)
+    # override the OSC 66 `f=` and the ANSI fg for every emit on the line.
+    # When unset, body text falls back to `theme.font.family` / `theme.font.color`.
+    # To opt out of that body fallback (so a heading can render in the
+    # terminal's defaults even when body text is themed), pass the keyword
+    # explicitly — even `nil` is honored. Inline `<font face/color>` and
+    # `<color=...>` runs still win for their own segments.
+    #
+    # `default_h:` threads an OSC 66 `h=` (horizontal alignment) into every
+    # emit on the line. h1 uses h=2 so a proportional `title.family` is
+    # centered within the reserved cell block — without it the glyphs left-
+    # align inside the block and the visible text drifts left of the center
+    # column we computed.
+    def render_segments_scaled(segments, para_scale, default_face: :body, default_h: nil, default_color: :body)
+      f = default_face == :body ? @theme.font[:family] : default_face
+      h = default_h
+      c = default_color == :body ? @theme.font[:color] : default_color
+      body_open = c ? color_code(c) : ""
+      inner = segments.map { |segment|
         type = segment[0]
         content = segment[1]
         case type
         when :tag
           tag_name = segment[2]
           if (scale = Parser::SIZE_SCALES[tag_name])
-            KittyText.sized(content, s: scale)
+            KittyText.sized(content, s: scale, f: f, h: h)
           elsif Parser::NAMED_COLORS.key?(tag_name)
-            "#{color_code(tag_name)}#{KittyText.sized(content, s: para_scale)}#{ANSI[:reset]}"
+            "#{color_code(tag_name)}#{KittyText.sized(content, s: para_scale, f: f, h: h)}#{ANSI[:reset]}#{body_open}"
           else
-            KittyText.sized(content, s: para_scale)
+            KittyText.sized(content, s: para_scale, f: f, h: h)
           end
-        when :note          then "#{ANSI[:dim]}#{KittyText.sized(content, s: para_scale)}#{ANSI[:reset]}"
-        when :bold          then "#{ANSI[:bold]}#{KittyText.sized(content, s: para_scale)}#{ANSI[:reset]}"
-        when :italic        then "#{ANSI[:italic]}#{KittyText.sized(content, s: para_scale)}#{ANSI[:reset]}"
-        when :strikethrough then "#{ANSI[:strikethrough]}#{KittyText.sized(content, s: para_scale)}#{ANSI[:reset]}"
-        when :code          then "#{ANSI[:gray_bg]}#{KittyText.sized(" #{content} ", s: para_scale)}#{ANSI[:reset]}"
-        when :text          then KittyText.sized(content, s: para_scale)
+        when :font          then "#{render_font_segment(content, segment[2] || {}, para_scale, default_face: f, default_h: h)}#{(segment[2] || {})[:color] ? body_open : ''}"
+        when :note          then "#{ANSI[:dim]}#{KittyText.sized(content, s: para_scale, f: f, h: h)}#{ANSI[:reset]}#{body_open}"
+        when :bold          then "#{ANSI[:bold]}#{KittyText.sized(content, s: para_scale, f: f, h: h)}#{ANSI[:reset]}#{body_open}"
+        when :italic        then "#{ANSI[:italic]}#{KittyText.sized(content, s: para_scale, f: f, h: h)}#{ANSI[:reset]}#{body_open}"
+        when :strikethrough then "#{ANSI[:strikethrough]}#{KittyText.sized(content, s: para_scale, f: f, h: h)}#{ANSI[:reset]}#{body_open}"
+        when :code          then "#{ANSI[:gray_bg]}#{KittyText.sized(" #{content} ", s: para_scale, f: f, h: h)}#{ANSI[:reset]}#{body_open}"
+        when :text          then KittyText.sized(content, s: para_scale, f: f, h: h)
         end
       }.join
+      body_open.empty? ? inner : "#{body_open}#{inner}#{ANSI[:reset]}"
     end
 
     def render_inline_scaled(text, para_scale)
       render_segments_scaled(Parser.parse_inline(text), para_scale)
     end
 
-    # Wrap parsed inline segments into lines that fit within max_width display units
-    def wrap_segments(segments, max_width)
+    # Wrap parsed inline segments into lines that fit within max_width units,
+    # where 1 unit = `para_scale` terminal cells. Per-segment scaling (e.g.
+    # size tags) is honored so a span with a larger scale consumes more budget.
+    def wrap_segments(segments, max_width, para_scale = DEFAULT_SCALE)
       return [segments] if max_width <= 0
 
+      max_cells = max_width * para_scale
       lines = [[]]
-      width = 0
+      used = 0
 
       segments.each do |seg|
         content = seg[1] || ""
-        seg_w = display_width(content)
+        next if content.empty?
+
+        seg_scale = effective_seg_scale(seg, para_scale)
+        seg_cells = display_width(content) * seg_scale
 
-        if width + seg_w <= max_width
+        if used + seg_cells <= max_cells
           lines.last << seg
-          width += seg_w
+          used += seg_cells
           next
         end
 
         remaining = content
         loop do
-          space = max_width - width
-          if space <= 0
+          space_cells = max_cells - used
+          if space_cells < seg_scale && used > 0
             lines << []
-            width = 0
-            space = max_width
+            used = 0
+            space_cells = max_cells
           end
 
-          chunk, remaining = split_by_display_width(remaining, space)
+          chunk_max_dw = [space_cells / seg_scale, 1].max
+          chunk, remaining = split_by_display_width(remaining, chunk_max_dw)
           lines.last << [seg[0], chunk, *Array(seg[2..])]
-          width += display_width(chunk)
+          used += display_width(chunk) * seg_scale
 
           break unless remaining
           lines << []
-          width = 0
+          used = 0
         end
       end
 
       lines
     end
 
+    def effective_seg_scale(seg, para_scale)
+      case seg[0]
+      when :tag
+        Parser::SIZE_SCALES[seg[2]] || para_scale
+      when :font
+        size = seg[2].is_a?(Hash) ? seg[2][:size] : nil
+        (size && Parser::SIZE_SCALES[size]) || para_scale
+      else
+        para_scale
+      end
+    end
+
+    def segments_visible_cells(segments, para_scale)
+      segments.sum { |seg|
+        content = seg[1] || ""
+        display_width(content) * effective_seg_scale(seg, para_scale)
+      }
+    end
+
+    # Split `text` so the first piece fits within `max_width` cells, preferring
+    # to break at the last whitespace before the overflow rather than mid-word.
+    # Falls back to a char-level split when no whitespace is available — single
+    # long words, CJK runs (no inter-character whitespace) — so a word that's
+    # itself longer than the line still wraps instead of overflowing.
     def split_by_display_width(text, max_width)
       w = 0
+      last_space = nil
       text.each_char.with_index do |c, i|
         cw = display_width(c)
         if w + cw > max_width && w > 0
-          return [text[0...i], text[i..]]
+          if c == ' '
+            return [text[0...i], text[(i + 1)..]]
+          elsif last_space && last_space > 0
+            return [text[0...last_space], text[(last_space + 1)..]]
+          else
+            return [text[0...i], text[i..]]
+          end
         end
         w += cw
+        last_space = i if c == ' '
       end
       [text, nil]
     end
@@ -511,6 +692,7 @@ module Przn
              (o >= 0xfe30 && o <= 0xfe6f) ||
              (o >= 0xff00 && o <= 0xff60) ||
              (o >= 0xffe0 && o <= 0xffe6) ||
+             (o >= 0x1f300 && o <= 0x1faff) ||  # emoji blocks; terminals render these as 2 cells
              (o >= 0x20000 && o <= 0x2fffd) ||
              (o >= 0x30000 && o <= 0x3fffd))
           2
@@ -529,6 +711,7 @@ module Przn
         .gsub(/\*(.+?)\*/, '\1')
         .gsub(/~~(.+?)~~/, '\1')
         .gsub(/`([^`]+)`/, '\1')
+        .gsub(/&(lt|gt|amp);/) { |_| {"lt" => "<", "gt" => ">", "amp" => "&"}[$1] }
     end
 
     def calculate_height(blocks, width)
@@ -572,6 +755,8 @@ module Przn
         image_block_height(block, width)
       when :align
         0
+      when :bg
+        0
       when :blank
         s
       else

data/lib/przn/screenshot_pdf_exporter.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+require 'tmpdir'
+require 'fileutils'
+
+module Przn
+  # Renders each slide live to the user's terminal, asks the terminal to save
+  # the current pane as a vector PDF via Echoes' OSC 7772 `capture` command,
+  # then concatenates the per-slide PDFs into a single multi-page PDF.
+  #
+  # Trade-off vs the Prawn-based PdfExporter:
+  #   - Pixel-perfect match with what's on screen (gradients, fonts, OSC 66
+  #     sized text, bullet glyphs, the lot) — but vector, so the result is
+  #     small, sharp at any zoom, and text stays selectable.
+  #   - Requires running inside a terminal that implements OSC 7772 capture
+  #     to a `.pdf` path (i.e. Echoes). Won't work in CI or any terminal that
+  #     doesn't honor the command.
+  #
+  # Echoes-side wire format (independent of przn):
+  #   ESC ] 7772 ; capture ; <absolute_path> BEL
+  #   On receipt, Echoes saves the current pane to the path. The file
+  #   extension picks the format — `.pdf` produces a single-page vector PDF
+  #   by replaying the same drawing pipeline into a CGPDFContext instead of
+  #   the screen's NSGraphicsContext.
+  class ScreenshotPdfExporter
+    OSC = "\e]7772".freeze
+    BEL = "\a".freeze
+
+    POLL_INTERVAL = 0.05  # seconds between file-existence checks
+    CAPTURE_TIMEOUT = 10  # seconds per slide before giving up
+
+    def initialize(presentation, base_dir: '.', theme: nil, terminal: nil)
+      @presentation = presentation
+      @base_dir = base_dir
+      @theme = theme || Theme.default
+      @terminal = terminal || Terminal.new
+      @renderer = Renderer.new(@terminal, base_dir: base_dir, theme: theme)
+    end
+
+    def export(output_path)
+      require 'hexapdf'
+
+      Dir.mktmpdir('przn-capture') do |dir|
+        pdf_paths = capture_all_slides(dir)
+        merge_pdfs(pdf_paths, output_path)
+      end
+    end
+
+    private
+
+    def capture_all_slides(dir)
+      paths = []
+      @terminal.enter_alt_screen
+      @terminal.hide_cursor
+      @presentation.slides.each_with_index do |slide, i|
+        pdf_path = File.join(dir, format("slide-%04d.pdf", i))
+        @renderer.render(slide, current: i, total: @presentation.total)
+        request_capture(pdf_path)
+        wait_for_capture(pdf_path)
+        paths << pdf_path
+      end
+      paths
+    ensure
+      @terminal.write "#{OSC};bg-clear#{BEL}"
+      @terminal.show_cursor
+      @terminal.leave_alt_screen
+      @terminal.flush
+    end
+
+    def request_capture(path)
+      @terminal.write "#{OSC};capture;#{path}#{BEL}"
+      @terminal.flush
+    end
+
+    def wait_for_capture(path)
+      deadline = Time.now + CAPTURE_TIMEOUT
+      until File.exist?(path) && File.size?(path).to_i.positive?
+        if Time.now > deadline
+          raise "Capture timed out for #{path}. " \
+                "Is Echoes running and recent enough to honor OSC 7772 `capture` to a .pdf path?"
+        end
+        sleep POLL_INTERVAL
+      end
+      # Small grace period to ensure the PDF write is fully flushed.
+      sleep POLL_INTERVAL
+    end
+
+    def merge_pdfs(pdf_paths, output_path)
+      raise "No slides captured" if pdf_paths.empty?
+
+      output = HexaPDF::Document.new
+      pdf_paths.each do |path|
+        src = HexaPDF::Document.open(path)
+        src.pages.each do |page|
+          output.pages << output.import(page)
+        end
+      end
+      output.write(output_path)
+    end
+  end
+end

data/lib/przn/terminal.rb

@@ -4,6 +4,8 @@ require 'io/console'
 
 module Przn
   class Terminal
+    MOUSE_OFF = "\e[?1006l\e[?1003l\e[?1002l\e[?1000l"
+
     def initialize(input: $stdin, output: $stdout)
       @in = input
       @out = output
@@ -45,9 +47,11 @@ module Przn
 
     def enter_alt_screen
       write "\e[?1049h"
+      write MOUSE_OFF
     end
 
     def leave_alt_screen
+      write MOUSE_OFF
       write "\e[?1049l"
     end
 

data/lib/przn/theme.rb

@@ -6,7 +6,7 @@ module Przn
   class Theme
     DEFAULT_PATH = File.expand_path('../../../default_theme.yml', __FILE__)
 
-    attr_reader :colors, :font
+    attr_reader :colors, :font, :bullet, :background, :title
 
     def self.load(path)
       raise ArgumentError, "Theme file not found: #{path}" unless File.exist?(path)
@@ -16,6 +16,9 @@ module Przn
       merged = {
         colors: defaults[:colors].merge(overrides[:colors] || {}),
         font: defaults[:font].merge(overrides[:font] || {}),
+        bullet: defaults[:bullet].merge(overrides[:bullet] || {}),
+        background: defaults[:background].merge(overrides[:background] || {}),
+        title: defaults[:title].merge(overrides[:title] || {}),
       }
       new(merged)
     end
@@ -24,11 +27,23 @@ module Przn
       new(load_yaml(DEFAULT_PATH))
     end
 
+    # Look for a sibling `theme.yml` next to the given file and load it if
+    # present, so a deck can ship its theme alongside the markdown without
+    # the user having to pass `--theme` explicitly. Returns nil if no file
+    # is found.
+    def self.auto_discover(near:)
+      candidate = File.join(File.dirname(File.expand_path(near)), 'theme.yml')
+      File.exist?(candidate) ? load(candidate) : nil
+    end
+
     def self.load_yaml(path)
       data = YAML.safe_load_file(path, symbolize_names: true) || {}
       {
         colors: data[:colors] || {},
         font: data[:font] || {},
+        bullet: (data[:bullet] || {}).compact,
+        background: (data[:background] || {}).compact,
+        title: (data[:title] || {}).compact,
       }
     end
     private_class_method :load_yaml
@@ -36,6 +51,9 @@ module Przn
     def initialize(config)
       @colors = config[:colors]
       @font = config[:font]
+      @bullet = config[:bullet]
+      @background = config[:background]
+      @title = config[:title]
     end
   end
 end

data/lib/przn/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Przn
-  VERSION = "0.1.6"
+  VERSION = "0.3.0"
 end