arrolio 0.1.0 → 0.1.1

data/lib/arrolio/math_ml/inline_run_extractor.rb

@@ -0,0 +1,272 @@
+# frozen_string_literal: true
+
+require 'mml'
+
+module Arrolio
+  module MathML
+    # Walks a parsed Mml tree (from +Mml.parse(xml_string, version: 3)+)
+    # and emits an Array of +Content::InlineRun+ values, applying
+    # +baseline_shift+ and +font_size_scale+ to match the math
+    # layout semantics of each MathML element.
+    #
+    # The extractor relies on the canonical Mml gem (plurimath/mml)
+    # for parsing, keeping Arrolio free of its own MathML grammar.
+    # MathML presentation elements map as follows:
+    #
+    #   <mi>                  → italic math run (:math_identifier)
+    #   <mn>, <mo>, <mtext>   → regular math run (parent style)
+    #   <ms>                  → quoted string run (parent style)
+    #   <msub>                → base + subscript run
+    #   <msup>                → base + superscript run
+    #   <msubsup>             → base + sub + sup
+    #   <munder>/<mover>      → rendered as sub/sup for visual fidelity
+    #   <mfrac>               → numerator + '/' + denominator (inline)
+    #   <mrow>, <mstyle>      → transparent group, recurse children
+    #
+    # Anything else recurses transparently.
+    class InlineRunExtractor
+
+      # Each entry is [value_attribute, child_collection_attribute, kind]
+      # - value_attribute: node method returning the text content (or nil)
+      # - child_collection_attribute: node method returning child
+      #   elements of that type (Array)
+      # - kind: :text | :identifier | :transparent | :subscript_container
+      #         | :superscript_container | :fraction | :ignored
+      ELEMENT_HANDLERS = {
+        'Mml::V3::Mi' => [:value, :mi_value, :identifier],
+        'Mml::V3::Mn' => [:value, :mn_value, :text],
+        'Mml::V3::Mo' => [:value, :mo_value, :text],
+        'Mml::V3::Mtext' => [:value, :mtext_value, :text],
+        'Mml::V3::Ms' => [:value, :ms_value, :text],
+        'Mml::V3::Mrow' => [nil, nil, :transparent_all],
+        'Mml::V3::Mstyle' => [nil, nil, :transparent_all],
+        'Mml::V3::Msub' => [nil, :msub_value, :subscript_container],
+        'Mml::V3::Msup' => [nil, :msup_value, :superscript_container],
+        'Mml::V3::Msubsup' => [nil, :msubsup_value, :subsup_container],
+        'Mml::V3::Munder' => [nil, :munder_value, :subscript_container],
+        'Mml::V3::Mover' => [nil, :mover_value, :superscript_container],
+        'Mml::V3::Munderover' => [nil, :munderover_value, :subsup_container],
+        'Mml::V3::Mfrac' => [nil, :mfrac_value, :fraction],
+        'Mml::V3::Menclose' => [nil, :menclose_value, :transparent],
+        'Mml::V3::Mphantom' => [nil, :mphantom_value, :transparent],
+        'Mml::V3::Mpadded' => [nil, :mpadded_value, :transparent],
+        'Mml::V3::Merror' => [nil, :merror_value, :transparent],
+        'Mml::V3::Semantics' => [nil, :semantics_value, :transparent],
+        'Mml::V3::Math' => [nil, nil, :transparent_all]
+      }.freeze
+
+      attr_reader :base_style
+
+      def sub_sup_scale = 0.7
+
+      def default_baseline
+        ::Arrolio::Content::InlineRun::BASELINE_NORMAL
+      end
+
+      def sub_baseline
+        ::Arrolio::Content::InlineRun::BASELINE_SUB
+      end
+
+      def sup_baseline
+        ::Arrolio::Content::InlineRun::BASELINE_SUP
+      end
+
+      def initialize(base_style: :math)
+        @base_style = base_style.to_sym
+      end
+
+      def extract(math_node)
+        runs = []
+        walk(math_node, runs, baseline: default_baseline, scale: 1.0,
+                              style_id: base_style)
+        runs
+      end
+
+      # Parse +xml_string+ as MathML and extract the runs. Returns
+      # an empty Array if parsing fails.
+      def self.extract_from_xml(xml_string, base_style: :math)
+        return [] if xml_string.nil? || xml_string.to_s.empty?
+
+        parsed = ::Mml.parse(xml_string.to_s, version: 3)
+        new(base_style: base_style).extract(parsed)
+      rescue StandardError => e
+        Arrolio::Logger.warn "Mml parse failed: #{e.class}: #{e.message[0, 80]}"
+        []
+      end
+
+      private
+
+      def walk(node, runs, baseline:, scale:, style_id:)
+        return unless node
+
+        handler = ELEMENT_HANDLERS[node.class.name]
+        if handler
+          dispatch_handler(node, handler, runs, baseline: baseline,
+                                                scale: scale, style_id: style_id)
+        else
+          # Unknown element: recurse transparently into all child collections.
+          walk_all_children(node, runs, baseline: baseline, scale: scale,
+                                        style_id: style_id)
+        end
+      end
+
+      def dispatch_handler(node, handler, runs, baseline:, scale:, style_id:)
+        _value_attr, child_attr, kind = handler
+        effective_style = kind == :identifier ? :math_identifier : style_id
+        if handler.first
+          emit_text_value(node, runs, baseline: baseline, scale: scale,
+                                      style_id: effective_style)
+        end
+        case kind
+        when :identifier
+          emit_collection_as(node, child_attr, runs, baseline: baseline, scale: scale,
+                                                     style_id: :math_identifier)
+        when :text
+          emit_collection_as(node, child_attr, runs, baseline: baseline, scale: scale,
+                                                     style_id: style_id)
+        when :transparent
+          walk_collection(node, child_attr, runs, baseline: baseline, scale: scale,
+                                                  style_id: style_id)
+        when :transparent_all
+          walk_all_children(node, runs, baseline: baseline, scale: scale,
+                                        style_id: style_id)
+        when :subscript_container
+          process_script_container(node, runs, baseline: baseline, scale: scale,
+                                               style_id: style_id,
+                                               script_baseline: sub_baseline,
+                                               script_position: 1)
+        when :superscript_container
+          process_script_container(node, runs, baseline: baseline, scale: scale,
+                                               style_id: style_id,
+                                               script_baseline: sup_baseline,
+                                               script_position: 1)
+        when :subsup_container
+          process_subsup_container(node, runs, baseline: baseline, scale: scale,
+                                               style_id: style_id)
+        when :fraction
+          process_fraction_container(node, runs, baseline: baseline, scale: scale,
+                                                 style_id: style_id)
+        end
+      end
+
+      def emit_text_value(node, runs, baseline:, scale:, style_id:)
+        value = safe_value(node)
+        return if value.nil? || value.empty?
+
+        runs << ::Arrolio::Content::InlineRun.new(value,
+                                                  style_id: style_id,
+                                                  baseline_shift: baseline,
+                                                  font_size_scale: scale)
+      end
+
+      def emit_collection_as(node, attr, runs, baseline:, scale:, style_id:)
+        children = safe_collection(node, attr)
+        children.each { |c| walk(c, runs, baseline: baseline, scale: scale, style_id: style_id) }
+      end
+
+      def walk_collection(node, attr, runs, baseline:, scale:, style_id:)
+        safe_collection(node, attr).each do |child|
+          walk(child, runs, baseline: baseline, scale: scale, style_id: style_id)
+        end
+      end
+
+      # For <msub>/<msup>: the node IS the container. Its children
+      # are the base (first) and the script (second).
+      def process_script_container(node, runs, baseline:, scale:, style_id:,
+                                   script_baseline:, script_position:)
+        children = all_child_elements(node)
+        base = children.first
+        script = children[script_position]
+        if base
+          walk(base, runs, baseline: baseline, scale: scale,
+                           style_id: style_id)
+        end
+        return unless script
+
+        walk(script, runs, baseline: script_baseline,
+                           scale: reduce_scale(scale),
+                           style_id: style_id)
+      end
+
+      # For <msubsup>: base + sub + sup
+      def process_subsup_container(node, runs, baseline:, scale:, style_id:)
+        children = all_child_elements(node)
+        base = children[0]
+        sub = children[1]
+        sup = children[2]
+        if base
+          walk(base, runs, baseline: baseline, scale: scale,
+                           style_id: style_id)
+        end
+        if sub
+          walk(sub, runs, baseline: sub_baseline,
+                          scale: reduce_scale(scale), style_id: style_id)
+        end
+        return unless sup
+
+        walk(sup, runs, baseline: sup_baseline,
+                        scale: reduce_scale(scale), style_id: style_id)
+      end
+
+      # For <mfrac>: numerator + '/' + denominator, all at reduced scale.
+      def process_fraction_container(node, runs, baseline:, scale:, style_id:)
+        children = all_child_elements(node)
+        numerator = children[0]
+        denominator = children[1]
+        child_scale = reduce_scale(scale)
+        if numerator
+          walk(numerator, runs, baseline: sup_baseline, scale: child_scale,
+                                style_id: style_id)
+        end
+        runs << ::Arrolio::Content::InlineRun.new('/', style_id: style_id,
+                                                       baseline_shift: baseline,
+                                                       font_size_scale: scale)
+        return unless denominator
+
+        walk(denominator, runs, baseline: sub_baseline, scale: child_scale,
+                                style_id: style_id)
+      end
+
+      def walk_all_children(node, runs, baseline:, scale:, style_id:)
+        %i[mi_value mn_value mo_value mtext_value ms_value mrow_value
+           mstyle_value msub_value msup_value msubsup_value mfrac_value
+           menclose_value mphantom_value mpadded_value merror_value
+           mover_value munder_value munderover_value semantics_value
+           msqrt_value mroot_value mtable_value math_value].each do |attr|
+          safe_collection(node, attr).each do |child|
+            walk(child, runs, baseline: baseline, scale: scale, style_id: style_id)
+          end
+        end
+      end
+
+      def all_child_elements(node)
+        %i[mi_value mn_value mo_value mtext_value ms_value mrow_value
+           mstyle_value msub_value msup_value msubsup_value mfrac_value
+           menclose_value mphantom_value mpadded_value merror_value
+           mover_value munder_value munderover_value semantics_value
+           msqrt_value mroot_value mtable_value].flat_map do |attr|
+          safe_collection(node, attr)
+        end
+      end
+
+      def safe_collection(node, attr)
+        return [] unless node.is_a?(::Mml::CommonElements)
+
+        node.public_send(attr)
+      rescue StandardError
+        []
+      end
+
+      def safe_value(node)
+        value = node.value
+        value.is_a?(Array) ? value.join : value.to_s
+      rescue StandardError
+        nil
+      end
+
+      def reduce_scale(current_scale)
+        (current_scale * sub_sup_scale).round(4)
+      end
+    end
+  end
+end

