raindown 0.12.0 → 0.14.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6ea9df31d83ebabf0649ad353b75e2f2546aeb10c31aa97038bdd85f5e45fd2c
-  data.tar.gz: cc736f0d57e576c476629bfa7fe37405139cb1b880e86908e71e7e8d8b22926c
+  metadata.gz: be9fc3af39c4d6f20b00b691a14582626448ac903a01aa129a2f33911553a76f
+  data.tar.gz: d0bf1eea7f8996adb29d97eeeaeda1c38ad16739df7724704ab1402b1bd2c723
 SHA512:
-  metadata.gz: 851438f9079a944aca1dc2f97d0c5081822d0ce31df12e536ca10dce8d471233ee0879fc91b7004fcf7949159554dec7cd0d1e4aa3d50b8cee4009dbd3180766
-  data.tar.gz: 27863d35bb59084303144bdc0b1ea3852028a55c854e8142456c3e1d8f9ee495a3d5489dc00c91ce474bcd9eda833deb42d4f3696118bb24c25e913dabb54372
+  metadata.gz: b6b4305e373de95235142d2e030849aac517d724232194bd68eb2c16cef7c81dd9594ccc8a80b2cd7d8042af045818773d1059c8d30caef634f0722ed35cd6d4
+  data.tar.gz: 593a219070643268ddd2c52a25aa34d0fe76d62f1074c2a3a263dddf72407d4b03c3a13113100e684ee19c6168a15525e059bf26c118ea6bca680c7112c3ee62

data/lib/elements.rb

@@ -6,28 +6,27 @@ module Raindown
   class Elements
     include Plugs
 
-    # Antlers' prop and slot directives, rendered as components in the template pass.
-    plug(:prop_component) do
+    # Write-in nodes, in <{ }>, like <{ Card }>, <{ :toc }> or <{ Card: }>...<{ :Card }>, rendered in the template pass.
+    plug(:write_in) do
       plug(:lexeme) do
-        require 'lexemes/prop_lexeme'
-        Antlers::PropLexeme
+        require_relative 'lexemes/node_lexeme'
+        NodeLexeme
       end
 
+      # A list: block loops over its files, so it comes before other nodes' blocks.
       plug(:node) do
-        require_relative 'nodes/component_nodes'
-        PropComponentNode
+        require_relative 'nodes/list_node'
+        ListNode
       end
-    end
 
-    plug(:slot_component) do
-      plug(:lexeme) do
-        require 'lexemes/slot_lexeme'
-        Antlers::SlotLexeme
+      plug(:node) do
+        require_relative 'nodes/write_in_node'
+        WriteInNode
       end
 
       plug(:node) do
-        require_relative 'nodes/component_nodes'
-        SlotComponentNode
+        require_relative 'nodes/write_in_node'
+        SoloWriteInNode
       end
     end
 
@@ -42,17 +41,5 @@ module Raindown
         EndpointNode
       end
     end
-
-    plug(:list) do
-      plug(:lexeme) do
-        require_relative 'lexemes/list_lexeme'
-        ListLexeme
-      end
-
-      plug(:node) do
-        require_relative 'nodes/list_node'
-        ListNode
-      end
-    end
   end
 end

