html2rss 0.32.4 → 0.34.0

data/lib/html2rss/html/article_extractor.rb

@@ -14,11 +14,10 @@ module Html2rss
         # @param article_tag [Nokogiri::XML::Node] article-like container to extract from
         # @param base_url [String, Html2rss::Url] base url used to resolve relative links
         # @param selected_anchor [Nokogiri::XML::Node, nil] explicit primary anchor for the container
-        # @param fallback_anchorless [Boolean] whether to fall back to anchorless extraction
         # @param time_zone [String] channel time zone for naive leftover dates
         # @return [Hash{Symbol => Object}] extracted article attributes
-        def call(article_tag, base_url:, selected_anchor: nil, fallback_anchorless: false, time_zone: 'UTC')
-          new(article_tag, base_url:, selected_anchor:, fallback_anchorless:, time_zone:).call
+        def call(article_tag, base_url:, selected_anchor: nil, time_zone: 'UTC')
+          new(article_tag, base_url:, selected_anchor:, time_zone:).call
         end
       end
 
@@ -26,26 +25,26 @@ module Html2rss
       # @param article_tag [Nokogiri::XML::Node] article-like container to extract from
       # @param base_url [String, Html2rss::Url] base url used to resolve relative links
       # @param selected_anchor [Nokogiri::XML::Node, nil] explicit primary anchor for the container
-      # @param fallback_anchorless [Boolean] whether to fall back to anchorless extraction
       # @param time_zone [String] channel time zone for naive leftover dates
-      def initialize(article_tag, base_url:, selected_anchor: nil, fallback_anchorless: false, time_zone: 'UTC')
-        raise ArgumentError, 'article_tag is required' unless article_tag
+      def initialize(article_tag, base_url:, selected_anchor: nil, time_zone: 'UTC')
+        raise InvalidError, 'article_tag is required' unless article_tag
 
         @article_tag = article_tag
         @base_url = base_url
         @selected_anchor = selected_anchor
-        @fallback_anchorless = fallback_anchorless
         @time_zone = time_zone
       end
 
       # @return [Hash{Symbol => Object}] extracted article attributes
       def call # rubocop:disable Metrics/MethodLength
-        title = extract_title
+        title = extract_headline
         lines = leftover_lines
         published_at = extract_published_at(lines)
         source, lines, published_at = parent_card_fields(title, lines, published_at)
         {
-          title:,
+          # Composed here, not passed as a +kicker:+ key: Selectors' enhance merges keys one by one,
+          # so a separate kicker would prefix an explicitly selected title.
+          title: Article::Title.compose(title, kicker: title_pieces.kicker_text),
           url: extract_url,
           image: extract_image,
           description: ArticleRules::Description.from_lines(lines, title:),
@@ -63,55 +62,29 @@ module Html2rss
       def extract_url
         @extract_url ||= begin
           href = selected_anchor&.[]('href').to_s
-
-          if href.empty?
-            anchorless_url_fallback
-          else
-            Url.from_relative(href.split('#').first.strip, base_url)
-          end
+          Url.from_relative(href.split('#').first, base_url) unless href.empty?
         end
       end
 
-      def anchorless_url_fallback
-        return unless @fallback_anchorless
+      def extract_headline
+        return first_text_title unless headline_source
 
-        id = generate_id
-        Url.from_relative("##{id}", base_url) if id
+        title_pieces.headline_text(headline_source)
       end
 
-      # rubocop:disable-next Metrics/CyclomaticComplexity
-      def extract_title
-        source = heading || selected_anchor
-        title_text = source ? Navigator.extract_visible_text(source) : fallback_anchorless_title
-        return unless title_text
-
-        kicker = kicker_node ? Navigator.extract_visible_text(kicker_node).to_s.strip : nil
-        kicker && !kicker.empty? && !title_text.include?(kicker) ? "#{kicker}: #{title_text}" : title_text
-      end
-
-      def fallback_anchorless_title
-        return unless @fallback_anchorless && selected_anchor.nil?
+      # Kicker and headline text ({TitlePieces}) of this card.
+      def title_pieces = @title_pieces ||= TitlePieces.new(article_tag, headline_source, anchor: selected_anchor)
 
+      def first_text_title
         text_node = article_tag.xpath('.//text()').find { |t| !t.text.strip.empty? }
         text_node&.text&.strip
       end
 
       def heading
-        @heading ||= HeadingExtractor.call(
-          article_tag,
-          fallback_anchorless: @fallback_anchorless,
-          selected_anchor:
-        )
+        @heading ||= HeadingExtractor.call(article_tag, selected_anchor:)
       end
 
-      def kicker_node
-        @kicker_node ||= begin
-          selector = '[data-tb-kicker], [class*="kicker"], [class*="eyebrow"], ' \
-                     '[class*="pre-title"], [class*="pretitle"], [class*="overline"]'
-          node = article_tag.at_css(selector)
-          node && heading && (node == heading || Navigator.descendant_of?(node, heading)) ? nil : node
-        end
-      end
+      def headline_source = heading || selected_anchor
 
       def leftover_lines
         leftover_lines_from(article_tag)
@@ -124,7 +97,7 @@ module Html2rss
       end
 
       def leftover_exclude_nodes_for(node)
-        [heading, selected_anchor, kicker_node, *node.css('time')].compact
+        [heading, selected_anchor, title_pieces.kicker, *node.css('time')].compact
       end
 
       def heading_or_anchor_item?
@@ -186,8 +159,7 @@ module Html2rss
           article_tag,
           heading:,
           url: (selected_anchor ? extract_url : nil),
-          selected_anchor:,
-          fallback_anchorless: @fallback_anchorless
+          selected_anchor:
         )
       end
 

