idml 0.8.7 → 0.8.9

data/lib/idml/render/renderers/text_frame_renderer.rb

@@ -25,7 +25,6 @@ module Idml
       # FontMetrics is available (no shaper → no wrap → rough output).
       class TextFrameRenderer
         DEFAULT_SIZE = 12.0
-        LEADING_FACTOR = 1.2
 
         def self.render(canvas, context)
           frame = context.item
@@ -36,6 +35,7 @@ module Idml
 
           box = frame_box(frame, context.page_height)
           render_inline_tables(canvas, story, box, context)
+          render_anchored_objects(canvas, story, context)
 
           state = initial_chain_state(frame, story, context)
           return unless state
@@ -72,7 +72,8 @@ module Idml
         def self.fresh_state(story, context)
           paragraphs = StyleResolver.extract_paragraphs(
             story, condition_filter: context.condition_filter,
-                   style_lookup: context.style_lookup
+                   style_lookup: context.style_lookup,
+                   footnote_option: Footnote.option(context.package)
           )
           return nil if paragraphs.empty?
 
@@ -102,14 +103,47 @@ module Idml
         private_class_method :render_inline_tables
 
         def self.tables_in_story(story)
+          story_csrs(story).flat_map(&:table).compact
+        end
+        private_class_method :tables_in_story
+
+        # All CharacterStyleRanges of a story, in document order.
+        # Shared by the story-level item discovery walks (tables,
+        # anchored objects).
+        def self.story_csrs(story)
           inner = story&.inner
           return [] unless inner
 
-          inner.paragraph_style_range.flat_map do |psr|
-            psr.character_style_range.flat_map(&:table)
-          end.compact
+          inner.paragraph_style_range.flat_map(&:character_style_range)
         end
-        private_class_method :tables_in_story
+        private_class_method :story_csrs
+
+        # Renders anchored page items embedded in the story flow
+        # (Story > PSR > CSR > Rectangle/Oval/Polygon/GraphicLine/
+        # Group/TextFrame — the IDML structure for anchored objects).
+        # Each item renders at its own stored geometry, which
+        # InDesign resolves to the anchored position when saving;
+        # AnchorType-specific text reflow is not simulated (the
+        # layout engine positions text independently either way).
+        def self.render_anchored_objects(canvas, story, context)
+          anchored_items_in_story(story).each do |item|
+            PageItemRenderer.render(canvas, context_for_item(context, item))
+          end
+        end
+        private_class_method :render_anchored_objects
+
+        def self.anchored_items_in_story(story)
+          story_csrs(story).flat_map do |csr|
+            [csr.rectangle, csr.oval, csr.polygon,
+             csr.graphic_line, csr.group, csr.text_frame]
+          end.flatten.compact
+        end
+        private_class_method :anchored_items_in_story
+
+        def self.context_for_item(context, item)
+          RenderContext.new(**context.to_h, item: item)
+        end
+        private_class_method :context_for_item
 
         def self.render_text(canvas, state, context, box)
           font = context.font_metrics
@@ -175,19 +209,23 @@ module Idml
           top_y = layout_frame.y + layout_frame.height -
             (layout_frame.inset_top || 0)
           bottom_limit = TextEngine::VerticalLayout.bottom_limit(layout_frame)
+          footnotes = []
           cursor_y = vertical_justify_top(top_y, bottom_limit, state, context)
           char_cursor = state.char_cursor
 
           if state.current_paragraph
             cursor_y, char_cursor = resume_paragraph(
               canvas, state, context, layout_frame, font,
-              cursor_y, bottom_limit, char_cursor
+              cursor_y, bottom_limit, char_cursor, footnotes
             )
-            return if state.current_paragraph
           end
 
-          consume_paragraphs(canvas, state, context, layout_frame, font,
-                             cursor_y, bottom_limit, char_cursor)
+          unless state.current_paragraph
+            consume_paragraphs(canvas, state, context, layout_frame, font,
+                               cursor_y, bottom_limit, char_cursor, footnotes)
+          end
+          render_footnote_entries(canvas, footnotes, layout_frame,
+                                  context, font)
         end
         private_class_method :engine_render_single_column
 