data/lib/arrolio/math_ml.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Arrolio
+  module MathML
+    autoload :InlineRunExtractor, 'arrolio/math_ml/inline_run_extractor'
+  end
+end

data/lib/arrolio/output/page.rb

@@ -5,13 +5,13 @@ module Arrolio
     class Page
       attr_reader :number, :template_name, :template_role, :page_size,
                   :regions, :static_regions, :header_text, :footer_text,
-                  :header_align, :footer_align, :footnotes
+                  :header_align, :footer_align, :footnotes, :title_text
 
       def initialize(number:, template_name:, page_size:,
                      regions:, static_regions: {}, template_role: :body,
                      header_text: nil, footer_text: nil,
-                     header_align: :right, footer_align: :center,
-                     footnotes: [])
+                     header_align: nil, footer_align: :center,
+                     footnotes: [], title_text: nil)
         @number = number.to_i
         @template_name = template_name.to_sym
         @template_role = template_role.to_sym
@@ -20,9 +20,10 @@ module Arrolio
         @static_regions = static_regions.transform_keys(&:to_sym).freeze
         @header_text = header_text
         @footer_text = footer_text
-        @header_align = header_align.to_sym
+        @header_align = header_align ? header_align.to_sym : :right
         @footer_align = footer_align.to_sym
         @footnotes = Array(footnotes).freeze
