red_quilt 0.7.2 → 0.9.0

data/lib/red_quilt/node_ref.rb

@@ -46,6 +46,83 @@ module RedQuilt
       text
     end
 
+    # Node attributes, by NodeType.
+    #
+    # Each returns nil when the node does not carry the attribute, so callers
+    # can walk the tree branching on #type and read the type's own fields
+    # without a Hash allocation per node. The Arena's accessors are the raw
+    # layer and deliberately skip that check: several attributes share a
+    # storage column, so reading one off a mismatched node yields another
+    # field's value rather than nil (e.g. Arena#link_destination on a
+    # paragraph returns the paragraph's text). These wrappers are the safe
+    # way to read attributes.
+
+    # CODE_BLOCK: the fence info string, e.g. "ruby" or 'vtt audio="x.mp3"'.
+    # A code block written without one has an empty info string, so "" means
+    # "no info given" while nil means "not a code block".
+    def info
+      return nil unless type?(NodeType::CODE_BLOCK)
+
+      @arena.code_block_info(@node_id).to_s
+    end
+
+    # HEADING: nesting level (1..6).
+    def heading_level
+      @arena.heading_level(@node_id) if type?(NodeType::HEADING)
+    end
+
+    # LIST: ordered (`1.`) vs bullet (`-`).
+    def list_ordered?
+      @arena.list_ordered?(@node_id) if type?(NodeType::LIST)
+    end
+
+    # LIST: start number of an ordered list.
+    def list_start
+      @arena.list_start(@node_id) if type?(NodeType::LIST)
+    end
+
+    # LIST: tight (no blank lines between items) vs loose.
+    def list_tight?
+      @arena.list_tight?(@node_id) if type?(NodeType::LIST)
+    end
+
+    # LIST: the item delimiter as authored, e.g. "-" or "1.".
+    def list_delimiter
+      @arena.list_delimiter(@node_id) if type?(NodeType::LIST)
+    end
+
+    # LINK / IMAGE: the destination URL.
+    def link_destination
+      @arena.link_destination(@node_id) if link_like?
+    end
+
+    # LINK / IMAGE: the optional title, nil when absent.
+    def link_title
+      @arena.link_title(@node_id) if link_like?
+    end
+
+    # FOOTNOTE_DEFINITION / FOOTNOTE_REFERENCE: the label as authored.
+    def footnote_label
+      @arena.footnote_label(@node_id) if footnote_like?
+    end
+
+    # FOOTNOTE_DEFINITION / FOOTNOTE_REFERENCE: the resolved 1-based number.
+    def footnote_number
+      @arena.footnote_number(@node_id) if footnote_like?
+    end
+
+    # TABLE_ROW / TABLE_CELL: whether this belongs to the header row.
+    #
+    # nil rather than false outside a table, matching the other attribute
+    # accessors: a paragraph is not a non-header row, it has no header-ness
+    # at all. Both answers are falsy, so `if node.header?` reads the same.
+    def header?
+      return @arena.table_row_header?(@node_id) if type?(NodeType::TABLE_ROW)
+      return @arena.table_cell_header?(@node_id) if type?(NodeType::TABLE_CELL)
+
+      nil # rubocop:disable Style/ReturnNilInPredicateMethodDefinition
+    end
+
     def source_span
       @arena.source_span(@node_id)
     end
@@ -83,29 +160,47 @@ module RedQuilt
 
     private
 
+    def type?(node_type)
+      @arena.type(@node_id) == node_type
+    end
+
+    # Kept allocation-free (no splat) because these accessors are meant for
+    # per-node use while walking a whole document.
+    def link_like?
+      node_type = @arena.type(@node_id)
+      node_type == NodeType::LINK || node_type == NodeType::IMAGE
+    end
+
+    def footnote_like?
+      node_type = @arena.type(@node_id)
+      node_type == NodeType::FOOTNOTE_DEFINITION || node_type == NodeType::FOOTNOTE_REFERENCE
+    end
+
     def ast_attributes
       case @arena.type(@node_id)
       when NodeType::HEADING