@@ -212,19 +250,23 @@ module Idml
         def self.render_column(canvas, state, context, col_frame, font)
           top_y = col_frame.y + col_frame.height - (col_frame.inset_top || 0)
           bottom_limit = TextEngine::VerticalLayout.bottom_limit(col_frame)
+          footnotes = []
           cursor_y = top_y
           char_cursor = state.char_cursor
 
           if state.current_paragraph
             cursor_y, char_cursor = resume_paragraph(
               canvas, state, context, col_frame, font,
-              cursor_y, bottom_limit, char_cursor
+              cursor_y, bottom_limit, char_cursor, footnotes
             )
-            return if state.current_paragraph
           end
 
-          consume_paragraphs(canvas, state, context, col_frame, font,
-                             cursor_y, bottom_limit, char_cursor)
+          unless state.current_paragraph
+            consume_paragraphs(canvas, state, context, col_frame, font,
+                               cursor_y, bottom_limit, char_cursor, footnotes)
+          end
+          render_footnote_entries(canvas, footnotes, col_frame,
+                                  context, font)
         end
         private_class_method :render_column
 
@@ -343,12 +385,13 @@ module Idml
         private_class_method :space_before_after
 
         def self.resume_paragraph(canvas, state, context, layout_frame, font,
-                                  cursor_y, bottom_limit, char_cursor)
+                                  cursor_y, bottom_limit, char_cursor,
+                                  footnotes)
           paragraph = state.current_paragraph
           remaining_runs, cursor_y, char_cursor = render_runs_for_paragraph(
             canvas, paragraph, state.runs_remaining, context,
             layout_frame, font, cursor_y, bottom_limit, char_cursor,
-            first_paragraph: true
+            first_paragraph: true, footnotes: footnotes
           )
           if remaining_runs.any?
             state.runs_remaining = remaining_runs
@@ -361,7 +404,8 @@ module Idml
         private_class_method :resume_paragraph
 
         def self.consume_paragraphs(canvas, state, context, layout_frame, font,
-                                    cursor_y, bottom_limit, char_cursor)
+                                    cursor_y, bottom_limit, char_cursor,
+                                    footnotes)
           pending = 0
           state.paragraphs.each do |paragraph|
             break if cursor_y < bottom_limit
@@ -369,7 +413,7 @@ module Idml
             remaining_runs, cursor_y, char_cursor = render_runs_for_paragraph(
               canvas, paragraph, paragraph.runs, context,
               layout_frame, font, cursor_y, bottom_limit, char_cursor,
-              first_paragraph: pending.zero?
+              first_paragraph: pending.zero?, footnotes: footnotes
             )
             if remaining_runs.any?
               state.current_paragraph = paragraph
@@ -392,7 +436,7 @@ module Idml
         def self.render_runs_for_paragraph(canvas, paragraph, runs, context,
                                            layout_frame, font, cursor_y,
                                            bottom_limit, char_cursor,
-                                           first_paragraph:)
+                                           first_paragraph:, footnotes:)
           wrap_width = TextEngine::VerticalLayout.wrap_width(
             layout_frame, paragraph.right_indent || 0
           )
@@ -411,7 +455,7 @@ module Idml
           rendered, cursor_y, char_cursor = iterate_paragraph_runs(
             canvas, paragraph, effective_runs, context, layout_frame,
             font, wrap_width, cursor_y, bottom_limit, char_cursor,
-            first_paragraph, para_attrs, dc_width, dc_lines
+            first_paragraph, para_attrs, dc_width, dc_lines, footnotes
           )
 
           remaining_runs = effective_runs[rendered..]
@@ -427,7 +471,7 @@ module Idml
                                         layout_frame, font, wrap_width,
                                         cursor_y, bottom_limit, char_cursor,
                                         first_paragraph, para_attrs,