+        @title_text = title_text
         freeze
       end
 

data/lib/arrolio/output/placed_box.rb

@@ -17,11 +17,14 @@ module Arrolio
       end
 
       class << self
-        def text(x:, y:, width:, height:, lines:, line_height:, style:, link_dest: nil)
+        def text(x:, y:, width:, height:, lines:, line_height:, style:,
+                 hanging_indent: 0.0, line_heights: nil, link_dest: nil)
           new(x: x, y: y, width: width, height: height, kind: :text,
               data: { lines: Array(lines).freeze,
                       line_height: line_height.to_f,
-                      style: style },
+                      line_heights: line_heights&.map(&:to_f)&.freeze,
+                      style: style,
+                      hanging_indent: hanging_indent.to_f },
               link_dest: link_dest)
         end
 

data/lib/arrolio/renderer/pdf.rb

@@ -240,6 +240,7 @@ module Arrolio
         pdfrb_page.value[:Resources] = catalog.value[:Resources]
         canvas = pdfrb_page.canvas
         render_cover_logo(canvas, output_page) if output_page.template_role == :cover && @logo_ref
+        render_page_title(canvas, output_page) if output_page.title_text
         render_header_footer(canvas, output_page) unless output_page.template_role == :cover
         render_page_footnotes(canvas, output_page) unless output_page.template_role == :cover
         (output_page.static_regions.values + output_page.regions.values).each do |region|