data/lib/lexemes/node_lexeme.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require 'antlers/api'
+require_relative '../raindown/node_blocks'
+
+module Raindown
+  # A write-in node, in Antlers' delimiters, read with its props as Raindown reads them, like
+  # <{ :list folder: 'notes' }>. It opens a block with <{ Name: }>, and <{ :Name }> ends one, or else it's self-closing,
+  # as is <{ Card title='Hi' }>. Template directives, like if: and for:, aren't nodes, so they're left to their lexemes.
+  module NodeLexeme
+    include Antlers::Lexeme
+
+    module_function
+
+    DIRECTIVE = /\A(:)?([A-Za-z]\w*(?:::[A-Z]\w*)*)(:)?(?:\s+(.*))?\z/m
+
+    # A name with a colon is a node, like <{ :toc }> or <{ :app_name }>, while {:app_name} is a translation. One without
+    # is a node when it's capitalized, so <{ title }> is still a variable. The lexer gives no name to a directive that
+    # starts with another lexeme's keyword, like <{ if: draft }> or <{ :list }>, which it leaves to that lexeme.
+    def match?(segment:, name: nil, **)
+      _, close, node_name, open = segment.to_s.match(DIRECTIVE).to_a
+      return false if name.nil? || node_name.nil? || (close && open)
+      return true if close || open
+
+      node_name.match?(/\A[A-Z]/)
+    end
+
+    # <{ :Name }> ends a block of the name, or else is self-closing, while <{ Name }> is always self-closing.
+    def lexeme(segment:, **)
+      _, close, name, open, args = segment.match(DIRECTIVE).to_a
+      return { node_def: name, args: args.to_s } if open
+      return { node_end: name, args: args.to_s } if close
+
+      { node_solo: name, args: args.to_s }
+    end
+  end
+end

data/lib/nodes/list_node.rb

@@ -1,46 +1,43 @@
 # frozen_string_literal: true
 
 require 'antlers/api'
+require_relative '../raindown/context'
+require_relative '../raindown/node_blocks'
+require_relative '../raindown/nodes'
+require_relative 'write_in_node'
 
 module Raindown
+  # <{ list: page folder: 'notes' }> ... <{ :list }>, which renders its template for each file the list: node lists,
+  # with the file as page. Without a block, <{ :list folder: 'notes' }> renders the node's links, as a WriteInNode.
   class ListNode < Antlers::BranchNode
-    include Antlers::Props
-    include Antlers::Variables
+    DEF_KEY = :node_def
+    END_KEY = :node_end
 
-    DEF_KEY = :list_def
-    END_KEY = :list_end
+    def initialize(name:, args:)
+      super(name:)
 
-    def initialize(value:, folder:, props: [], children: [])
-      super(name: :toc, props:, children:)
-
-      @value = value.delete("'").delete('"')
-      @folder = folder.delete("'").delete('"')
+      @variable, @tags = args.split(/\s+/, 2)
     end
 
-    def render(current_binding: nil, parent_binding: nil, slot_node: nil, metadata: {})
-      output = ''
-
-      list = metadata.list(folder: @folder)
-
-      list.each do |value|
-        # TODO: Parallelize by creating new bindings and ensuring children have any args they need via RenderEvent.
-        current_binding.local_variable_set(@value, value)
-
-        @children.each do |child|
-          output += child.render(current_binding:, parent_binding:, slot_node:, metadata:) || ''
-        end
-      end
+    def render(current_binding: nil, context: Context.new, **)
+      tags = NodeBlocks.props(@tags.to_s, BoundVariables.new(current_binding))
+      Nodes.instance(Nodes.node_class('list'), tags).files(metadata: context.metadata).map do |file|
+        current_binding.local_variable_set(@variable, file)
+        super
+      end.join
+    end
 
-      output
+    def end_name
+      'list'
     end
 
     class << self
       def match?(segment:)
-        segment[DEF_KEY]
+        segment[DEF_KEY] == 'list'
       end
 
       def build(segment:, **)
-        new(value: segment[:list_def], folder: segment[:folder])
+        new(name: :list, args: segment[:args])
       end
     end
   end