-                                        dc_width, dc_lines)
+                                        dc_width, dc_lines, footnotes)
           rendered_count = 0
           runs.each do |run|
             break if cursor_y < bottom_limit
@@ -442,16 +486,65 @@ module Idml
               canvas, run, paragraph, context, layout_frame, font,
               run_wrap, cursor_y, space_before,
               para_attrs[:first_line_indent], para_attrs[:left_indent],
-              char_cursor
+              char_cursor, bottom_limit
             )
             char_cursor += positioned.length
             cursor_y = next_y
             rendered_count += 1
+            bottom_limit = register_footnote(footnotes, run, layout_frame,
+                                             font, context, bottom_limit)
           end
           [rendered_count, cursor_y, char_cursor]
         end
         private_class_method :iterate_paragraph_runs
 
+        # Collects the footnote anchored by a marker run and raises
+        # the effective bottom limit to reserve room for all
+        # footnotes collected so far. Pass-through for regular runs.
+        def self.register_footnote(footnotes, run, layout_frame, font,
+                                   context, bottom_limit)
+          return bottom_limit unless run.footnote_paragraphs
+
+          footnotes << Footnote::Entry.new(
+            number: run.footnote_number,
+            paragraphs: run.footnote_paragraphs,
+          )
+          option = Footnote.option(context.package)
+          frame_bottom = TextEngine::VerticalLayout.bottom_limit(layout_frame)
+          reserved = Footnote.reserved_height(footnotes, font, layout_frame,
+                                              option)
+          frame_bottom + reserved
+        end
+        private_class_method :register_footnote
+
+        # Renders the collected footnotes at the bottom of the
+        # frame: separator rule at the area's top edge, then the
+        # footnote paragraphs (marker-prefixed at extraction)
+        # flowing downward to the content bottom.
+        def self.render_footnote_entries(canvas, footnotes, layout_frame,
+                                         context, font)
+          return if footnotes.empty?
+
+          option = Footnote.option(context.package)
+          content_bottom = TextEngine::VerticalLayout.bottom_limit(
+            layout_frame,
+          )
+          area_top = content_bottom +
+            Footnote.reserved_height(footnotes, font, layout_frame, option)
+
+          Footnote.emit_separator(canvas, layout_frame, area_top, option)
+          positioned, = Footnote.layout_entries(
+            footnotes, layout_frame, font,
+            area_top - Footnote.rule_gap(option), option
+          )
+          positioned.each do |item|
+            next if item.line.y < content_bottom
+
+            emit_line(canvas, item.line, item.run, context, item.font_size)
+          end
+        end
+        private_class_method :render_footnote_entries
+
         # Computes the text-wrap overlap for a run at its current y
         # position. Uses the run's point_size as the line height
         # approximation. Returns 0.0 when no resolver is wired or no
@@ -594,7 +687,7 @@ module Idml
         def self.layout_run(canvas, run, paragraph, context, layout_frame,
                             font, wrap_width, cursor_y, space_before,
                             first_line_indent, left_indent,
-                            char_cursor)
+                            char_cursor, bottom_limit)
           size = run.point_size || DEFAULT_SIZE
           glyphs = TextEngine::Shaper.shape(
             text: run.text, font: font, size: size,
@@ -621,7 +714,6 @@ module Idml
             left_indent: left_indent,
           )
 
-          bottom_limit = TextEngine::VerticalLayout.bottom_limit(layout_frame)
           positioned.each do |line|
             break if line.y < bottom_limit
 
@@ -664,10 +756,7 @@ module Idml
         private_class_method :emit_line
 
         def self.leading_for(paragraph, size)
-          explicit = paragraph.auto_leading
-          return size * LEADING_FACTOR unless explicit&.positive?
-
-          size * explicit
+          TextEngine::VerticalLayout.leading_for(paragraph.auto_leading, size)
         end
         private_class_method :leading_for
 

data/lib/idml/render/shape_paint.rb