@@ -248,28 +249,37 @@ module Arrolio
         @link_annotator.flush(pdfrb_page)
       end
 
+      # Footnote bodies occupy the zone the engine reserved at the
+      # page bottom. The layout comes from
+      # FootnoteMarkerFlowable.body_flowable - the same policy the
+      # engine used to reserve the space - so the drawn block fits
+      # the reserved zone exactly.
       def render_page_footnotes(canvas, page)
-        return unless page.footnotes && !page.footnotes.empty?
-
-        hf = header_footer_style
-        y = hf[:margin_bottom] + 20
-        page.footnotes.each do |footnote|
-          marker = footnote.marker.to_s
-          body_text = footnote.body.map do |node|
-            node.is_a?(Arrolio::Content::Paragraph) ? node.text : node.to_s
-          end.join(' ')
-          line = "#{marker} #{body_text}".strip
-          next if line.empty?
-
-          payload = encoded_or_text(hf[:font_name], line)
-          ref = embedded_or_standard(hf[:font_name])
-          canvas.text(payload, at: [hf[:margin_lr], y], font: ref, size: 7.0)
-          y -= 9.0
+        return if page.footnotes.nil? || page.footnotes.empty?
+
+        style = footnote_style
+        body = page.body_region
+        width = body ? body.width : page.width * 0.85
+        x = body ? body.x : page.width * 0.075
+        flowables = page.footnotes.map do |footnote|
+          Flowables::FootnoteMarkerFlowable.body_flowable(footnote, style)
+        end
+        total = flowables.sum { |flow| flow.height(width) }
+        y = header_footer_style[:margin_bottom] + 20 + total
+        flowables.each do |flow|
+          boxes, = flow.emit(x, y, width, nil)
+          boxes.each { |box| render_box(canvas, box) }
+          y -= flow.height(width)
         end
       rescue StandardError => e
         Arrolio::Logger.warn "footnote render failed: #{e.class}: #{e.message[0, 80]}"
       end
 
+      def footnote_style
+        style = @layout_spec&.resolve_style(:footnote)
+        style.nil? || style.font_size.nil? ? Style::Definition.new(font_size: 9.0) : style
+      end
+
       def render_cover_logo(canvas, page)
         logo_style = cover_logo_style
         w = logo_style[:width]
@@ -296,6 +306,24 @@ module Arrolio
         end
       end
 
+      def render_page_title(canvas, page)
+        header_footer_style
+        body = page.regions[:body]
+        return unless body
+
+        font_name = 'Times New Roman Bold'
+        size = 18.0
+        measurer = GlyphMeasurer.new(font_name: font_name)
+        tw = measurer.width_of_string(page.title_text, font_size: size)
+        x = (page.width - tw) / 2.0
+        baseline = body.y + body.height - 9.0
+        ref = embedded_or_standard(font_name)
+        payload = encoded_or_text(font_name, page.title_text)
+        canvas.text(payload, at: [x, baseline], font: ref, size: size)
+      rescue StandardError => e
+        Arrolio::Logger.warn "render_page_title failed: #{e.message[0, 80]}"
+      end
+
       def render_header_footer(canvas, page)
         hf_style = header_footer_style
         margin_top = hf_style[:margin_top]
@@ -344,48 +372,119 @@ module Arrolio
         when :rect then render_rect(canvas, box)
         when :line then render_line(canvas, box)
         when :image then render_image(canvas, box)
+        when :rotated_text then render_rotated_text(canvas, box)
         end
       end
 