-        { level: @arena.int1(@node_id), text: text }
+        { level: @arena.heading_level(@node_id), text: text }
       when NodeType::LIST
         {
-          ordered: @arena.int1(@node_id) == 1,
-          start_number: @arena.int2(@node_id),
-          tight: @arena.int3(@node_id) == 1,
-          delimiter: @arena.str1(@node_id),
+          ordered: @arena.list_ordered?(@node_id),
+          start_number: @arena.list_start(@node_id),
+          tight: @arena.list_tight?(@node_id),
+          delimiter: @arena.list_delimiter(@node_id),
         }
-      when NodeType::TABLE_ROW, NodeType::TABLE_CELL
-        { header: @arena.int1(@node_id) == 1, text: text }
+      when NodeType::TABLE_ROW
+        { header: @arena.table_row_header?(@node_id), text: text }
+      when NodeType::TABLE_CELL
+        { header: @arena.table_cell_header?(@node_id), text: text }
       when NodeType::TEXT, NodeType::CODE_SPAN, NodeType::HTML_BLOCK, NodeType::HTML_INLINE, NodeType::PARAGRAPH
         { text: text }
       when NodeType::CODE_BLOCK
-        { text: @arena.text(@node_id), info: @arena.str2(@node_id) }
+        { text: @arena.text(@node_id), info: @arena.code_block_info(@node_id) }
       when NodeType::LINK, NodeType::IMAGE
-        { destination: @arena.str1(@node_id), title: @arena.str2(@node_id), text: text }
+        { destination: @arena.link_destination(@node_id), title: @arena.link_title(@node_id), text: text }
       when NodeType::FOOTNOTE_REFERENCE
-        { label: @arena.str1(@node_id), number: @arena.int1(@node_id) }
+        { label: @arena.footnote_label(@node_id), number: @arena.footnote_number(@node_id) }
       when NodeType::FOOTNOTE_DEFINITION
-        { label: @arena.str1(@node_id) }
+        { label: @arena.footnote_label(@node_id) }
       else
         {}
       end

data/lib/red_quilt/renderer/html.rb

@@ -16,6 +16,18 @@ module RedQuilt
         @out
       end
 
+      # Renders the given nodes (an Array of NodeRef) in order and returns
+      # the resulting HTML fragment, without affecting the main render
+      # output.
+      def render_fragment(nodes)
+        saved = @out
+        @out = +""
+        nodes.each { |node| render_node(node.node_id) }
+        @out
+      ensure
+        @out = saved
+      end
+
       private
 
       # CommonMark-compliant HTML escape: only `&`, `<`, `>`, `"` are
@@ -46,7 +58,7 @@ module RedQuilt
           render_children(node_id)
           @out << "</p>\n"
         when NodeType::HEADING