@@ -0,0 +1,172 @@
+# frozen_string_literal: true
+
+module Idml
+  module Render
+    # Paints a page item's fill and stroke on a pdfrb canvas,
+    # delegating path construction to the caller's block. The
+    # single owner of the IDML → PDF paint mapping — solid fill,
+    # gradient shading fill, stroke styling — shared by every
+    # shape renderer. Callers choose the geometry (axis-aligned
+    # rectangle, Bézier contour); this module chooses the paint
+    # and the PDF paint op sequencing (fill, stroke, or
+    # fill-and-stroke on one path).
+    module ShapePaint
+      # Paints the item. The block receives the canvas and must
+      # construct the current path (move_to/line_to/curve_to/...).
+      # The block may be called more than once (a path is consumed
+      # by each paint op, so fill-then-stroke rebuilds it).
+      # Returns nil when there is nothing to paint; truthy
+      # otherwise.
+      def self.paint(canvas, item, context, &build_path)
+        fill = fill_style(item, context)
+        stroke = stroke_style(item, context)
+        return unless fill || stroke
+
+        Blending.wrap(canvas, item.transparency_setting) do
+          paint_styles(canvas, item, context, fill, stroke, &build_path)
+        end
+      end
+
+      # Returns the fill plan: { kind: :solid, color: } for a
+      # resolved color, { kind: :gradient, gradient:, stops: } for
+      # a fill referencing a Gradient, nil when nothing fillable.
+      def self.fill_style(item, context)
+        return nil unless item.fill_color
+        return nil if item.fill_color == "Color/None"
+
+        if GradientResolver.gradient?(item.fill_color)
+          gradient_fill_style(item, context)
+        else
+          solid_fill_style(item, context)
+        end
+      end
+      private_class_method :fill_style
+
+      def self.gradient_fill_style(item, context)
+        gradient = gradient_for(item, context)
+        return nil unless gradient
+
+        stops = gradient_stops(gradient, context)
+        return nil unless stops.length >= 2
+
+        { kind: :gradient, gradient: gradient, stops: stops }
+      end
+      private_class_method :gradient_fill_style
+
+      def self.solid_fill_style(item, context)
+        color = context.color_resolver&.resolve(item.fill_color)
+        return nil unless color
+
+        { kind: :solid, color: ColorHelper.to_canvas(color) }
+      end
+      private_class_method :solid_fill_style
+
+      def self.stroke_style(item, context)
+        return nil unless StrokeStyle.strokeable?(item)
+
+        color = context.color_resolver&.resolve(item.stroke_color)
+        return nil unless color
+
+        { color: ColorHelper.to_canvas(color) }
+      end
+      private_class_method :stroke_style
+
+      def self.paint_styles(canvas, item, context, fill, stroke, &)
+        if fill && stroke
+          paint_fill_and_stroke(canvas, item, context, fill, stroke,
+                                &)
+        elsif fill
+          paint_fill(canvas, item, context, fill, &)
+        else
+          paint_stroke(canvas, item, stroke, &)
+        end
+      end
+      private_class_method :paint_styles
+
+      def self.paint_fill(canvas, item, context, fill, &)
+        yield(canvas)
+        if fill[:kind] == :gradient
+          canvas.fill_shading(shading_for(canvas, item, context, fill))
+        else
+          canvas.fill_color(fill[:color])
+          canvas.fill
+        end
+      end
+      private_class_method :paint_fill
+
+      def self.paint_stroke(canvas, item, stroke, &)
+        StrokeStyle.apply(canvas, item) do
+          canvas.stroke_color(stroke[:color])
+          canvas.line_width = item.stroke_weight
+          yield(canvas)
+          canvas.stroke
+        end
+      end
+      private_class_method :paint_stroke
+
+      # Fill and stroke on one path where possible (fill_stroke);
+      # a gradient fill consumes the path, so the stroke rebuilds
+      # it afterward.
+      def self.paint_fill_and_stroke(canvas, item, context, fill, stroke,
+                                     &)
+        if fill[:kind] == :gradient
+          paint_fill(canvas, item, context, fill, &)
+          paint_stroke(canvas, item, stroke, &)
+        else
+          yield(canvas)
+          canvas.fill_color(fill[:color])
+          StrokeStyle.apply(canvas, item) do
+            canvas.stroke_color(stroke[:color])
+            canvas.line_width = item.stroke_weight
+            canvas.fill_stroke
+          end
+        end
+      end
+      private_class_method :paint_fill_and_stroke
+
+      def self.shading_for(canvas, item, context, fill)
+        box = Placement.box(item, context.page_height)
+        stops = fill[:stops]
+        if fill[:gradient].type == "Radial"
+          canvas.document.shadings.add_radial(
+            from: radial_center(box, 0.0),
+            to: radial_center(box, [box[:width], box[:height]].max / 2.0),
+            stops: stops,
+          )
+        else
+          canvas.document.shadings.add_axial(
+            from: [box[:x], box[:y] + box[:height]],
+            to: [box[:x] + box[:width], box[:y]],
+            stops: stops,
+          )
+        end
+      end
+      private_class_method :shading_for
+
+      def self.radial_center(box, radius)
+        cx = box[:x] + (box[:width] / 2.0)
+        cy = box[:y] + (box[:height] / 2.0)
+        [cx, cy, radius]
+      end
+      private_class_method :radial_center
+
+      def self.gradient_for(item, context)
+        graphic = context.package&.graphic
+        return nil unless graphic
+
+        graphic.gradient.find { |g| g.self_attr == item.fill_color }
+      end
+      private_class_method :gradient_for
+
+      def self.gradient_stops(gradient, context)
+        gradient.gradient_stop.filter_map do |stop|
+          color = context.color_resolver&.resolve(stop.stop_color)
+          next unless color
+
+          [stop.location || 0.0, ColorHelper.to_canvas(color)]
+        end
+      end
+      private_class_method :gradient_stops
+    end
+  end
+end