+      def render_rotated_text(canvas, box)
+        text = box.data[:text]
+        style = box.data[:style]
+        angle = box.data[:angle].to_f
+        line_height = box.data[:line_height].to_f
+        font_name = style.font_name
+        ref = embedded_or_standard(font_name)
+        payload = encoded_or_text(font_name, text)
+        rad = angle * Math::PI / 180.0
+        cos = Math.cos(rad)
+        sin = Math.sin(rad)
+        baseline_y = box.y + line_height - GlyphMeasurer.new(font_name: font_name)
+                                                          .ascender(font_size: style.font_size)
+        # PDF text matrix is [a b c d e f] where (a,d) scale, (b,c) rotate,
+        # (e,f) translate. We rotate around the baseline starting point.
+        canvas.text(payload, at: [box.x, baseline_y], font: ref, size: style.font_size,
+                             tm: [cos, sin, -sin, cos, box.x, baseline_y])
+      rescue StandardError => e
+        Arrolio::Logger.warn "render_rotated_text failed: #{e.message[0, 80]}"
+      end
+
       def render_text(canvas, box)
         lines = box.data[:lines]
         line_height = box.data[:line_height]
         style = box.data[:style]
+        hanging_indent = box.data[:hanging_indent] || 0.0
         measurer = GlyphMeasurer.new(font_name: style.font_name)
         ascender = measurer.ascender(font_size: style.font_size)
         x_origin = box.x
         y_top = box.y + box.height
 
+        heights = box.data[:line_heights] ||
+                  Array.new(lines.length, line_height)
+        offset = 0.0
         lines.each_with_index do |line, idx|
-          baseline_y = y_top - (idx * line_height) - ascender
-          line_x = x_origin + line.x_offset
-          render_line_runs(canvas, line, line_x, baseline_y, style)
+          # A math line's slot is taller than a text line; the
+          # reference draws the stacked expression at the BOTTOM of
+          # its slot (the text-level parens stay at the line top).
+          drop = heights[idx] - line_height
+          baseline_y = y_top - offset - ascender - drop
+          indent = idx.zero? ? 0 : hanging_indent
+          line_x = x_origin + indent + line.x_offset
+          render_line_runs(canvas, line, line_x, baseline_y, style,
+                           last_line: idx == lines.length - 1)
+          offset += heights[idx]
         end
       end
 
-      def render_line_runs(canvas, line, line_x, baseline_y, _paragraph_style)
-        justify = line.justified? ? line.justify_stretch : 0.0
+      def render_line_runs(canvas, line, line_x, baseline_y, _paragraph_style, last_line: false)
+        justify = line.justified? && !last_line ? line.justify_stretch : 0.0
         extra_offset = 0.0
         line.placed_runs.each do |pr|
           run = pr.run
-          x = line_x + pr.x_offset + extra_offset
+          run_x = line_x + pr.x_offset
           font_name = run.style.font_name
           ref = embedded_or_standard(font_name)
-          payload = encoded_or_text(font_name, run.text)
           y, size = baseline_position_for(run, baseline_y)
-          opts = { at: [x, y], font: ref, size: size }
-          if run.style.character_spacing && !run.style.character_spacing.zero?
-            opts[:char_spacing] = run.style.character_spacing
-          end
-          if run.style.word_spacing && !run.style.word_spacing.zero?
-            opts[:word_spacing] = run.style.word_spacing
+          measurer = GlyphMeasurer.new(font_name: font_name)
+          cursor = 0.0
+          run_start = nil
+          text_chunks(run.text, justify).each do |chunk|
+            x = run_x + extra_offset + cursor
+            run_start ||= x
+            payload = encoded_or_text(font_name, chunk)
+            opts = { at: [x, y], font: ref, size: size }
+            if run.style.character_spacing && !run.style.character_spacing.zero?
+              opts[:char_spacing] = run.style.character_spacing
+            end
+            if run.style.word_spacing && !run.style.word_spacing.zero?
+              opts[:word_spacing] = run.style.word_spacing
+            end
+            record_link_if_needed(run, x, y, size) if cursor.zero?
+            canvas.text(payload, **opts)
+            cursor += measurer.width_of_string(chunk, font_size: size)
+            # Justify must SHRINK as well as stretch: a compressed
+            # line (ratio > -1) relies on negative space adjustment —
+            # skipping it draws the line at natural width, past the
+            # measure.
+            extra_offset += (chunk.count(' ') * justify) unless justify.zero?
           end