data/lib/nodes/write_in_node.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+require 'antlers/api'
+require 'nodes/html_node'
+require_relative '../raindown/context'
+require_relative '../raindown/fragments'
+require_relative '../raindown/node_blocks'
+require_relative '../raindown/nodes'
+
+module Raindown
+  # A write-in node, in <{ }>, which Antlers renders where it is in the template, so its props see loop variables, like
+  # <{ Card name=p.name }> in a for: loop. It only renders, with its render, never its rewrite, and the Markdown
+  # between its tags, <{ Card: }> to <{ :Card }>, is its slot, rendered to HTML in its scope first.
+  # One with a class template, like Raindeer's .rbx components, renders its template, with that HTML as its slot.
+  class WriteInNode < Antlers::BranchNode
+    DEF_KEY = :node_def
+    END_KEY = :node_end
+
+    def initialize(name:, args: '', **)
+      super(name:)
+
+      @args = args
+    end
+
+    def render(current_binding: nil, context: Context.new, **)
+      slot = Raindown.commonmark(super) unless @children.empty?
+      props, args = NodeBlocks.args(@args, BoundVariables.new(current_binding))
+      node = Nodes.instance(node_class, props, args || [])
+      return Fragments.add(template_html(node, props, slot.to_s, current_binding)) if Nodes.template?(node.class)
+
+      Nodes.rendered(node, context, slot: slot.to_s)
+    end
+
+    def end_name
+      @name
+    end
+
+    private
+
+    # A render-only component, like Card, isn't a node Nodes finds, as it has no rewrite, so it's any class of the name.
+    def node_class
+      klass = Nodes.node_class(@name)
+      return klass if klass
+      raise NameError, "No node is named #{@name}, for <{ :#{@name} }>" unless @name.match?(/\A[A-Z]/)
+
+      Object.const_get(@name)
+    end
+
+    # The node's class template, whose slot is the HTML in place of its children.
+    def template_html(node, props, slot, parent_binding)
+      children = @children
+      @children = [Antlers::HTMLNode.new(html: slot)]
+      node.render_template(parent_binding:, slot_node: self, props:)
+    ensure
+      @children = children
+    end
+
+    class << self
+      def match?(segment:)
+        segment[DEF_KEY]
+      end
+
+      def build(segment:, **)
+        new(name: segment[DEF_KEY], args: segment[:args])
+      end
+    end
+  end
+
+  # <{ Card }>, or <{ :Card }> when it doesn't end a block, which a lowercase name needs, like <{ :toc }>.
+  class SoloWriteInNode < WriteInNode
+    END_KEY = nil
+
+    def self.match?(segment:)
+      segment[:node_solo] || segment[:node_end]
+    end
+
+    def self.build(segment:, **)
+      new(name: segment[:node_solo] || segment[:node_end], args: segment[:args])
+    end
+  end
+
+  # The variables where Antlers renders a node, like a loop's, and then the front matter's, as its props read them.
+  class BoundVariables < BasicObject
+    def initialize(binding)
+      @binding = binding
+    end
+
+    # A name that can't be a local, like a-b, is only looked for in the front matter.
+    def send(name)
+      return @binding.local_variable_get(name) if name.match?(/\A[a-z_]\w*\z/) && @binding.local_variable_defined?(name)
+
+      @binding.receiver.send(name)
+    end
+  end
+end

data/lib/raindown/bare_directives.rb

@@ -8,22 +8,22 @@ require_relative 'front_matter'
 module Raindown
   # Raindown files (.rd/.raindown) can write a content directive, which writes its output back, bare on its own line,
   # like endpoint: or toc:, which shows in bold in the HTML. Markdown files opt in with "raindown: true" in their front
-  # matter, or with the --bare flag. Nodes like toc: and files: are handled by NodeBlocks, before the rest.
+  # matter, or with the --bare flag. Nodes like toc: and list: are handled by NodeBlocks, before the rest.
   # Template directives, like if: and for:, are always in Antlers' delimiters, so they're never bare.
   #
   # A bare schema: shows in bold, with its fields in a code block below it.
   #
-  # Bare directives have no end tag. A bare endpoint closes itself after its curl snippet and response, so where it
-  # needs more than that, write it in comments with an end tag instead:
+  # Bare directives have no end tag. A bare endpoint holds the lines straight below it, its curl snippet, the comment
+  # with its response's status, time and date, and its response, up to the next blank line, like a bare node block, so
+  # where it needs blank lines, write it in comments with an end tag instead:
   #   <!-- endpoint: -->
   #   ...
   #   <!-- :endpoint -->
   module BareDirectives
     EXTENSIONS = %w[.rd .raindown].freeze