data/lib/html2rss/html/article_rules/category.rb

@@ -27,10 +27,10 @@ module Html2rss
           end
 
           ##
-          # @param class_attr [String, nil]
+          # @param class_names [Array<String>] individual class tokens
           # @return [Boolean]
-          def class_match?(class_attr)
-            class_attr.to_s.split(/\s+/).any? { |token| class_token_match?(token) }
+          def class_match?(class_names)
+            class_names.any? { |token| class_token_match?(token) }
           end
 
           ##

data/lib/html2rss/html/article_rules/description.rb

@@ -7,24 +7,15 @@ module Html2rss
       # Leftover visible-text keep/drop for article descriptions.
       # Split once on block newlines; Date and Category consume the same keepers.
       module Description
-        # CTA lines dropped by whole-line equality (case-insensitive).
-        CTA = Set['read more', 'learn more'].freeze
-        # Type-chip lines dropped when the whole leftover line is one of these.
-        TYPE_CHIPS = Set['news article', 'press release', 'news'].freeze
+        # Owner of the read-more vocabulary; a whole line that is one is chrome, not a dek.
+        TEXT_CLASSIFIER = LinkDestination::TextClassifier.new
+        private_constant :TEXT_CLASSIFIER
         # Listing section names that are chrome, not a dek.
         SECTION_NAMES = Set['press releases'].freeze
         # Skip date detection / DateTime.parse above this length.
         MAX_DATE_CHARS = 128
         # Optional type-chip / clock separators (ASCII/en/em dash, pipe, bullet).
         CHIP_SEPARATORS = [' - ', ' – ', ' — ', ' | ', ' • '].freeze