-          record_link_if_needed(run, x, y, opts[:size])
-          canvas.text(payload, **opts)
-          extra_offset += (run.text.count(' ') * justify) if justify.positive?
+          draw_underline(canvas, run, run_start, y, size, cursor) if run.style.underline
         end
       end
 
+      # PDF word spacing (Tw) does not apply to two-byte CID-encoded
+      # embedded fonts, so justification cannot rely on it. Instead a
+      # justified line is drawn as one positioned text operation per
+      # word — FOP's model — with each word's x carrying the stretch
+      # accumulated so far. The separating space stays attached to
+      # the preceding word so text extraction still sees word gaps.
+      def text_chunks(text, justify)
+        return [text] if justify.zero?
+
+        text.split(/(?<=\s)(?=\S)/)
+      end
+
+      # Draws a thin horizontal rule below a run's baseline when the
+      # style's `underline` flag is set. Matches FOP/HTML convention:
+      # the rule sits ~1pt below baseline, thickness ~5% of font size.
+      def draw_underline(canvas, _run, x, baseline_y, size, width)
+        weight = [size * 0.05, 0.5].max
+        underline_y = baseline_y - (size * 0.18)
+        canvas.line(x, underline_y, x + width, underline_y)
+        canvas.line_width = weight
+        canvas.stroke
+      rescue StandardError => e
+        Arrolio::Logger.warn "draw_underline failed: #{e.message[0, 60]}"
+      end
+
       # Returns [y, font_size] for a run, applying baseline shift and
       # font size scaling for subscript/superscript runs.
       # Subscript: shift down 0.2em, scale 0.7x.

data/lib/arrolio/style/definition.rb

@@ -9,7 +9,8 @@ module Arrolio
                   :padding_top, :padding_right, :padding_bottom, :padding_left,
                   :character_spacing, :word_spacing, :line_break,
                   :keep_together, :page_break_before, :page_break_after,
-                  :keep_with_next, :widows, :orphans, :parent
+                  :keep_with_next, :widows, :orphans, :parent,
+                  :underline, :text_transform
 
       DEFAULTS = {
         font_name: 'Helvetica', font_size: 12.0,
@@ -20,7 +21,8 @@ module Arrolio
         character_spacing: 0.0, word_spacing: 0.0,
         line_break: :greedy,
         keep_together: false, page_break_before: false, page_break_after: false,
-        keep_with_next: false, widows: 2, orphans: 2, parent: nil
+        keep_with_next: false, widows: 1, orphans: 1, parent: nil,
+        underline: false, text_transform: nil
       }.freeze
 
       def initialize(**opts)
@@ -50,6 +52,8 @@ module Arrolio
         @widows = merged.fetch(:widows).to_i
         @orphans = merged.fetch(:orphans).to_i
         @parent = merged.fetch(:parent)
+        @underline = truthy?(merged.fetch(:underline))
+        @text_transform = merged.fetch(:text_transform)
         freeze
       end
 
@@ -80,7 +84,7 @@ module Arrolio
           line_break: @line_break, keep_together: @keep_together,
           page_break_before: @page_break_before, page_break_after: @page_break_after,
           keep_with_next: @keep_with_next, widows: @widows, orphans: @orphans,
-          parent: @parent
+          parent: @parent, underline: @underline, text_transform: @text_transform
         }
       end
 

data/lib/arrolio/style/registry.rb

@@ -9,18 +9,21 @@ module Arrolio
 
       def initialize(overrides = {})
         @overrides = {}
+        @resolution_cache = {}
         overrides.each { |name, attrs| register(name, **attrs) }
         freeze
       end
 
       def register(name, **opts)
         @overrides[name.to_sym] = opts.transform_keys(&:to_sym)
+        @resolution_cache.clear
         name.to_sym
       end
 
       def resolve(name, fallback: Definition.new)
         key = name.to_sym
         return fallback unless @overrides.key?(key)
+        return @resolution_cache[key] if @resolution_cache.key?(key)
 
         chain = []
         cursor = key
@@ -32,7 +35,9 @@ module Arrolio
         end
         merged = chain.reverse_each.reduce({}) { |acc, h| acc.merge(h) }
         merged.delete(:parent)
-        Definition.new(**merged)
+        result = Definition.new(**merged)
+        @resolution_cache[key] = result
+        result
       end
 
       def names = @overrides.keys