data/lib/idml/render/style_resolver.rb

@@ -18,7 +18,9 @@ module Idml
     class StyleResolver
       # Character-level attributes carried per run. Defaults are
       # applied at render time (e.g., DEFAULT_POINT_SIZE) — the Struct
-      # itself stores only what the CSR declares.
+      # itself stores only what the CSR declares. `footnote_number`
+      # and `footnote_paragraphs` are set only on synthesized
+      # footnote-marker runs (see Render::Footnote).
       StyledRun = Struct.new(
         :text,
         :font_style,
@@ -39,6 +41,8 @@ module Idml
         :horizontal_scale,
         :vertical_scale,
         :baseline_shift,
+        :footnote_number,
+        :footnote_paragraphs,
         keyword_init: true,
       )
 
@@ -98,27 +102,48 @@ module Idml
 
       # Returns the flat run list for a story. Each run carries only
       # character-level attributes. Paragraph boundaries are lost.
+      # Footnote markers number sequentially across the story.
       def self.extract_runs(story)
         return [] unless story&.inner
 
+        counter = Footnote.counter_for(nil)
         story.inner.paragraph_style_range.flat_map do |psr|
-          csr_runs(psr)
+          csr_runs(psr, footnote_counter: counter)
         end
       end
 
       # Returns the paragraph list for a story. Each paragraph groups
       # its runs and carries the paragraph-level attributes from the
       # owning PSR. Empty paragraphs (no runs after filtering) are
-      # skipped.
+      # skipped. Footnotes anchored in the story emit superscript
+      # marker runs, numbered sequentially from the FootnoteOption's
+      # StartAt (default 1).
       def self.extract_paragraphs(story, condition_filter: nil,
-                                  style_lookup: nil)
+                                  style_lookup: nil, footnote_option: nil)
         return [] unless story&.inner
 
