jekyll-slides 0.1.0 → 0.3.0

data/doc/README.md

@@ -59,6 +59,62 @@ class: keynote
 -->
 ```
 
+## Deck folders
+
+A deck can also be a folder of Markdown files, one file per slide, instead of one file with `---` separators:
+
+```
+talks/my-talk/
+  index.md          # deck front matter, opts in with `slides: true`
+  01-title.md
+  02-the-idea.md
+  03-code.md
+  diagram.png        # ordinary static file, untouched
+```
+
+The entry file must be named `index.md` and carry the deck's front matter, `layout: presentation`, and `slides: true`:
+
+```yaml
+# talks/my-talk/index.md
+---
+layout: presentation
+title: My talk
+slides: true
+---
+```
+
+`slides: true` discovers every other Markdown file that is a direct child of the folder (not recursive), skipping names starting with `_` or `.`, and skipping anything Jekyll itself withholds: a file dropped by the site's `exclude:` setting, or one whose front matter sets `published: false`. Naming a withheld file in an explicit list warns and skips it too, so a deck never publishes content the site holds back. Files are ordered by a natural sort of the filename: digit runs compare numerically and sort before letters, so `01-title.md`, `02-the-idea.md`, `10-outro.md`, then any file with no numeric prefix, sorted alphabetically. Each file holds one slide, or several separated by `---`, exactly as in a single-file deck. Body content in `index.md`, if any, becomes the deck's leading slides.
+
+A slide file can carry its own YAML front matter with `layout`, `background`, and `class`, as an alternative to the `<!-- ... -->` comment:
+
+```markdown
+---
+layout: statement
+background: spotlight
+---
+# A bold claim
+```
+
+Front matter in the file applies to every slide it holds; a slide's own comment overrides it key by key.
+
+Set `slides:` to a list instead of `true` to turn the entry file into a readable running order, in presentation order:
+
+```yaml
+---
+layout: presentation
+title: My talk
+slides:
+  - 01-title.md
+  - 02-the-idea.md
+  # - 03-detour.md
+  - 04-code.md
+---
+```
+
+Cutting a slide for a shorter time slot is commenting out one line, not moving a file out of the folder.
+
+`slides:` is what opts a folder in. Opting in absorbs the whole folder: every Markdown file it absorbs is removed from the site's pages, collection documents, and static files, so none of them is ever published on its own. This holds even for a file commented out of an explicit list; the list controls order and inclusion in the deck, not what gets absorbed. Without `slides:`, a folder holding an `index.md` presentation behaves exactly as it does today, and sibling files are left alone. This matters if the site applies `layout: presentation` through a broad `defaults:` rule, since that alone never triggers absorption.
+
 ## Editors and terminals
 
 Put a kramdown inline attribute list immediately after a fenced block. Attribute values must be quoted; class and ID tokens such as `.editor` and `#order-total` do not need quotes. `.editor` renders a syntax-highlighted editor window; `.terminal` renders a terminal window.