-    # The block directives, and the method that finds the line their end tag goes after.
-    BLOCK_KEYWORDS = { 'endpoint:' => :after_endpoint }.freeze
-    # Four spaces of indent would make the line a Markdown code block.
-    LINE = /\A( {0,3})((#{BLOCK_KEYWORDS.keys.join('|')})(?:[ \t]+\S.*?)?)[ \t]*$/
+    # A bare endpoint, the one bare directive with a block. Four spaces of indent would make the line a Markdown code
+    # block.
+    LINE = /\A( {0,3})(endpoint:(?:[ \t]+\S.*?)?)[ \t]*$/
 
     module_function
 
@@ -75,7 +75,7 @@ module Raindown
       return index unless match
 
       lines[index] = "#{Directives.marker(match[2], shown: true)}\n#{wrap(lines[index])}"
-      close_block(lines, index, indent: match[1], keyword: match[3])
+      close_block(lines, index, indent: match[1])
       index
     end
 
@@ -88,16 +88,10 @@ module Raindown
     end
 
     # The end tag after the block, then the end tag in bold, as a bare directive's shown.
-    def close_block(lines, index, indent:, keyword:)
-      last = public_send(BLOCK_KEYWORDS[keyword], lines, index + 1) || index
+    def close_block(lines, index, indent:)
+      last = CodeBlocks.last_before_blank(lines, index)
       lines[last] = "#{lines[last]}\n" unless lines[last].end_with?("\n")
-      name = keyword.delete_suffix(':')
-      lines.insert(last + 1, "#{indent}<{ :#{name} }>\n#{Directives.marker(":#{name}", shown: true)}\n")
-    end
-
-    # The last line of the curl snippet and response below an endpoint.
-    def after_endpoint(lines, index)
-      CodeBlocks.endpoint(lines, index).last&.fetch(:close)
+      lines.insert(last + 1, "#{indent}<{ :endpoint }>\n#{Directives.marker(':endpoint', shown: true)}\n")
     end
   end
 end

data/lib/raindown/chart/chart.rb

@@ -32,7 +32,7 @@ module Raindown
     end
 
     # The data is read every time, so the chart follows changes to its file.
-    def replace(metadata: NoMetadata)
+    def rewrite(metadata: NoMetadata)
       points = points(metadata:)
       return '' if points.empty?
 

data/lib/raindown/code_blocks.rb

@@ -5,6 +5,9 @@ module Raindown
   module CodeBlocks
     FENCE = /\A {0,3}(`{3,}|~{3,})[ \t]*(\S*)/
     SNIPPET_LANGUAGES = %w[sh bash shell zsh console curl].freeze
+    # The comment Raindown writes between an endpoint's snippet and its response, with the response's status, how long
+    # it took and the date it was fetched, like <!-- response 200 · 142 ms · 2026-10-14 -->.
+    RESPONSE_COMMENT = /\A {0,3}<!-- response [^\n]*? -->[ \t]*$/
     # The line closing a fence, like ``` or ~~~~, compiled once per fence.
     CLOSINGS = Hash.new { |closings, fence| closings[fence] = /\A {0,3}#{fence[0]}{#{fence.length},}[ \t]*$/ }
 
@@ -19,27 +22,32 @@ module Raindown
       { open: index, close:, language:, body: lines[index + 1...close].join } if close
     end
 
-    # An endpoint's curl snippet and its response, if it has one yet.
-    # A second snippet straight after is another example rather than the response.
-    def endpoint(lines, index)
-      snippet, response = following(lines, index, limit: 2)
-      response && snippet?(response) ? [snippet] : [snippet, response].compact
+    # An endpoint's curl snippet and its response, if it has one yet, with the line of the response comment between them
+    # as the response's :comment, if there is one. A second snippet straight after is another example rather than the
+    # response. A bare endpoint's are in the lines straight below it, up to the next blank line.
+    def endpoint(lines, index, bare: false)
+      lines = lines[..last_before_blank(lines, index - 1)] if bare
+      snippet = at(lines, skip_blank_lines(lines, index))
+      return [] unless snippet
+
+      index = skip_blank_lines(lines, snippet[:close] + 1)
+      comment = index if lines[index]&.match?(RESPONSE_COMMENT)
+      response = at(lines, comment ? skip_blank_lines(lines, comment + 1) : index)
+      return [snippet] if response.nil? || snippet?(response)
+
+      [snippet, response.merge(comment:)]
     end
 
     def snippet?(block)
       SNIPPET_LANGUAGES.include?(block[:language].downcase) || block[:body].lstrip.start_with?('curl')
     end
 
-    # Up to limit blocks from index on, with only blank lines before and between them.
-    def following(lines, index, limit:)
-      blocks = []
-
-      while blocks.length < limit && (block = at(lines, skip_blank_lines(lines, index)))
-        blocks << block
-        index = block[:close] + 1
-      end
-
-      blocks
+    # The last of the lines straight below open, up to the next blank line, with fenced code kept whole, or open when
+    # there are none, like a bare block's.
+    def last_before_blank(lines, open)
+      last = open
+      last = at(lines, last + 1)&.fetch(:close) || (last + 1) while lines[last + 1] && !lines[last + 1].strip.empty?
+      last
     end
 
     def skip_blank_lines(lines, index)

data/lib/raindown/context.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require_relative 'front_matter'
+require_relative 'variables'
+
+module Raindown
+  # The document being rendered, its metadata, like a site's pages, and whether its directives can be bare: the keywords
+  # a node's rewrite and render can take. Antlers passes it down to Raindown's own Antlers nodes.
+  Context = Data.define(:document, :metadata, :bare) do
+    def initialize(document: '', metadata: NoMetadata, bare: false)
+      super
+    end
+
+    # The document's front matter, as variables, like {title}.
+    def variables
+      Variables.new(FrontMatter.parse(document).first)
+    end
+  end
+end

data/lib/raindown/directives.rb

@@ -19,7 +19,7 @@ module Raindown
 
     module_function
 
-    # A directive's line without its delimiters, like "files: folder: 'notes'" for <!-- files: folder: 'notes' -->.
+    # A directive's line without its delimiters, like "list: folder: 'notes'" for <!-- list: folder: 'notes' -->.
     def text(line)
       line = line.strip
       [COMMENT, DELIMITERS].each do |open, close|

data/lib/raindown/document.rb

@@ -16,6 +16,9 @@ module Raindown
   class Document
     Heading = Data.define(:level, :text, :line)
 
+    # Its Markdown, and whether it allows bare directives.
+    attr_reader :markdown, :bare
+
     # A content directive: a node, like toc: or a project's Changelog:, or an endpoint.
     # It spans line to end_line, its end tag, or the last line of a bare block.
     # Body is the lines inside it, between it and its end tag, like an endpoint's request and response.
@@ -116,21 +119,18 @@ module Raindown
       [bare.strip, true] if bare
     end
 
-    # The response and the date it was fetched are the output, while the curl snippet above them is the author's.
+    # The response and the comment above it are the output, while the curl snippet above them is the author's.
     def endpoint(open, args, writes)
-      curl, response = CodeBlocks.endpoint(@lines, open + 1)
-      output = response && (response[:open]..(fetched?(response[:close] + 1) ? response[:close] + 1 : response[:close]))
+      bare = Directives.bare?(@lines[open])
+      curl, response = CodeBlocks.endpoint(@lines, open + 1, bare:)
+      output = response && ((response[:comment] || response[:open])..response[:close])
       last = output&.end || curl&.fetch(:close) || open
-      # A bare endpoint, which isn't delimited, ends after its blocks.
-      last = end_tag(after: last) || last unless Directives.bare?(@lines[open])
+      # A bare endpoint ends at the next blank line, and one in a comment at its end tag.
+      last = bare ? CodeBlocks.last_before_blank(@lines, open) : end_tag(after: last) || last
 
       directive('endpoint', args, open..last, output:, writes:)
     end
 
-    def fetched?(index)
-      @lines[index]&.match?(EndpointRunner::FETCHED)
-    end
-
     # The end tag after the endpoint's blocks, with only blank lines between.
     def end_tag(after:)
       index = CodeBlocks.skip_blank_lines(@lines, after + 1)

data/lib/raindown/endpoint/endpoint_runner.rb

@@ -10,17 +10,17 @@ require_relative 'endpoint_variables'
 
 module Raindown
   # Runs the curl block under an endpoint directive in a comment, or a bare one, and writes the response in the code
-  # block below it, followed by the date it was fetched, its status and how long it took.
+  # block below it, after a comment of its status, how long it took and the date it was fetched.
   # Only runs when that block is missing or empty, and --execute is passed, so a file can't run requests by itself.
   # Or with only: and a directive's line index, runs just that endpoint, replacing any response it has.
   #   <!-- endpoint: -->
   #   ```sh
   #   curl https://api.example.com
   #   ```
+  #   <!-- response 200 · 142 ms · 2026-10-14 -->
   #   ```json
   #   { "id": 1 }
   #   ```
-  #   <!-- raindown:fetched 2026-10-14 · 200 · 142 ms -->
   #   <!-- :endpoint -->
   # Its snippet's {placeholders} are filled from EndpointVariables, and with as: login, later snippets can use its
   # response, like {login.token}. With status: and schema:, each response in the file is checked, and failures are kept.
@@ -32,9 +32,7 @@ module Raindown
     DIRECTIVE = /\A {0,3}<\{\s*endpoint:(.*?)\}>[ \t]*$/
     COMMENT = /\A {0,3}<!--\s*endpoint:(.*?)-->[ \t]*$/
     END_TAG = /\A {0,3}(?:<\{\s*:endpoint\s*\}>|<!--\s*:endpoint\s*-->)[ \t]*$/
-    # The date a response was fetched, on the line after it.
-    FETCHED = /\A {0,3}<!-- raindown:fetched [^\n]*? -->[ \t]*$/
-    FETCHED_STATUS = /raindown:fetched \S+ · (\d{3}) /
+    RESPONSE_STATUS = /<!-- response (\d{3}) /
 
     attr_reader :failures
 
@@ -83,19 +81,19 @@ module Raindown
 
     # Returns the index of the last line it handled.
     def fill(index, args, directive:)
-      curl, output = CodeBlocks.endpoint(@lines, index)
+      curl, output = CodeBlocks.endpoint(@lines, index, bare: !@lines[directive].match?(COMMENT))
       return index - 1 unless curl&.dig(:body)&.lstrip&.start_with?('curl')
       return write_output(curl:, output:, args:, directive:) if run?(output, directive)
       return curl[:close] unless output
 
       @variables.remember(args.name, output[:body])
-      check(args, directive:, body: output[:body], status: fetched_status(output))
+      check(args, directive:, body: output[:body], status: response_status(output))
       curl[:close]
     end
 
-    # The status in the fetched comment after a response, which responses fetched before statuses were kept don't have.
-    def fetched_status(output)
-      @lines[output[:close] + 1]&.[](FETCHED_STATUS, 1)&.to_i
+    # The status in the comment above a response, which a comment written by hand may not have.
+    def response_status(output)
+      @lines[output[:comment]][RESPONSE_STATUS, 1]&.to_i if output[:comment]
     end
 
     # Run alone, only the endpoint that ran is checked. One without a response or a status hasn't run, so it has nothing
@@ -113,14 +111,15 @@ module Raindown
       @execute && (output.nil? || output[:body].strip.empty?)
     end
 
-    # Replaces the output block and the date it was fetched, or with no block, replaces nothing just after the curl block.
+    # Replaces everything from just after the curl block to the end of the output block, if there is one, like its
+    # comment.
     # Secrets that a response echoes are written as their placeholders.
     def write_output(curl:, output:, args:, directive:)
       response = Curl.run(curl[:body], @variables)
       body = @variables.redact(response.body)
       @variables.remember(args.name, body)
       check(args, directive:, body:, status: response.status)
-      replace_output(curl:, output:, block: [*output_block(body, response.language), fetched(response)])
+      replace_output(curl:, output:, block: [response_comment(response), *output_block(body, response.language)])
     rescue Curl::Error => e
       message = @variables.redact(e.message)
       # The one endpoint that was asked for fails for the caller to show, like in the terminal UI.
@@ -132,21 +131,13 @@ module Raindown
 
     # Returns the index of the block's last line.
     def replace_output(curl:, output:, block:)
-      block.unshift("\n") unless output
-      start = output ? output[:open] : curl[:close] + 1
-
-      @lines[start, output ? replaced_length(output) : 0] = block
+      start = curl[:close] + 1
+      @lines[start, output ? output[:close] - start + 1 : 0] = block
       start + block.length - 1
     end
 
-    # The output block, and the line after it when that's the date it was last fetched.
-    def replaced_length(output)
-      length = output[:close] - output[:open] + 1
-      @lines[output[:close] + 1]&.match?(FETCHED) ? length + 1 : length
-    end
-
-    def fetched(response)
-      "<!-- raindown:fetched #{Date.today.iso8601} · #{response.status} · #{response.milliseconds} ms -->\n"
+    def response_comment(response)
+      "<!-- response #{response.status} · #{response.milliseconds} ms · #{Date.today.iso8601} -->\n"
     end
 
     # The fence is longer than any run of backticks in the body, so the body can't close it.

data/lib/raindown/fragments.rb

@@ -18,8 +18,13 @@ module Raindown
     end
 
     def add(html)
+      "<!-- raindown:fragment #{store(html)} -->"
+    end
+
+    # Keeps the HTML for this render, returning its index in the list.
+    def store(html)
       list << html
-      "<!-- raindown:fragment #{list.length - 1} -->"
+      list.length - 1
     end
 
     # Fills each placeholder, again and again, since a fragment can hold others, like a component in a slot.

data/lib/raindown/js/host.mjs

@@ -16,13 +16,13 @@ const classes = {}
 const nodes = {}
 
 const requests = {
-  // Every exported class with replace is a node, named by its export, or by its class for a default export.
+  // Every exported class with rewrite is a node, named by its export, or by its class for a default export.
   async load({ folder }) {
     for (const file of readdirSync(folder).filter((file) => /\.m?js$/.test(file))) {
       const exports = await import(pathToFileURL(join(folder, file)).href)
 
       for (const [name, value] of Object.entries(exports)) {
-        if (typeof value?.prototype?.replace === 'function') classes[name === 'default' ? value.name : name] = value
+        if (typeof value?.prototype?.rewrite === 'function') classes[name === 'default' ? value.name : name] = value
       }
     }
 

data/lib/raindown/js/js_nodes.rb

@@ -6,7 +6,7 @@ require 'open3'
 require_relative '../node'
 
 module Raindown
-  # JavaScript Components, the .js and .mjs files in a project's .raindown folder, which export classes with replace and
+  # JavaScript Components, the .js and .mjs files in a project's .raindown folder, which export classes with rewrite and
   # optionally render, like Ruby nodes. They run in a NodeJS process of Raindown's own, started when a folder has them,
   # so only projects with JavaScript Components need NodeJS.
   module JSNodes
@@ -57,7 +57,7 @@ module Raindown
     end
   end
 
-  # A JavaScript Component, made in the NodeJS process with its props, where its replace and render are sent.
+  # A JavaScript Component, made in the NodeJS process with its props, where its rewrite and render are sent.
   class JSNode < Node
     # A class for each JavaScript Component, which renders its own HTML when the component has render.
     def self.for(name:, render:)
@@ -72,8 +72,8 @@ module Raindown
       JSNodes.host.request(op: 'new', id: object_id, name: self.class.name, args:, props:)
     end
 
-    def replace(**context)
-      js_output(:replace, context)
+    def rewrite(**context)
+      js_output(:rewrite, context)
     end
 
     private