-          level = @arena.int1(node_id)
+          level = @arena.heading_level(node_id)
           if @slugger
             id = @slugger.generate(PlainText.from(@arena, node_id))
             @out << %(<h#{level} id="#{escape_html(id)}">)
@@ -62,9 +74,9 @@ module RedQuilt
           render_children(node_id)
           @out << "</blockquote>\n"
         when NodeType::LIST
-          ordered = @arena.int1(node_id) == 1
+          ordered = @arena.list_ordered?(node_id)
           tag = ordered ? "ol" : "ul"
-          start_number = @arena.int2(node_id)
+          start_number = @arena.list_start(node_id)
           attrs = ordered && start_number != 1 ? %( start="#{start_number}") : ""
           @out << "<#{tag}#{attrs}>\n"
           render_children(node_id)
@@ -74,7 +86,7 @@ module RedQuilt
           render_list_item(node_id)
           @out << "</li>\n"
         when NodeType::CODE_BLOCK
-          info_word = @arena.str2(node_id).to_s.split.first.to_s
+          info_word = @arena.code_block_info(node_id).to_s.split.first.to_s
           if @mermaid && info_word == "mermaid"
             # Emit a container mermaid.js recognizes via class="mermaid".
             # The diagram source is still HTML-escaped; the browser decodes
@@ -116,7 +128,7 @@ module RedQuilt
         when NodeType::CODE_SPAN
           @out << "<code>#{escape_html(@arena.text(node_id).to_s)}</code>"
         when NodeType::LINK
-          dest = escape_html(@arena.str1(node_id).to_s)
+          dest = escape_html(@arena.link_destination(node_id).to_s)
           @out << %(<a href="#{dest}")
           append_title_attribute(node_id)
           @out << ">"
@@ -124,7 +136,7 @@ module RedQuilt
           @out << "</a>"
         when NodeType::IMAGE
           alt = PlainText.from(@arena, node_id)
-          dest = escape_html(@arena.str1(node_id).to_s)
+          dest = escape_html(@arena.link_destination(node_id).to_s)
           @out << %(<img src="#{dest}" alt="#{escape_html(alt)}")
           append_title_attribute(node_id)
           @out << " />"
@@ -141,10 +153,11 @@ module RedQuilt
       # element ids use the footnote number; a second+ reference to the
       # same footnote gets a `-M` suffix so each backref has a unique target.
       def render_footnote_reference(node_id)
-        number = @arena.int1(node_id)
-        occurrence = @arena.int2(node_id)
-        ref_id = occurrence > 1 ? "fnref-#{number}-#{occurrence}" : "fnref-#{number}"
-        @out << %(<sup><a href="#fn-#{number}" id="#{ref_id}">#{number}</a></sup>)
+        number = @arena.footnote_number(node_id)
+        occurrence = @arena.footnote_occurrence(node_id)
+        ref_id = FootnoteAnchors.reference_id(number, occurrence)
+        def_id = FootnoteAnchors.definition_id(number)
+        @out << %(<sup><a href="##{def_id}" id="#{ref_id}">#{number}</a></sup>)
       end
 
       def render_footnotes_section(node_id)
@@ -154,10 +167,9 @@ module RedQuilt
       end
 
       def render_footnote_definition(def_id)
-        label = @arena.str1(def_id).to_s
-        number = @document.footnotes.number(label)
-        occurrences = @document.footnotes.occurrences(label)
-        @out << %(<li id="fn-#{number}">\n)
+        number = @arena.footnote_number(def_id)
+        occurrences = @arena.footnote_total_references(def_id)
+        @out << %(<li id="#{FootnoteAnchors.definition_id(number)}">\n)
 
         # Append the backref(s) inside the definition's last paragraph (GFM);
         # if the last block isn't a paragraph, emit a standalone one.
@@ -184,7 +196,7 @@ module RedQuilt
       def footnote_backrefs(number, occurrences)
         out = +""
         (1..occurrences).each do |occ|
-          ref_id = occ > 1 ? "fnref-#{number}-#{occ}" : "fnref-#{number}"
+          ref_id = FootnoteAnchors.reference_id(number, occ)
           suffix = occ > 1 ? "<sup>#{occ}</sup>" : ""
           out << %( <a href="##{ref_id}">&#8617;#{suffix}</a>)
         end
@@ -193,8 +205,8 @@ module RedQuilt
 
       def render_table(table_id)
         rows = @arena.child_ids(table_id).to_a
-        header_rows = rows.select { |row_id| @arena.int1(row_id) == 1 }
-        body_rows = rows.reject { |row_id| @arena.int1(row_id) == 1 }
+        header_rows = rows.select { |row_id| @arena.table_row_header?(row_id) }
+        body_rows = rows.reject { |row_id| @arena.table_row_header?(row_id) }
 
         unless header_rows.empty?
           @out << "<thead>\n"
@@ -210,7 +222,7 @@ module RedQuilt
 
       def render_list_item(node_id)
         parent_id = @arena.raw_parent_id(node_id)
-        tight = parent_id != -1 && @arena.type(parent_id) == NodeType::LIST && @arena.int3(parent_id) == 1
+        tight = parent_id != -1 && @arena.type(parent_id) == NodeType::LIST && @arena.list_tight?(parent_id)
 
         first_child_id = @arena.raw_first_child_id(node_id)
         first_is_para = first_child_id != -1 &&
@@ -249,7 +261,7 @@ module RedQuilt
       def render_table_row(row_id)
         @out << "<tr>"
         @arena.each_child(row_id) do |cell_id|
-          tag = @arena.int1(cell_id) == 1 ? "th" : "td"
+          tag = @arena.table_cell_header?(cell_id) ? "th" : "td"
           @out << "<#{tag}>"
           render_children(cell_id)
           @out << "</#{tag}>"
@@ -285,7 +297,7 @@ module RedQuilt
       end
 
       def append_title_attribute(node_id)
-        title = @arena.str2(node_id).to_s
+        title = @arena.link_title(node_id).to_s
         return if title.empty?
 
         @out << %( title="#{escape_html(title)}")

data/lib/red_quilt/renderer/mdast.rb

@@ -57,19 +57,19 @@ module RedQuilt
 
         case type_int
         when NodeType::HEADING
-          result["depth"] = @arena.int1(node_id)
+          result["depth"] = @arena.heading_level(node_id)
           result["children"] = children(node_id)
         when NodeType::LIST
-          result["ordered"] = @arena.int1(node_id) == 1
-          tight = @arena.int3(node_id) == 1
-          result["start"] = @arena.int2(node_id) if result["ordered"]
+          result["ordered"] = @arena.list_ordered?(node_id)
+          tight = @arena.list_tight?(node_id)
+          result["start"] = @arena.list_start(node_id) if result["ordered"]
           result["spread"] = !tight
           result["children"] = children(node_id, parent_spread: !tight)
         when NodeType::LIST_ITEM
           result["spread"] = parent_spread
           result["children"] = children(node_id)
         when NodeType::CODE_BLOCK
-          info = @arena.str2(node_id)
+          info = @arena.code_block_info(node_id)
           lang = info && !info.empty? ? info.split.first : nil
           result["lang"] = lang
           result["value"] = @arena.text(node_id).to_s
@@ -81,21 +81,21 @@ module RedQuilt
         when NodeType::CODE_SPAN
           result["value"] = @arena.text(node_id).to_s
         when NodeType::LINK
-          result["url"] = @arena.str1(node_id).to_s
-          title = @arena.str2(node_id)
+          result["url"] = @arena.link_destination(node_id).to_s
+          title = @arena.link_title(node_id)
           result["title"] = title && !title.empty? ? title : nil
           result["children"] = children(node_id)
         when NodeType::IMAGE
-          result["url"] = @arena.str1(node_id).to_s
-          title = @arena.str2(node_id)
+          result["url"] = @arena.link_destination(node_id).to_s
+          title = @arena.link_title(node_id)
           result["title"] = title && !title.empty? ? title : nil
           result["alt"] = NodeRef.new(@document, node_id).text.to_s
         when NodeType::FOOTNOTE_REFERENCE
-          label = @arena.str1(node_id).to_s
+          label = @arena.footnote_label(node_id).to_s
           result["identifier"] = label
           result["label"] = label
         when NodeType::FOOTNOTE_DEFINITION
-          label = @arena.str1(node_id).to_s
+          label = @arena.footnote_label(node_id).to_s
           result["identifier"] = label
           result["label"] = label
           result["children"] = children(node_id)
@@ -127,19 +127,23 @@ module RedQuilt
         result
       end
 
+      # unist Point: line and column are 1-based, offset is a 0-based
+      # *character* index. SourceSpan carries bytes, so offset is converted
+      # rather than passed through — the two diverge on multibyte sources.
       def position(span)
-        start_loc = @document.source_map.line_column(span.start_byte)
-        end_loc = @document.source_map.line_column(span.end_byte)
+        source_map = @document.source_map
+        start_loc = source_map.line_column(span.start_byte)
+        end_loc = source_map.line_column(span.end_byte)
         {
           "start" => {
             "line" => start_loc[:line],
             "column" => start_loc[:column],
-            "offset" => span.start_byte,
+            "offset" => source_map.char_offset(span.start_byte),
           },
           "end" => {
             "line" => end_loc[:line],
             "column" => end_loc[:column],
-            "offset" => span.end_byte,
+            "offset" => source_map.char_offset(span.end_byte),
           },
         }
       end

data/lib/red_quilt/source_map.rb

@@ -1,29 +1,69 @@
 # frozen_string_literal: true
 
 module RedQuilt
+  # Translates byte offsets from SourceSpan into human-facing positions.
+  #
+  # Positions follow the unist Point convention, which cmark sourcepos and
+  # mdast both use: `line` and `column` are 1-based, while character offsets
+  # are 0-based. Columns and offsets are counted in characters, not bytes, so
+  # a multibyte source reports the position a reader would count.
   class SourceMap
     def initialize(source)
       @source = source
       @line_starts = build_line_starts(source)
+      @line_char_starts = build_line_char_starts(source, @line_starts)
     end
 
+    # Returns { line:, column: }, both 1-based.
     def line_column(byte_offset)
-      line = (@line_starts.bsearch_index { |s| s > byte_offset } || @line_starts.length) - 1
-      line_start = @line_starts[line]
-      column = @source.byteslice(line_start, byte_offset - line_start).to_s.length
-      { line: line + 1, column: column }
+      line = line_index(byte_offset)
+      { line: line + 1, column: chars_from_line_start(line, byte_offset) + 1 }
+    end
+
+    # Returns the 0-based character offset, as unist Point#offset requires.
+    # Byte offsets are what SourceSpan carries, and the two differ as soon as
+    # the source contains a multibyte character.
+    def char_offset(byte_offset)
+      line = line_index(byte_offset)
+      @line_char_starts[line] + chars_from_line_start(line, byte_offset)
     end
 
     private
 
+    def line_index(byte_offset)
+      (@line_starts.bsearch_index { |s| s > byte_offset } || @line_starts.length) - 1
+    end
+
+    def chars_from_line_start(line, byte_offset)
+      line_start = @line_starts[line]
+      @source.byteslice(line_start, byte_offset - line_start).to_s.length
+    end
+
+    # Line starts are byte offsets, matching SourceSpan#start_byte / #end_byte
+    # and the argument of #line_column. Scanning the binary view is what makes
+    # them bytes: index on a UTF-8 string counts characters, so a multibyte
+    # source would yield offsets that line_column then misreads as bytes.
     def build_line_starts(source)
       starts = [0]
+      source_b = source.b
       pos = 0
-      while (idx = source.index("\n", pos))
+      while (idx = source_b.index("\n", pos))
         starts << (idx + 1)
         pos = idx + 1
       end
       starts
     end
+
+    # Character offset of each line start, so char_offset stays O(1) per call
+    # instead of recounting the source prefix every time.
+    def build_line_char_starts(source, line_starts)
+      chars = 0
+      prev_byte = 0
+      line_starts.map do |byte_start|
+        chars += source.byteslice(prev_byte, byte_start - prev_byte).to_s.length
+        prev_byte = byte_start
+        chars
+      end
+    end
   end
 end

data/lib/red_quilt/table.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+module RedQuilt
+  # GFM table detection (spec 4.10). Pure functions over line text: whether
+  # a line could be a table row and whether a header+delimiter pair starts a
+  # table. Cell splitting lives here too so the recognition rules and the
+  # splitting rules they depend on stay together. Node construction stays in
+  # BlockParser.
+  module Table
+    module_function
+
+    # True when lines[index] / lines[index+1] form a header + delimiter pair
+    # that starts a GFM table.
+    def start?(lines, index)
+      return false if index + 1 >= lines.length
+      return false unless row?(lines[index].content)
+
+      header_cells = split_row(lines[index].content)
+      separators = split_row(lines[index + 1].content)
+      return false if separators.empty?
+
+      # GFM spec: separator row must have valid delimiters AND match header column count.
+      # "The header row must match the delimiter row in the number of cells.
+      #  If not, a table will not be recognized."
+      return false unless header_cells.length == separators.length
+
+      separators.all? { |cell| cell.strip.match?(/\A:?-+:?\z/) }
+    end
+
+    def row?(text)
+      text.include?("|")
+    end
+
+    def split_row(text)
+      body = text.strip
+      body = body[1..] if body.start_with?("|")
+      body = body[0...-1] if body.end_with?("|")
+      body.split("|", -1)
+    end
+
+    # Cached collaborator for BlockParser. A single instance is created in
+    # BlockParser#initialize and reused; per-call state lives in method
+    # locals so reentrant calls are safe.
+    class Parser
+      def initialize(block_parser)
+        @arena = block_parser.arena
+      end
+
+      # Parses the table starting at lines[index] (already confirmed by
+      # Table.start?). Returns the index past the table.
+      def parse(parent_id, lines, index)
+        start_index = index
+        header_cells = Table.split_row(lines[index].content)
+        row_lines = [lines[index]]
+        index += 2
+        while index < lines.length
+          break if lines[index].blank
+          break unless Table.row?(lines[index].content)
+
+          row_lines << lines[index]
+          index += 1
+        end
+
+        table_id = @arena.add_node(NodeType::TABLE,
+                                   source_start: lines[start_index].start_byte,
+                                   source_len: row_lines.last.end_byte - lines[start_index].start_byte)
+        @arena.append_child(parent_id, table_id)
+
+        append_row(table_id, lines[start_index], header_cells, true)
+        row_lines.drop(1).each do |row_line|
+          append_row(table_id, row_line, Table.split_row(row_line.content), false)
+        end
+
+        index
+      end
+
+      private
+
+      def append_row(table_id, line, cells, header)
+        row_id = @arena.add_node(NodeType::TABLE_ROW,
+                                 source_start: line.start_byte,
+                                 source_len: line.span_len,
+                                 int1: header ? 1 : 0)
+        @arena.append_child(table_id, row_id)
+        cells.each do |cell_text|
+          stripped = cell_text.strip
+          cell_id = @arena.add_node(NodeType::TABLE_CELL,
+                                    source_start: line.start_byte,
+                                    source_len: line.span_len,
+                                    int1: header ? 1 : 0,
+                                    str1: stripped)
+          @arena.append_child(row_id, cell_id)
+        end
+      end
+    end
+  end
+end

data/lib/red_quilt/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module RedQuilt
-  VERSION = "0.7.2"
+  VERSION = "0.9.0"
 end

data/lib/red_quilt.rb

@@ -15,17 +15,24 @@ require_relative "red_quilt/theme"
 require_relative "red_quilt/document"
 require_relative "red_quilt/inline"
 require_relative "red_quilt/inline/html_entities"
+require_relative "red_quilt/frontmatter"
 require_relative "red_quilt/reference_definition"
 require_relative "red_quilt/footnote_registry"
+require_relative "red_quilt/footnote_anchors"
 require_relative "red_quilt/footnote_definition"
 require_relative "red_quilt/list"
 require_relative "red_quilt/blockquote"
+require_relative "red_quilt/html_block"
+require_relative "red_quilt/table"
+require_relative "red_quilt/code_block"
 require_relative "red_quilt/block_parser"
 require_relative "red_quilt/inline/token_kind"
 require_relative "red_quilt/inline/tokens"
 require_relative "red_quilt/inline/flanking"
 require_relative "red_quilt/inline/lexer"
 require_relative "red_quilt/inline/link_scanner"
+require_relative "red_quilt/inline/url_sanitizer"
+require_relative "red_quilt/inline/emphasis_resolver"
 require_relative "red_quilt/inline/builder"
 require_relative "red_quilt/inline_pass"
 require_relative "red_quilt/footnote_pass"
@@ -38,8 +45,13 @@ module RedQuilt
   class Error < StandardError; end
 
   class << self
-    def parse(source, allow_html: false, disallow_raw_html: false, extended_autolinks: false, footnotes: false, lint: false)
+    def parse(source, allow_html: false, disallow_raw_html: false, extended_autolinks: false, footnotes: false, lint: false, frontmatter: false)
       normalized = normalize_input(source)
+      frontmatter_diagnostics = []
+      if frontmatter
+        frontmatter_data, normalized =
+          Frontmatter.extract(normalized, diagnostics: frontmatter_diagnostics)
+      end
       arena = Arena.new(normalized)
       footnote_registry = FootnoteRegistry.new if footnotes
       block_parser = BlockParser.new(arena, footnotes: footnote_registry)
@@ -48,7 +60,9 @@ module RedQuilt
                               allow_html: allow_html,
                               disallow_raw_html: disallow_raw_html,
                               references: block_parser.references,
-                              footnotes: footnote_registry)
+                              footnotes: footnote_registry,
+                              frontmatter: frontmatter_data)
+      document.diagnostics.concat(frontmatter_diagnostics)
       document.diagnostics.concat(block_parser.diagnostics)
       InlinePass.new(document).apply
       FootnotePass.new(document).apply if footnote_registry
@@ -57,13 +71,14 @@ module RedQuilt
       document
     end
 
-    def render_html(source, allow_html: false, disallow_raw_html: false, extended_autolinks: false, footnotes: false, lint: false, heading_ids: false, mermaid: false)
+    def render_html(source, allow_html: false, disallow_raw_html: false, extended_autolinks: false, footnotes: false, lint: false, frontmatter: false, heading_ids: false, mermaid: false)
       parse(source,
             allow_html: allow_html,
             disallow_raw_html: disallow_raw_html,
             extended_autolinks: extended_autolinks,
             footnotes: footnotes,
-            lint: lint).to_html(heading_ids: heading_ids, mermaid: mermaid)
+            lint: lint,
+            frontmatter: frontmatter).to_html(heading_ids: heading_ids, mermaid: mermaid)
     end
 
     private

data/sig/red_quilt.rbs

@@ -65,6 +65,19 @@ module RedQuilt
     def find_all: (Symbol type) -> Array[NodeRef]
     def source_location: () -> { start_line: Integer, start_column: Integer, end_line: Integer, end_column: Integer }?
     def to_h: () -> Hash[Symbol, untyped]
+
+    # Node attributes: nil when the node's type does not carry the attribute.
+    def info: () -> String?
+    def heading_level: () -> Integer?
+    def list_ordered?: () -> bool?
+    def list_start: () -> Integer?
+    def list_tight?: () -> bool?
+    def list_delimiter: () -> String?
+    def link_destination: () -> String?
+    def link_title: () -> String?
+    def footnote_label: () -> String?
+    def footnote_number: () -> Integer?
+    def header?: () -> bool?
   end
 
   # Low-level parallel-array storage for the AST. See docs/arena-usage.ja.md.
@@ -115,6 +128,25 @@ module RedQuilt
     def source_span: (Integer id) -> SourceSpan?
     def text: (Integer id) -> String?
 
+    # Semantic payload accessors (per-NodeType column conventions)
+    def heading_level: (Integer id) -> Integer
+    def heading_content_start: (Integer id) -> Integer
+    def heading_content_len: (Integer id) -> Integer
+    def list_ordered?: (Integer id) -> bool
+    def list_start: (Integer id) -> Integer
+    def list_tight?: (Integer id) -> bool
+    def list_delimiter: (Integer id) -> String?
+    def table_row_header?: (Integer id) -> bool
+    def table_cell_header?: (Integer id) -> bool
+    def code_block_info: (Integer id) -> String?
+    def link_destination: (Integer id) -> String?
+    def link_title: (Integer id) -> String?
+    def footnote_number: (Integer id) -> Integer
+    def footnote_occurrence: (Integer id) -> Integer
+    def footnote_label: (Integer id) -> String?
+    def footnote_total_references: (Integer id) -> Integer
+    def resolve_footnote_definition: (Integer id, Integer number, Integer total_references) -> void
+
     # Traversal
     def each_child: (Integer id) { (Integer child_id) -> void } -> self
     def child_ids: (Integer id) -> Enumerator[Integer, void]
@@ -132,9 +164,12 @@ module RedQuilt
     def to_h: () -> { start_byte: Integer, end_byte: Integer }
   end
 
+  # Positions follow the unist Point convention: line and column are 1-based
+  # and counted in characters, while char_offset is 0-based.
   class SourceMap
     def initialize: (String source) -> void
     def line_column: (Integer byte_offset) -> { line: Integer, column: Integer }
+    def char_offset: (Integer byte_offset) -> Integer
   end
 
   class Diagnostic