@@ -80,7 +136,7 @@ ruby 3.4.1
 {: .terminal #ruby-version title="terminal" size="sm"}
 ````
 
-Editor/terminal attributes are `title`, `id` (or `#id`), `size` (`sm`, `md`, `lg`), `line_numbers` (`true`/`false`), `focus`, and `highlight`. Ranges accept comma-separated lines and ranges such as `2,4-6,9`; invalid values fall back safely with a Jekyll warning. Terminal prompts beginning with `$ `, `> `, or `❯ ` are styled separately. Source remains server-rendered and copyable.
+Editor/terminal attributes are `title`, `id` (or `#id`), `size` (`sm`, `md`, `lg`), `theme`, `line_numbers` (`true`/`false`), `focus`, and `highlight`. Ranges accept comma-separated lines and ranges such as `2,4-6,9`; invalid values fall back safely with a Jekyll warning. Terminal prompts beginning with `$ `, `> `, or `❯ ` are styled separately. Source remains server-rendered and copyable.
 
 Long editor and terminal blocks scroll within the slide. Blocks over 20 lines produce an advisory build warning; the amount that fits depends on the layout and font size. Split long examples across slides for print, where scrolling is unavailable.
 
@@ -90,7 +146,7 @@ Code remains selectable and copyable with normal browser controls; version 0.1 d
 
 ## Themes and configuration
 
-Presentation themes are `minimal-light`, `minimal-dark`, `midnight` (the default), and `ruby`. These style the slides without replacing the site's Jekyll theme. Configure defaults under `slides:`:
+Presentation themes are `minimal-light`, `minimal-dark`, `midnight` (the default), `ruby`, and the four Catppuccin flavors `catppuccin-latte`, `catppuccin-frappe`, `catppuccin-macchiato`, and `catppuccin-mocha`. These style the slides without replacing the site's Jekyll theme. Configure defaults under `slides:`:
 
 ```yaml
 slides:
@@ -106,11 +162,31 @@ The same keys can be overridden per presentation in front matter (`theme`, `aspe
 
 For a light presentation, set `slides: { theme: minimal-light }` in `_config.yml`, or `theme: minimal-light` in the deck's front matter. The [readability example](https://github.com/lucianghinda/jekyll-slides/blob/main/examples/readability.md) demonstrates the light theme with code, terminal output, tables, and prose.
 
+### Terminal themes
+
+The Catppuccin flavors are ported from the palette shared by [catppuccin/ghostty](https://github.com/catppuccin/ghostty). Hues are the published values; lightness is adjusted only where a token cannot otherwise clear the 4.5:1 contrast the project checks on every code surface. Latte, the light flavor, needed the most adjustment.
+
+Any theme also works on a single editor or terminal block through a `theme` attribute, so one window can carry a different palette from the deck around it:
+
+````markdown
+```console
+$ ghostty --version
+ghostty 1.0.1
+```
+{: .terminal title="ghostty" theme="catppuccin-latte"}
+````
+
+The override repaints that window completely: surface, title bar, syntax colors, prompt, and body text. Everything outside it keeps the deck theme. An unknown name warns during the build and falls back to the deck theme. The [terminal themes example](https://github.com/lucianghinda/jekyll-slides/blob/main/examples/terminal-themes.md) shows a deck-wide flavor next to per-window overrides.
+
+### Window chrome
+
+Editors and terminals render the same macOS-style title bar: traffic lights on the left, the `title` centered in the bar, and for editors the language on the right. The traffic lights keep the macOS red, amber, and green in every theme, the way a real title bar does; only the window surface follows the theme. Bar height, control size, and spacing scale with the component `size`.
+
 ## Typography and readability
 
 The gem bundles Atkinson Hyperlegible Next for text and Atkinson Hyperlegible Mono for code, including variable upright and italic faces. Fonts load from the site's own assets and work offline. The font files retain their SIL Open Font License; source revisions, checksums, and notices are in [assets/fonts](https://github.com/lucianghinda/jekyll-slides/blob/main/assets/fonts/README.md).
 
-On the 1920×1080 slide canvas, body text is 44px, section headings are 72px, and code sizes `sm`, `md`, and `lg` are 32px, 38px, and 42px. These sizes scale with the slide. Filenames and line numbers remain readable, and focused lines use borders and background color while keeping surrounding code fully visible. All four themes check syntax-token contrast against normal, highlighted, and focused code surfaces.
+On the 1920×1080 slide canvas, body text is 44px, section headings are 72px, and code sizes `sm`, `md`, and `lg` are 32px, 38px, and 42px. These sizes scale with the slide. Filenames and line numbers remain readable, and focused lines use borders and background color while keeping surrounding code fully visible. All eight themes check syntax-token contrast against normal, highlighted, and focused code surfaces, both deck-wide and as a single-window override.
 
 Prefer medium or large code and short examples for projection. Long blocks can scroll, but an audience cannot reveal hidden lines independently; split examples when presenting or printing. Screen contrast tests do not replace checking the actual projector and viewing distance.
 
@@ -151,7 +227,7 @@ bundle exec rake docs
 ```
 
 This replaces `doc/` with fresh YARD Markdown, updates the documentation index in
-`doc/Jekyll/Slides.md`, and writes `llm.txt` with links relative to the gem root.
+`doc/Jekyll/Slides.md`, and writes `llms.txt` with links relative to the gem root.
 The generated files are checked in and shipped with the gem. Internal plans,
 temporary files, and Node dependencies are excluded. YARD and `yard-markdown`
 are development tools only.

data/doc/index.csv

@@ -5,27 +5,44 @@ Jekyll,Module,Jekyll.md
 Jekyll::Slides,Module,Jekyll/Slides.md
 Jekyll::Slides.ROOT,Constant,Jekyll/Slides.md#constant-ROOT
 Jekyll::Slides.LAYOUT_NAME,Constant,Jekyll/Slides.md#constant-LAYOUT_NAME
+Jekyll::Slides.THEMES,Constant,Jekyll/Slides.md#constant-THEMES
+Jekyll::Slides.DEFAULT_THEME,Constant,Jekyll/Slides.md#constant-DEFAULT_THEME
 Jekyll::Slides.VERSION,Constant,Jekyll/Slides.md#constant-VERSION
 Jekyll::Slides::Assets,Module,Jekyll/Slides/Assets.md
 Jekyll::Slides::Assets.asset_files,Method,Jekyll/Slides/Assets.md#method-c-asset_files
 Jekyll::Slides::Assets.install,Method,Jekyll/Slides/Assets.md#method-c-install
 Jekyll::Slides::Support,Module,Jekyll/Slides/Support.md
 Jekyll::Slides::Support.escape,Method,Jekyll/Slides/Support.md#method-c-escape
+Jekyll::Slides::Support.natural_sort_key,Method,Jekyll/Slides/Support.md#method-c-natural_sort_key
 Jekyll::Slides::Support.warn,Method,Jekyll/Slides/Support.md#method-c-warn
+Jekyll::Slides::FrontMatter,Module,Jekyll/Slides/FrontMatter.md
+Jekyll::Slides::FrontMatter.parse,Method,Jekyll/Slides/FrontMatter.md#method-c-parse
+Jekyll::Slides::FrontMatter.split,Method,Jekyll/Slides/FrontMatter.md#method-c-split
+Jekyll::Slides::DeckAssembler,Module,Jekyll/Slides/DeckAssembler.md
+Jekyll::Slides::DeckAssembler.assemble,Method,Jekyll/Slides/DeckAssembler.md#method-c-assemble
 Jekyll::Slides::JekyllIntegration,Module,Jekyll/Slides/JekyllIntegration.md
 Jekyll::Slides::JekyllIntegration.DEFAULTS,Constant,Jekyll/Slides/JekyllIntegration.md#constant-DEFAULTS
-Jekyll::Slides::JekyllIntegration.THEMES,Constant,Jekyll/Slides/JekyllIntegration.md#constant-THEMES
 Jekyll::Slides::JekyllIntegration.BOOLEAN_OPTIONS,Constant,Jekyll/Slides/JekyllIntegration.md#constant-BOOLEAN_OPTIONS
 Jekyll::Slides::JekyllIntegration.OPTION_KEYS,Constant,Jekyll/Slides/JekyllIntegration.md#constant-OPTION_KEYS
 Jekyll::Slides::JekyllIntegration.install!,Method,Jekyll/Slides/JekyllIntegration.md#method-c-install-21
 Jekyll::Slides::JekyllIntegration.process,Method,Jekyll/Slides/JekyllIntegration.md#method-c-process
 Jekyll::Slides::JekyllIntegration.process_site,Method,Jekyll/Slides/JekyllIntegration.md#method-c-process_site
+Jekyll::Slides::Deck,Class,Jekyll/Slides/Deck.md
+Jekyll::Slides::Deck.OPTION_KEYS,Constant,Jekyll/Slides/Deck.md#constant-OPTION_KEYS
+Jekyll::Slides::Deck.consumed_paths,Method,Jekyll/Slides/Deck.md#method-i-consumed_paths
+Jekyll::Slides::Deck.content,Method,Jekyll/Slides/Deck.md#method-i-content
+Jekyll::Slides::Deck.deck?,Method,Jekyll/Slides/Deck.md#method-i-deck-3F
+Jekyll::Slides::Deck.initialize,Method,Jekyll/Slides/Deck.md#method-i-initialize
+Jekyll::Slides::Deck.slide_paths,Method,Jekyll/Slides/Deck.md#method-i-slide_paths
 Jekyll::Slides::Assets::SiteAssetFile,Class,Jekyll/Slides/Assets/SiteAssetFile.md
 Jekyll::Slides::Assets::SiteAssetFile.write,Method,Jekyll/Slides/Assets/SiteAssetFile.md#method-i-write
 Jekyll::Slides::Layout,Class,Jekyll/Slides/Layout.md
 Jekyll::Slides::Layout.initialize,Method,Jekyll/Slides/Layout.md#method-i-initialize
 Jekyll::Slides::Renderer,Class,Jekyll/Slides/Renderer.md
 Jekyll::Slides::Renderer.convert,Method,Jekyll/Slides/Renderer.md#method-i-convert
+Jekyll::Slides::SlideFile,Class,Jekyll/Slides/SlideFile.md
+Jekyll::Slides::SlideFile.initialize,Method,Jekyll/Slides/SlideFile.md#method-i-initialize
+Jekyll::Slides::SlideFile.slides,Method,Jekyll/Slides/SlideFile.md#method-i-slides
 Jekyll::Slides::Presentation,Class,Jekyll/Slides/Presentation.md
 Jekyll::Slides::Presentation.initialize,Method,Jekyll/Slides/Presentation.md#method-i-initialize
 Jekyll::Slides::Presentation.render,Method,Jekyll/Slides/Presentation.md#method-i-render
@@ -45,6 +62,7 @@ Jekyll::Slides::SlideMetadata.KEYS,Constant,Jekyll/Slides/SlideMetadata.md#const
 Jekyll::Slides::SlideMetadata.initialize,Method,Jekyll/Slides/SlideMetadata.md#method-i-initialize
 Jekyll::Slides::SlideMetadata.parse,Method,Jekyll/Slides/SlideMetadata.md#method-i-parse
 Jekyll::Slides::SlideMetadata.parse,Method,Jekyll/Slides/SlideMetadata.md#method-c-parse
+Jekyll::Slides::SlideMetadata.split_comment,Method,Jekyll/Slides/SlideMetadata.md#method-c-split_comment
 Jekyll::Slides::SlideMetadata.background,Attribute,Jekyll/Slides/SlideMetadata.md#attribute-i-background
 Jekyll::Slides::SlideMetadata.content,Attribute,Jekyll/Slides/SlideMetadata.md#attribute-i-content
 Jekyll::Slides::SlideMetadata.custom_class,Attribute,Jekyll/Slides/SlideMetadata.md#attribute-i-custom_class

data/lib/jekyll/slides/component_renderer.rb

@@ -165,9 +165,8 @@ module Jekyll
         line_numbers = line_numbers?(attrs.fetch("line_numbers", "true"))
         classes = ["code-window", "size-#{size}"] + attrs[:classes].reject { |name| name == "editor" }
         classes << "has-focus" unless focus.empty?
-        attributes = html_attributes(class: classes.join(" "), id: attrs[:id])
-        header = +'<header class="code-window-header"><span class="code-window-controls" aria-hidden="true"><i></i><i></i><i></i></span>'
-        header << %(<span class="code-window-language">#{Support.escape(language)}</span></header>)
+        attributes = window_attributes(classes, attrs)
+        header = window_header(language: language)
         caption = attrs["title"] ? %(<figcaption>#{Support.escape(attrs['title'])}</figcaption>) : ""
         source = lines.map { |line, newline| line + newline }.join
         highlighted = @rouge_renderer.render_lines(source, language)
@@ -187,7 +186,7 @@ module Jekyll
       def render_terminal(lines, attrs)
         size = normalize_size(attrs["size"])
         classes = ["terminal-window", "size-#{size}"] + attrs[:classes].reject { |name| name == "terminal" }
-        figure_attrs = html_attributes(class: classes.join(" "), id: attrs[:id])
+        figure_attrs = window_attributes(classes, attrs)
         caption = attrs["title"] ? %(<figcaption>#{Support.escape(attrs['title'])}</figcaption>) : ""
         body = lines.map do |line, newline|
           visible = Support.escape(line)
@@ -198,7 +197,36 @@ module Jekyll
           end
           %(<span class="tline">#{visible}#{Support.escape(newline)}</span>)
         end.join
-        %(<figure#{figure_attrs}>#{caption}<pre><code>#{body}</code></pre></figure>)
+        %(<figure#{figure_attrs}>#{caption}#{window_header}<pre><code>#{body}</code></pre></figure>)
+      end
+
+      # The macOS-style title bar both window types share: traffic lights on
+      # the left, and for editors the language on the right. The centered title
+      # is the figure's own caption, which stays a direct child of the figure so
+      # the markup remains a valid figure/figcaption pair.
+      def window_header(language: nil)
+        header = +'<header class="code-window-header"><span class="code-window-controls" aria-hidden="true"><i></i><i></i><i></i></span>'
+        header << %(<span class="code-window-language">#{Support.escape(language)}</span>) if language
+        header << "</header>"
+      end
+
+      def window_attributes(classes, attrs)
+        html_attributes(
+          "class" => classes.join(" "),
+          "id" => attrs[:id],
+          "data-code-theme" => component_theme(attrs["theme"])
+        )
+      end
+
+      # A component may carry any deck theme, so one window can show a light
+      # terminal inside a dark deck. Returns nil to inherit the deck theme.
+      def component_theme(value)
+        return nil if value.nil? || value.to_s.empty?
+        return value.to_s if THEMES.include?(value.to_s)
+
+        Support.warn(@warning, "Unsupported component theme #{value.inspect}; expected one of #{THEMES.join(', ')}; " \
+                               "using the deck theme")
+        nil
       end
 
       def line_range(value, max_line: nil)

data/lib/jekyll/slides/deck.rb

@@ -0,0 +1,151 @@
+# frozen_string_literal: true
+
+module Jekyll
+  module Slides
+    # Represents one folder deck: an entry file plus the slide files a
+    # directory holds. Reads slide files from disk and assembles them, with
+    # the entry body, into one Markdown string ready for the existing
+    # +PresentationParser+ pipeline. Knows nothing about Jekyll page objects.
+    class Deck
+      # Top-level presentation options an author might mistakenly nest under
+      # +slides:+ instead of setting directly in front matter.
+      OPTION_KEYS = %w[theme progress slide_numbers overview fullscreen aspect_ratio].freeze
+
+      # rubocop:disable Metrics/ParameterLists -- this exact keyword set is the deck's public
+      # construction contract; the Jekyll integration layer wires it verbatim.
+      def initialize(directory:, entry_path:, entry_body:, slides:, markdown_extensions:, warning: nil, read_options: {}, published: nil)
+        @directory = directory
+        @entry_path = File.expand_path(entry_path)
+        @entry_body = entry_body.to_s
+        @slides_option = slides
+        @markdown_extensions = Array(markdown_extensions).map { |ext| ext.to_s.downcase }
+        @warning = warning
+        @read_options = read_options
+        @published = published
+        @deck = resolve_deck?
+      end
+      # rubocop:enable Metrics/ParameterLists
+
+      def deck?
+        @deck
+      end
+
+      # The ordered slide file paths that make up +content+: the explicit
+      # list in list order when +slides:+ names one, otherwise every
+      # discovered file in natural order.
+      def slide_paths
+        @slide_paths ||= deck? ? resolve_slide_paths : []
+      end
+
+      # Every slide file the deck folder absorbs, so none is published on
+      # its own: every discovered direct child, plus any explicitly listed
+      # path (which may live in a subfolder). Order is not meaningful; this
+      # is a set for pruning, not the render order. Identical to
+      # +slide_paths+ when +slides:+ is +true+.
+      def consumed_paths
+        @consumed_paths ||= deck? ? resolve_consumed_paths : []
+      end
+
+      def content
+        parts = []
+        parts << @entry_body unless blank?(@entry_body)
+        parts.concat(slide_files.flat_map(&:slides))
+        parts.join("\n\n---\n\n")
+      end
+
+      private
+
+      def blank?(text)
+        text.to_s.strip.empty?
+      end
+
+      def slide_files
+        @slide_files ||= slide_paths.map { |path| SlideFile.new(path, warning: @warning, read_options: @read_options) }
+      end
+
+      def resolve_deck?
+        case @slides_option
+        when true, Array
+          true
+        when false, nil
+          false
+        when Hash
+          Support.warn(@warning, "Invalid slides value #{@slides_option.inspect}; set the top-level slides options " \
+                                 "(#{OPTION_KEYS.join(', ')}) directly instead of nesting them under slides:; " \
+                                 "treating as a single-file deck")
+          false
+        else
+          Support.warn(@warning, "Invalid slides value #{@slides_option.inspect}; expected true, false, or a list of " \
+                                 "file names; treating as a single-file deck")
+          false
+        end
+      end
+
+      def resolve_slide_paths
+        @slides_option == true ? discover_slide_paths : explicit_slide_paths
+      end
+
+      def resolve_consumed_paths
+        paths = discover_slide_paths
+        @slides_option.is_a?(Array) ? paths | explicit_slide_paths : paths
+      end
+
+      def discover_slide_paths
+        paths = Dir.children(@directory).each_with_object([]) do |basename, found|
+          next if basename.start_with?("_", ".")
+
+          path = File.join(@directory, basename)
+          next unless File.file?(path)
+          next unless markdown_extension?(basename)
+          next if File.expand_path(path) == @entry_path
+          next unless published?(path)
+
+          found << path
+        end
+        paths.sort_by { |path| Support.natural_sort_key(File.basename(path)) }
+      end
+
+      def markdown_extension?(basename)
+        @markdown_extensions.include?(File.extname(basename).delete_prefix(".").downcase)
+      end
+
+      # Memoized because both the rendering set and the pruning set ask for
+      # it, and resolve warns about missing or out-of-bounds names.
+      def explicit_slide_paths
+        @explicit_slide_paths ||= @slides_option.filter_map { |name| resolve(name) }
+      end
+
+      def resolve(name)
+        root = File.expand_path(@directory) + File::SEPARATOR
+        path = File.expand_path(File.join(@directory, name.to_s))
+        unless path.start_with?(root)
+          Support.warn(@warning, "Slide file #{name.inspect} escapes the deck directory; ignoring")
+          return nil
+        end
+        if path == @entry_path
+          Support.warn(@warning, "Slide file #{name.inspect} is the deck entry itself; ignoring")
+          return nil
+        end
+        unless File.file?(path)
+          Support.warn(@warning, "Slide file #{name.inspect} does not exist; ignoring")
+          return nil
+        end
+        unless published?(path)
+          Support.warn(@warning, "Slide file #{name.inspect} is excluded or not published; ignoring")
+          return nil
+        end
+        path
+      end
+
+      # Discovery reads the folder straight from disk, which bypasses the
+      # filtering Jekyll already applied: files its exclude: config drops and
+      # files whose front matter sets published: false are never read. Absorbing
+      # one would publish content the author withheld, inside the deck.
+      def published?(path)
+        return true unless @published
+
+        @published.call(File.expand_path(path))
+      end
+    end
+  end
+end

data/lib/jekyll/slides/deck_assembler.rb

@@ -0,0 +1,147 @@
+# frozen_string_literal: true
+
+require "pathname"
+require "set"
+
+module Jekyll
+  module Slides
+    # Finds folder-deck entries across a site's pages and output-collection
+    # documents, assembles each into one Markdown string via +Deck+, and
+    # prunes the slide files it consumed so they never appear in the built
+    # site. Runs once per site, inside the +:site, :post_read+ hook, before
+    # Liquid rendering and before +JekyllIntegration.process+ computes
+    # +slides_count+.
+    module DeckAssembler
+      class << self
+        # Assembles every folder deck the site's pages and output-collection
+        # documents opt into. Mutates +site.pages+, each collection's
+        # +docs+, and +site.static_files+ in place to remove consumed slide
+        # files.
+        def assemble(site)
+          published = published_paths(site)
+          entry_candidates(site).each { |entry| assemble_entry(site, entry, published) }
+        end
+
+        private
+
+        # Every source path Jekyll actually read. A file its exclude: config
+        # drops, or one whose front matter sets published: false, is absent
+        # here, and a deck must not absorb it. Snapshotted before any pruning,
+        # since pruning removes the very items this is built from.
+        def published_paths(site)
+          items = site.pages + site.collections.values.flat_map(&:docs) + site.static_files
+          items.to_set { |item| absolute_path(site, item) }
+        end
+
+        def entry_candidates(site)
+          collection_documents = site.collections.values.flat_map(&:docs)
+          site.pages + collection_documents
+        end
+
+        def assemble_entry(site, entry, published)
+          return unless presentation_entry?(entry)
+
+          slides_option = entry.data["slides"]
+          return unless slides_option
+
+          entry_path = absolute_path(site, entry)
+          unless index_entry?(entry_path, markdown_extensions(site))
+            warn_entry(site, entry_path, "the entry of a deck folder must be named index.<ext>; leaving as a single-file deck")
+            return
+          end
+
+          finish_assembly(site, entry, entry_path, build_deck(site, entry, entry_path, published))
+        end
+
+        def finish_assembly(site, entry, entry_path, deck)
+          return unless deck.deck?
+
+          entry.content = deck.content
+          # Pruning does not depend on anything being selected. Opting in
+          # absorbs the whole folder, so a file left out of an explicit
+          # running order is cut from the deck rather than published alone.
+          prune(site, deck.consumed_paths)
+          register_dependencies(site, entry_path, deck.slide_paths)
+          log_deck(site, entry_path, deck.slide_paths) unless deck.slide_paths.empty?
+        end
+
+        def presentation_entry?(entry)
+          entry.respond_to?(:data) && entry.data.is_a?(Hash) && entry.data["layout"].to_s == "presentation"
+        end
+
+        def markdown_extensions(site)
+          site.config["markdown_ext"].to_s.split(",")
+        end
+
+        def index_entry?(path, extensions)
+          basename = File.basename(path)
+          extname = File.extname(basename)
+          return false if extname.empty?
+
+          base = basename.delete_suffix(extname)
+          ext = extname.delete_prefix(".").downcase
+          base.casecmp("index").zero? && extensions.any? { |candidate| candidate.to_s.downcase == ext }
+        end
+
+        def build_deck(site, entry, entry_path, published)
+          Deck.new(
+            directory: File.dirname(entry_path),
+            entry_path: entry_path,
+            entry_body: entry.content,
+            slides: entry.data["slides"],
+            markdown_extensions: markdown_extensions(site),
+            warning: ->(message) { warn_entry(site, entry_path, message) },
+            read_options: Jekyll::Utils.merged_file_read_opts(site, {}),
+            published: ->(path) { published.include?(path) }
+          )
+        end
+
+        # Removes every consumed slide file from site.pages, each
+        # collection's docs, and site.static_files, matching on absolute
+        # source path. A Markdown file with no front matter is read by
+        # Jekyll as a StaticFile rather than a Page, so pruning static
+        # files is required, not optional.
+        def prune(site, paths)
+          return if paths.empty?
+
+          consumed = paths.map { |path| File.expand_path(path) }
+          site.pages.reject! { |page| consumed.include?(absolute_path(site, page)) }
+          site.collections.each_value do |collection|
+            collection.docs.reject! { |doc| consumed.include?(absolute_path(site, doc)) }
+          end
+          site.static_files.reject! { |file| consumed.include?(absolute_path(site, file)) }
+        end
+
+        def register_dependencies(site, entry_path, slide_paths)
+          return unless site.respond_to?(:regenerator) && site.regenerator.respond_to?(:add_dependency)
+
+          slide_paths.each { |path| site.regenerator.add_dependency(entry_path, path) }
+        end
+
+        def log_deck(site, entry_path, slide_paths)
+          basenames = slide_paths.map { |path| File.basename(path) }
+          Jekyll.logger.info(
+            "Jekyll Slides:",
+            "#{relative_path(site, entry_path)}: #{slide_paths.length} slide files (#{basenames.join(', ')})"
+          )
+        end
+
+        def warn_entry(site, entry_path, message)
+          Jekyll.logger.warn("Jekyll Slides:", "#{relative_path(site, entry_path)}: #{message}")
+        end
+
+        # Jekyll::Page#path is relative to the source; Jekyll::Document#path
+        # and Jekyll::StaticFile#path are already absolute. expand_path
+        # handles all three, since it ignores the base for a path that is
+        # already absolute.
+        def absolute_path(site, item)
+          File.expand_path(item.path.to_s, site.source)
+        end
+
+        def relative_path(site, path)
+          Pathname.new(path).relative_path_from(Pathname.new(site.source)).to_s
+        end
+      end
+    end
+  end
+end

data/lib/jekyll/slides/front_matter.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require "yaml"
+require "date"
+
+module Jekyll
+  module Slides
+    # Splits a leading YAML front matter block off a Markdown source string.
+    module FrontMatter
+      module_function
+
+      # Returns [values, body]. +values+ is a Hash for a well-formed leading
+      # +---+ block; otherwise +values+ is {} and +body+ is +source+ unchanged.
+      def split(source)
+        source = source.to_s
+        return [{}, source] unless source.start_with?("---\n", "---\r\n")
+
+        lines = source.lines
+        closing = lines[1..]&.index { |line| line.chomp == "---" }
+        return [{}, source] unless closing
+
+        closing += 1
+        values = parse(lines[1...closing].join)
+        return [{}, source] unless values
+
+        [values, lines[(closing + 1)..]&.join.to_s]
+      end
+
+      def parse(text)
+        return {} if text.strip.empty?
+
+        parsed = YAML.safe_load(text, permitted_classes: [Date, Time, DateTime])
+        parsed.is_a?(Hash) ? parsed : nil
+      rescue Psych::Exception
+        nil
+      end
+    end
+  end
+end

data/lib/jekyll/slides/jekyll_integration.rb

@@ -6,14 +6,13 @@ module Jekyll
   module Slides
     module JekyllIntegration
       DEFAULTS = {
-        "theme" => "midnight",
+        "theme" => DEFAULT_THEME,
         "aspect_ratio" => "16:9",
         "progress" => true,
         "slide_numbers" => true,
         "overview" => true,
         "fullscreen" => true
       }.freeze
-      THEMES = %w[minimal-light minimal-dark midnight ruby].freeze
       BOOLEAN_OPTIONS = %w[progress slide_numbers overview fullscreen].freeze
       OPTION_KEYS = DEFAULTS.keys.freeze
 
@@ -29,6 +28,7 @@ module Jekyll
 
         def process_site(site)
           install_resources(site)
+          DeckAssembler.assemble(site)
           presentation_documents(site).each { |document| process(document) }
         end
 
@@ -84,7 +84,7 @@ module Jekyll
             theme = value.to_s
             return theme if THEMES.include?(theme)
 
-            warning("Invalid theme #{value.inspect}; falling back to midnight")
+            warning("Invalid theme #{value.inspect}; expected one of #{THEMES.join(', ')}; falling back to #{DEFAULT_THEME}")
             DEFAULTS[key]
           when "aspect_ratio"
             return value if value == DEFAULTS[key]

data/lib/jekyll/slides/renderer.rb

@@ -4,6 +4,20 @@ module Jekyll
   module Slides
     class Renderer < Jekyll::Renderer
       def convert(content)
+        # Liquid has already run by the time this fires (Jekyll::Renderer#run
+        # converts before place_in_layouts), so this is the true slide
+        # count, including slides a {% for %} loop generated.
+        #
+        # document.data alone is not enough: a Document reaches the layout
+        # through a live DocumentDrop that reads document.data on every
+        # access, so writing it here is enough. A Page reaches the layout
+        # through a plain Hash snapshot that Jekyll::Renderer#assign_pages!
+        # already built and stashed in payload["page"] before convert runs,
+        # so a Page's layout would keep seeing the old, pre-Liquid count
+        # unless payload["page"] itself is updated too.
+        count = PresentationParser.new(content).parse.length
+        document.data["slides_count"] = count
+        payload["page"]["slides_count"] = count
         Presentation.new(
           content,
           warning: method(:warning),