-        story.inner.paragraph_style_range.filter_map do |psr|
+        extract_container_paragraphs(
+          story.inner,
+          condition_filter: condition_filter, style_lookup: style_lookup,
+          footnote_option: footnote_option
+        )
+      end
+
+      # Extracts paragraphs from any container exposing
+      # `paragraph_style_range` (StoryInner, Elements::Footnote).
+      # Footnote-counter state is shared across the whole walk so
+      # footnotes number in document order.
+      def self.extract_container_paragraphs(container, condition_filter: nil,
+                                            style_lookup: nil,
+                                            footnote_option: nil)
+        counter = Footnote.counter_for(footnote_option)
+        container.paragraph_style_range.filter_map do |psr|
           next unless condition_visible?(psr, condition_filter)
 
           runs = csr_runs(psr, condition_filter: condition_filter,
-                               style_lookup: style_lookup)
+                               style_lookup: style_lookup,
+                               footnote_counter: counter,
+                               footnote_option: footnote_option)
           next if runs.empty?
 
           paragraph = Paragraph.new(
@@ -177,43 +202,73 @@ module Idml
         end
       end
 
-      def self.csr_runs(psr, condition_filter: nil, style_lookup: nil)
-        psr.character_style_range.filter_map do |csr|
-          next unless condition_visible?(csr, condition_filter)
+      def self.csr_runs(psr, condition_filter: nil, style_lookup: nil,
+                        footnote_counter: nil, footnote_option: nil)
+        counter = footnote_counter || Footnote.counter_for(footnote_option)
+        psr.character_style_range.flat_map do |csr|
+          next [] unless condition_visible?(csr, condition_filter)
 
-          text = csr.text_content
-          next if text.nil? || text.empty?
+          csr_content_runs(csr, condition_filter: condition_filter,
+                                style_lookup: style_lookup,
+                                footnote_counter: counter,
+                                footnote_option: footnote_option)
+        end
+      end
 
-          StyledRun.new(
-            text: text,
-            font_style: resolve_csr(style_lookup, csr, :font_style),
-            point_size: resolve_csr(style_lookup, csr, :point_size) ||
-                        DEFAULT_POINT_SIZE,
-            fill_color: resolve_csr(style_lookup, csr, :fill_color),
-            fill_tint: resolve_csr(style_lookup, csr, :fill_tint),
-            applied_font: resolve_csr(style_lookup, csr, :applied_font),
-            alignment: alignment_for(csr),
-            tracking: resolve_csr(style_lookup, csr, :tracking),
-            capitalization: resolve_csr(style_lookup, csr, :capitalization),
-            position: resolve_csr(style_lookup, csr, :position),
-            underline: resolve_csr(style_lookup, csr, :underline),
-            underline_offset: resolve_csr(style_lookup, csr,
-                                          :underline_offset),
-            underline_weight: resolve_csr(style_lookup, csr,
-                                          :underline_weight),
-            strike_thru: resolve_csr(style_lookup, csr, :strike_thru),
-            strike_through_offset: resolve_csr(style_lookup, csr,
-                                               :strike_through_offset),
-            strike_through_weight: resolve_csr(style_lookup, csr,
-                                               :strike_through_weight),
-            horizontal_scale: resolve_csr(style_lookup, csr,
-                                          :horizontal_scale),
-            vertical_scale: resolve_csr(style_lookup, csr, :vertical_scale),
-            baseline_shift: resolve_csr(style_lookup, csr, :baseline_shift),
+      # Builds the runs for one CSR: its text run (when non-empty)
+      # plus one superscript marker run per anchored Footnote. A CSR
+      # holding only a footnote still emits its marker.
+      def self.csr_content_runs(csr, condition_filter:, style_lookup:,
+                                footnote_counter:, footnote_option:)
+        text = csr.text_content
+        runs = []
+        unless text.nil? || text.empty?
+          runs << text_run(csr, style_lookup: style_lookup)
+        end
+        csr.footnote.each do |element|
+          number = footnote_counter.next_number
+          paragraphs = Footnote.extract(
+            element, number, condition_filter: condition_filter,
+                             style_lookup: style_lookup,
+                             option: footnote_option
           )
+          runs << Footnote.marker_run(number, runs.last, paragraphs,
+                                      footnote_option)
         end
+        runs
+      end
+      private_class_method :csr_content_runs
+
+      def self.text_run(csr, style_lookup:)
+        StyledRun.new(
+          text: csr.text_content,
+          font_style: resolve_csr(style_lookup, csr, :font_style),
+          point_size: resolve_csr(style_lookup, csr, :point_size) ||
+            DEFAULT_POINT_SIZE,
+          fill_color: resolve_csr(style_lookup, csr, :fill_color),
+          fill_tint: resolve_csr(style_lookup, csr, :fill_tint),
+          applied_font: resolve_csr(style_lookup, csr, :applied_font),
+          alignment: alignment_for(csr),
+          tracking: resolve_csr(style_lookup, csr, :tracking),
+          capitalization: resolve_csr(style_lookup, csr, :capitalization),
+          position: resolve_csr(style_lookup, csr, :position),
+          underline: resolve_csr(style_lookup, csr, :underline),
+          underline_offset: resolve_csr(style_lookup, csr,
+                                        :underline_offset),
+          underline_weight: resolve_csr(style_lookup, csr,
+                                        :underline_weight),
+          strike_thru: resolve_csr(style_lookup, csr, :strike_thru),
+          strike_through_offset: resolve_csr(style_lookup, csr,
+                                             :strike_through_offset),
+          strike_through_weight: resolve_csr(style_lookup, csr,
+                                             :strike_through_weight),
+          horizontal_scale: resolve_csr(style_lookup, csr,
+                                        :horizontal_scale),
+          vertical_scale: resolve_csr(style_lookup, csr, :vertical_scale),
+          baseline_shift: resolve_csr(style_lookup, csr, :baseline_shift),
+        )
       end
-      private_class_method :csr_runs
+      private_class_method :text_run
 
       # Resolves a paragraph-level attribute from PSR or its
       # referenced ParagraphStyle. When style_lookup is nil,

data/lib/idml/render.rb

@@ -22,6 +22,9 @@ module Idml
     autoload :LayerFilter,         "#{__dir__}/render/layer_filter"
     autoload :ConditionFilter,     "#{__dir__}/render/condition_filter"
     autoload :TextWrapResolver,    "#{__dir__}/render/text_wrap_resolver"
+    autoload :Footnote,            "#{__dir__}/render/footnote"
+    autoload :ShapePaint,          "#{__dir__}/render/shape_paint"
+    autoload :Contour,             "#{__dir__}/render/contour"
     autoload :Placement,           "#{__dir__}/render/placement"
     autoload :ImageCollector,      "#{__dir__}/render/image_collector"
     autoload :StructureTracker,    "#{__dir__}/render/structure_tracker"

data/lib/idml/text_engine/vertical_layout.rb

@@ -54,6 +54,17 @@ module Idml
         frame.y + (frame.inset_bottom || 0)
       end
 
+      # Leading for a text block: AutoLeading × size when the
+      # paragraph declares a positive AutoLeading, else the default
+      # factor. Shared by the frame renderer and the footnote
+      # layout so both stack lines identically.
+      def self.leading_for(auto_leading, font_size)
+        return font_size * DEFAULT_LEADING_FACTOR unless
+          auto_leading&.positive?
+
+        font_size * auto_leading
+      end
+
       # Effective wrap width after subtracting insets and indents.
       def self.wrap_width(frame, right_indent = 0)
         width = frame.width - (frame.inset_left || 0) - (frame.inset_right || 0)
@@ -63,7 +74,6 @@ module Idml
       def self.frame_left(frame)
         frame.x + (frame.inset_left || 0)
       end
-      private_class_method :frame_left
     end
   end
 end

data/lib/idml/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Idml
-  VERSION = "0.8.7"
+  VERSION = "0.8.9"
 end