-        # Trailing clock plus optional AM/PM and one timezone/offset token (IANA, GMT/UTC offset, or abbrev).
-        CLOCK_ZONE = %r{
-          \A
-          \d{1,2}:\d{2}(?::\d{2})?
-          (?:\s*(?:AM|PM))?
-          (?:\s+(?:[A-Za-z]+(?:/[A-Za-z_]+)+|(?:GMT|UTC)[+-]\d{1,2}(?::\d{2})?|[A-Za-z]{2,5}))?
-          \z
-        }ix
         # Whole-line date shapes after normalize (ISO, numeric, day-month, month-day).
         DATE_SHAPES = [
           /\A\d{4}-\d{1,2}-\d{1,2}(?:[T ]\d{1,2}:\d{2}(?::\d{2})?(?:\.\d+)?(?:Z|[+-]\d{2}:?\d{2})?)?\z/i,
@@ -100,13 +91,13 @@ module Html2rss
             nil
           end
 
-          def type_chip?(text) = TYPE_CHIPS.include?(text.downcase)
+          def type_chip?(text) = Article::Title::TYPE_MARKERS.include?(text.downcase)
 
-          def clock_zone?(text) = text.match?(CLOCK_ZONE)
+          def clock_zone?(text) = Article::Title.clock_piece?(text)
 
           def chrome?(normalized, title:, type_chips:)
             key = normalized.downcase
-            CTA.include?(key) || (type_chips && TYPE_CHIPS.include?(key)) ||
+            TEXT_CLASSIFIER.read_more?(normalized) || (type_chips && Article::Title::TYPE_MARKERS.include?(key)) ||
               SECTION_NAMES.include?(key) || normalized.end_with?(':') ||
               date_shaped?(normalized) || title_echo?(key, title)
           end

data/lib/html2rss/html/article_rules/enclosure.rb

@@ -4,66 +4,94 @@ module Html2rss
   module Html
     module ArticleRules
       ##
-      # DOM-agnostic enclosure URL/type normalization.
+      # The one rule for which HTML elements become enclosures, and their URL/type normalization.
+      #
+      # DOM-agnostic: {ArticleExtractor::EnclosureExtractor} (Nokogiri) and {SstArticleExtractor} (SST)
+      # only visit {ELEMENT_NAMES}, adapt their node API to {.from_element} and pass the result through
+      # {.unique}. Images (+img[src]+), players (+audio[src]+, +video[src]+), a player's +source[src]+ with
+      # its +type+, and file links ({FILE_LINK}) qualify; an +iframe+ (embed player page) never does,
+      # and only an http(s) URL is one (no +data:+, +blob:+, +javascript:+ or +mailto:+).
       module Enclosure
-        # Href path suffixes treated as download/archive enclosure links.
-        ARCHIVE_HREF_SUFFIXES = %w[.pdf .zip .tar.gz .tgz].freeze
+        # A link to a file: its path (before any query or fragment) ends, in any case, in a downloadable
+        # document or archive extension (+.pdf+, +.zip+, +.tar.gz+, +.tgz+) or an audio or video one
+        # ({Article::Enclosure::MEDIA_TYPES}, which also types it), such as an episode's download link.
+        FILE_LINK = /
+          \A[^?\#]*\.
+          (?:pdf|zip|tar\.gz|tgz|#{Regexp.union(Article::Enclosure::MEDIA_TYPES.keys).source})
+          (?:[?\#]|\z)
+        /ix
+        # Element names that may carry an enclosure.
+        ELEMENT_NAMES = %w[img audio video source a].freeze
+        # Players whose own +src+ and inner +source+ elements name a media file.
+        MEDIA_ELEMENTS = %w[audio video].freeze
 
         class << self
           ##
-          # @param href [String]
-          # @return [Boolean]
-          def archive_href?(href)
-            ARCHIVE_HREF_SUFFIXES.any? { |suffix| href.to_s.end_with?(suffix) }
-          end
-
-          ##
-          # @param src [String]
+          # The enclosure an HTML element stands for, if any. A player's file carries the player as its
+          # kind, so an untyped file without a media extension is still audio or video
+          # ({Article::Enclosure::KIND_TYPES}).
+          #
+          # @param name [String] element name (lower case)
           # @param base_url [String, Html2rss::Url]
+          # @param src [String, nil] the element's +src+ attribute
+          # @param href [String, nil] the element's +href+ attribute
+          # @param type [String, nil] the element's +type+ attribute
+          # @yieldreturn [String, nil] the name of the nearest {MEDIA_ELEMENTS} player around the element (an
+          #   ancestor, not only the parent: the HTML4 parser nests sibling +source+ elements), or nil; asked
+          #   only for a +source+
           # @return [Hash{Symbol => Object}, nil]
-          def from_image(src, base_url)
-            return if src.to_s.empty?
-
-            abs = Url.from_relative(src, base_url)
-            { url: abs, type: Article::Enclosure.guess_content_type_from_url(abs, default: 'image/jpeg') }
+          def from_element(name, base_url, src:, href:, type:)
+            case name
+            when 'img' then from_image(src, base_url)
+            when 'audio', 'video' then from_media(src, type, base_url, kind: name.to_sym)
+            when 'source' then from_source(src, type, base_url, yield)
+            when 'a' then from_anchor(href, base_url)
+            end
           end
 
           ##
-          # @param src [String]
-          # @param type [String, nil]
-          # @param base_url [String, Html2rss::Url]
-          # @return [Hash{Symbol => Object}, nil]
-          def from_media(src, type, base_url)
-            return if src.to_s.empty?
+          # @param href [String, nil] an anchor's +href+
+          # @return [Boolean] whether it names a file {.from_element} turns into an enclosure ({FILE_LINK})
+          def file_link?(href) = href.to_s.match?(FILE_LINK)
 
-            { url: Url.from_relative(src, base_url), type: }
+          ##
+          # @param src [String, nil]
+          # @param type [String, nil] declared MIME type; nil lets {Article::Enclosure#type} guess it
+          # @param base_url [String, Html2rss::Url, nil]
+          # @param kind [Symbol, nil] +:audio+ or +:video+ when the source proves the file's kind
+          # @return [Hash{Symbol => Object}, nil] nil unless +src+ resolves to an http(s) URL ({Url.resolve_web})
+          def from_media(src, type, base_url, kind: nil)
+            return unless (url = Url.resolve_web(src, base_url))
+
+            { url:, type:, kind: }.compact
           end
 
           ##
-          # @param src [String]
-          # @param base_url [String, Html2rss::Url]
-          # @return [Hash{Symbol => Object}, nil]
-          def from_iframe(src, base_url)
-            return if src.to_s.empty?
+          # One enclosure per URL, at its first position in document order; a duplicate declaring a type
+          # wins over an untyped one (+<video src=x><source src=x type=video/webm>+).
+          #
+          # @param enclosures [Array<Hash{Symbol => Object}>] {.from_element} results in document order
+          # @return [Array<Hash{Symbol => Object}>]
+          def unique(enclosures)
+            enclosures.group_by { _1[:url] }.map { |_url, same| same.find { _1[:type] } || same.first }
+          end
+
+          private
+
+          def from_image(src, base_url)
+            return unless (url = Url.resolve_web(src, base_url))
 
-            abs = Url.from_relative(src, base_url)
-            { url: abs, type: Article::Enclosure.guess_content_type_from_url(abs, default: 'text/html') }
+            { url:, type: Article::Enclosure.guess_content_type_from_url(url, default: 'image/jpeg') }
+          end
+
+          def from_source(src, type, base_url, player)
+            from_media(src, type, base_url, kind: player.to_sym) if player
           end
 
-          ##
-          # @param href [String]
-          # @param base_url [String, Html2rss::Url]
-          # @return [Hash{Symbol => Object}, nil]
           def from_anchor(href, base_url)
-            return if href.to_s.empty?
+            return unless file_link?(href) && (url = Url.resolve_web(href, base_url))
 
-            abs = Url.from_relative(href, base_url)
-            type = if href.end_with?('.pdf')
-                     Article::Enclosure.guess_content_type_from_url(abs)
-                   else
-                     'application/zip'
-                   end
-            { url: abs, type: }
+            { url: }
           end
         end
       end

data/lib/html2rss/html/article_rules/image.rb

@@ -14,10 +14,16 @@ module Html2rss
         MAX_ATTR_CHARS = 4_096
         # Optional quoting around a CSS `url(...)` value.
         QUOTES = ['"', "'"].freeze
-        # Srcset width/height descriptor suffixes.
-        UNITS = %w[w h].freeze
-        # HTML/CSS whitespace treated as srcset token separators.
-        WS = [' ', "\t", "\n", "\r", "\f"].freeze
+        # Srcset width/height descriptor suffix bytes (`w`, `h`).
+        UNIT_BYTES = [119, 104].freeze
+        # HTML/CSS whitespace bytes (space, tab, LF, CR, FF) treated as srcset token separators.
+        WS_BYTES = [32, 9, 10, 13, 12].freeze
+        # ASCII `,`.
+        COMMA = 44
+        # ASCII `0`.
+        ZERO = 48
+        # ASCII `9`.
+        NINE = 57
 
         class << self
           ##
@@ -29,6 +35,11 @@ module Html2rss
             by_size[by_size.keys.max]
           end
 
+          ##
+          # @param src [String, nil] an image URL attribute, e.g. a video +poster+
+          # @return [Boolean] whether it names a fetchable image: not blank, not an inline +data:+ URI
+          def remote_src?(src) = src.to_s.match?(/\S/) && !src.start_with?('data:')
+
           ##
           # @param style_strings [Array<String>] CSS style attribute values
           # @return [String, nil] longest non-data background url
@@ -54,23 +65,24 @@ module Html2rss
 
           # URL token + `Nw`/`Nh` pairs. Commas may appear inside URLs; a candidate
           # boundary is whitespace before a width/height descriptor.
+          # Scans bytes: every separator, digit and unit is ASCII, and UTF-8
+          # continuation bytes (0x80+) never equal an ASCII byte, so byte offsets are safe.
+          # `getbyte` returns nil past the end, which every predicate treats as no match.
           def each_srcset_pair(string) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
             i = 0
-            len = string.length
+            len = string.bytesize
             while i < len
-              i += 1 while i < len && sep?(string[i])
-              break if i >= len
-
+              i += 1 while sep?(string.getbyte(i))
               start = i
-              i += 1 while i < len && !ws?(string[i])
-              url = string[start, i - start]
+              i += 1 until ws?(string.getbyte(i)) || i >= len
+              url = string.byteslice(start, i - start)
 
-              i += 1 while i < len && ws?(string[i])
+              i += 1 while ws?(string.getbyte(i))
               size_start = i
-              i += 1 while i < len && string[i].between?('0', '9')
-              next unless i > size_start && i < len && UNITS.include?(string[i])
+              i += 1 while digit?(string.getbyte(i))
+              next unless i > size_start && UNIT_BYTES.include?(string.getbyte(i))
 
-              yield url, string[size_start, i - size_start].to_i
+              yield url, string.byteslice(size_start, i - size_start).to_i
               i += 1
             end
           end
@@ -99,9 +111,11 @@ module Html2rss
             string[start, close - start] if close
           end
 
-          def sep?(char) = ws?(char) || char == ','
+          def sep?(byte) = ws?(byte) || byte == COMMA
+
+          def ws?(byte) = WS_BYTES.include?(byte)
 
-          def ws?(char) = WS.include?(char)
+          def digit?(byte) = byte&.between?(ZERO, NINE)
         end
       end
     end

data/lib/html2rss/html/feed_link.rb

@@ -2,15 +2,16 @@
 
 module Html2rss
   module Html
-    FeedLink = Data.define(:href, :mime_type)
+    FeedLink = Data.define(:href, :mime_type, :title)
 
-    # A native RSS/Atom hint from a document head +link[rel=alternate]+.
+    # A native RSS/Atom/RDF hint from a document head +link[rel=alternate]+.
     #
     # Does not guess +/feed+ or +/rss.xml+ paths — that stays in configs +probe_rss+.
+    # +title+ is the link's stripped +title+ attribute (empty when absent).
     class FeedLink
       class << self
         ##
-        # Collects RSS/Atom +rel=alternate+ links from +doc+'s +head+.
+        # Collects RSS/Atom/RDF +rel=alternate+ links from +doc+'s +head+.
         #
         # @param doc [Nokogiri::XML::Node] parsed HTML document
         # @return [Array<FeedLink>] native feed hints, omitting blanks and non-feed types
@@ -21,16 +22,13 @@ module Html2rss
         private
 
         def from_node(node)
-          href = node['href']&.strip
+          href = node['href'].strip # the head selector guarantees an href attribute
           mime_type = feed_mime_type(node['type'])
-          new(href:, mime_type:) unless href.nil? || href.empty? || mime_type.nil?
+          new(href:, mime_type:, title: node['title'].to_s.strip) unless href.empty? || mime_type.nil?
         end
 
         def feed_mime_type(type)
-          return Probe::APPLICATION_RSS_XML if Probe.mime_match?(type, Probe::APPLICATION_RSS_XML)
-          return Probe::APPLICATION_ATOM_XML if Probe.mime_match?(type, Probe::APPLICATION_ATOM_XML)
-
-          nil
+          Probe::FEED_MIME_TYPES.find { |mime| Probe.mime_match?(type, mime) }
         end
       end
     end

data/lib/html2rss/html/navigator/text_extractor.rb

@@ -5,7 +5,9 @@ module Html2rss
     class Navigator
       ##
       # TextExtractor extracts visible text from DOM elements, preserving lists
-      # and block spacing while sanitizing white spaces.
+      # and block spacing while sanitizing white spaces. Same joining rule as {SST::Text}: an inline element
+      # embedded in direct text and touching it stays in its word (+Straßenbah<span>n</span> für+), while two
+      # adjacent elements and an element opening or closing its parent's text always separate.
       class TextExtractor
         # HTML block elements that trigger line breaks or special formatting.
         BLOCK_TAGS = %w[p div li ul ol h1 h2 h3 h4 h5 h6 tr br].to_set.freeze
@@ -29,19 +31,21 @@ module Html2rss
 
           private
 
+          # +last+ is [node, block?] of the previous piece with text.
           def iterate_children(tag, separator, exclude_nodes)
-            last = false
-            tag.children.each_with_object([]) do |c, p|
-              next if exclude_nodes&.include?(c) || !visible_child?(c)
+            last = nil
+            tag.children.each_with_object([]) do |c, parts|
+              text, block = process_child_node(c, separator, exclude_nodes) if shown?(c, exclude_nodes)
+              next if text.to_s.empty?
 
-              text, block = process_child_node(c, separator, exclude_nodes)
-              next if text.empty?
-
-              append_separator!(p, separator, block, last)
-              (p << text) && (last = block)
+              parts << gap(separator, block, last, c) if last
+              parts << text
+              last = [c, block]
             end
           end
 
+          def shown?(child, exclude_nodes) = !exclude_nodes&.include?(child) && visible_child?(child)
+
           def process_child_node(child, separator, exclude_nodes)
             child_text = get_child_text(child, separator, exclude_nodes)
             return ['', false] if child_text.empty?
@@ -58,16 +62,22 @@ module Html2rss
             end
           end
 
-          def append_separator!(parts, separator, is_block, last_was_block)
-            return if parts.empty?
+          def gap(separator, is_block, last, child)
+            return (separator == ' ' ? "\n" : separator) if is_block || last.last
 
-            parts << if is_block || last_was_block
-                       (separator == ' ' ? "\n" : separator)
-                     else
-                       ' '
-                     end
+            touching?(last.first, child) ? '' : ' '
           end
 
+          # Whether direct text and an inline element meet as adjacent siblings with no whitespace between
+          # them. Only an element embedded in direct text (a text sibling on both sides) touches it.
+          def touching?(before, after)
+            element = before.element? ? before : after
+            before.next_sibling == after && embedded?(element) &&
+              !before.text.match?(/\s\z/) && !after.text.match?(/\A\s/)
+          end
+
+          def embedded?(element) = element.previous_sibling&.text? && element.next_sibling&.text?
+
           def visible_child?(node)
             !INVISIBLE_CONTENT_TAGS.include?(node.name) &&
               !(node.name == 'a' && node['href']&.start_with?('#'))

data/lib/html2rss/html/navigator.rb

@@ -5,17 +5,17 @@ module Html2rss
     ##
     # Navigator owns DOM chrome recognition and node traversal helpers.
     class Navigator
+      # String forms of {SST::Tags} (the vocabulary owner); no delta today.
       # Heading tags used to prioritize title extraction and container assessment.
-      HEADING_TAGS = Set['h1', 'h2', 'h3', 'h4', 'h5', 'h6'].freeze
+      HEADING_TAGS = SST::Tags::HEADING_NAMES.to_set(&:to_s).freeze
 
       # Element tags that indicate ignored DOM chrome when found in a container path.
-      IGNORED_CONTAINER_TAGS = Set['nav', 'footer', 'header', 'svg', 'script', 'style'].freeze
+      IGNORED_CONTAINER_TAGS = SST::Tags::IGNORED_CONTAINER_NAMES.to_set(&:to_s).freeze
 
-      # Ancestor tags that usually indicate navigation/utility regions inside a content container.
-      UTILITY_LANDMARK_TAGS = Set['nav', 'aside', 'footer', 'menu'].freeze
-
-      # Immediate parent walk stops here — not a usable article card.
-      CARD_WALK_STOP_TAGS = (UTILITY_LANDMARK_TAGS | IGNORED_CONTAINER_TAGS | Set['html', 'body']).freeze
+      # Immediate parent walk stops here — not a usable article card. Utility landmarks
+      # (tags and roles, {SST::Tags.utility_landmark?}) stop too, and page-level header/footer
+      # (or banner/contentinfo roles), via {usable_card_parent?}.
+      CARD_WALK_STOP_TAGS = (IGNORED_CONTAINER_TAGS | Set['html', 'body']).freeze
 
       # Inner tags that mean a wrapping <a> is a card, not a span-styled list link.
       WRAPPING_ANCHOR_CHILD_TAGS = (HEADING_TAGS + %w[p]).freeze
@@ -23,7 +23,7 @@ module Html2rss
       # Anchor selector used to identify the canonical article link element.
       MAIN_ANCHOR_SELECTOR = begin
         buf = +'a[href]:not([href=""])'
-        %w[# javascript: mailto: tel: file:// sms: data:].each do |prefix|
+        SST::Tags::SKIP_HREF_PREFIXES.each do |prefix|
           buf << %[:not([href^="#{prefix}"])]
         end
         buf.freeze
@@ -67,6 +67,7 @@ module Html2rss
 
         ##
         # Immediate parent is a usable article card (not html/body/landmark chrome).
+        # A header/footer inside article/section/aside/main belongs to its card.
         #
         # @param node [Nokogiri::XML::Node, SST::Node, nil]
         # @return [Boolean]
@@ -74,7 +75,11 @@ module Html2rss
           return false unless node
           return false if node.is_a?(Nokogiri::XML::Document)
 
-          !CARD_WALK_STOP_TAGS.include?(Probe.tag(node))
+          tag = Probe.tag(node)
+          role = node.is_a?(SST::Node) ? node.attrs.raw['role'] : node['role']
+          return !page_chrome?(node) if SST::Tags.page_level_chrome?(tag, role)
+
+          !CARD_WALK_STOP_TAGS.include?(tag) && !SST::Tags.utility_landmark?(tag, role)
         end
 
         ##
@@ -123,6 +128,31 @@ module Html2rss
           end
           false
         end
+
+        private
+
+        # Whether a header/footer is page-level chrome. SST nodes defer to the
+        # Normalizer's chrome index (unindexed nodes stay chrome); Nokogiri nodes
+        # check for a sectioning ancestor.
+        #
+        # @param node [Nokogiri::XML::Node, SST::Node]
+        # @return [Boolean]
+        def page_chrome?(node)
+          if node.is_a?(SST::Node)
+            index = SST::Index.for_node(node)
+            return index.nil? || index.ignored_chrome?(node)
+          end
+
+          nokogiri_chrome_scope(node) == :chrome
+        end
+
+        # Folds {SST::Tags.chrome_scope} over a Nokogiri node's ancestors, root first.
+        #
+        # @param node [Nokogiri::XML::Node]
+        # @return [Symbol] +:page+, +:sectioned+, or +:chrome+
+        def nokogiri_chrome_scope(node)
+          (node.ancestors.reverse << node).reduce(:page) { |scope, el| el.element? ? SST::Tags.chrome_scope(el, scope) : scope }
+        end
       end
     end
   end