idml 0.8.6 → 0.8.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '04038941020b897a48513a0386fe33c4108384351a40e47e4ea50c2f09709611'
-  data.tar.gz: 5e79b2dc7e0ec38818d06b74196bfb61227e4cb80c2e5989f8b836858469db70
+  metadata.gz: ad2709aae7d11f8a91843141700ab7882b9b7a196480d7b6077fe4f0b6473d16
+  data.tar.gz: b6fd8d8df9996dabd3fd4ffbfc9fb788930cb3ca04bb6f014ae8b3c9fce5b6af
 SHA512:
-  metadata.gz: 115565aeb1f5c1da58d7a94337b3a8243da2303b4e12b25516582a7cc94065752d54df398a4f02632067b3a2b9495449911b43ee85b410d23b6a90d27e33c2ca
-  data.tar.gz: 3754116e6abce4fb0481f8fdb02edb3452df9a0a6f7ff0417ca9500ab80155b91ceea0336a37d9defe41c75963c7040b75a2774f096fc5217285d57e19e6a41a
+  metadata.gz: 20154b884fb1688985cdca3c7a3866e7c55be9059768d4a00eae4058bdd237f3606c964318d224bdd198853bc61a0a9167012b5dc6cc558f4a31537146a45a27
+  data.tar.gz: 7075c7451518b208e6ce17da854fb9954048ed40825287dc87bf4b4543467a0677a277fdf49f124703c353dfc4faf1b770de936d69acf1b0958998887a1cb101

data/TODO.pdf/102-anchored-objects.md

@@ -1,41 +1,45 @@
 # TODO PDF 102: Anchored objects (anchored object settings)
 
-## Status: OPEN — gap identified in 2026-08-08 audit
-
-## Problem
-
-`Elements::AnchoredObjectSetting` is modeled with the standard
-attributes (AnchorSpot, AnchorXunit, AnchorYunit, AnchorPoint,
-AnchorSpaceBefore, etc.). The renderer doesn't consult it.
-
-In IDML, an anchored object is a page item (Rectangle, Polygon,
-Group) that's "anchored" to a position within a story's text flow.
-When the text reflows, the anchored object moves with it. Today
-the renderer treats anchored objects as standalone page items in
-the Spread — they appear at their spread coordinates, not their
-anchored position.
-
-## What needs to happen
-
-1. Detect when a page item has an `AnchoredObjectSetting` child
-   with `AnchorType` indicating inline/anchored (vs. inline-only
-   or floating).
-2. For anchored items, suppress standalone rendering in the spread.
-3. When laying out the story that owns the anchored object, reserve
-   space at the anchor point and render the item there.
-
-This is a significant feature — anchored objects are common in
-real-world documents but rare in test fixtures.
+## Status: COMPLETE — implemented 2026-08-16
+
+## What was built
+
+- Model wiring: `anchored_object_setting` attribute + mapping on
+  Rectangle, Oval, Polygon, GraphicLine, Group, and Path (per
+  `*_Object` in Story.rnc — every page item can carry
+  `<AnchoredObjectSetting>`). The setting parses AnchoredPosition
+  (InlinePosition / AboveLine / Anchored), AnchorPoint,
+  AnchorXoffset / AnchorYoffset, Horizontal/VerticalReferencePoint,
+  and the remaining schema attributes.
+- `CharacterStyleRange` now models its story-embedded page-item
+  children: `rectangle`, `oval`, `polygon`, `graphic_line`,
+  `group`, `text_frame` collections. Previously these elements were
+  dropped at parse time — anchored objects were lost entirely.
+- Rendering: `TextFrameRenderer` discovers embedded items via the
+  shared `story_csrs` walk and renders each through
+  `PageItemRenderer` dispatch (fill, stroke, gradients, images —
+  everything the spread-level path does) with a child context.
+  Items render at their own stored geometry: InDesign resolves an
+  anchored object's position when saving the file, so the stored
+  ItemTransform + PathGeometry IS the anchored position for all
+  three AnchorTypes.
+
+## Known limitations
+
+- AnchorType-specific text reflow is not simulated: the layout
+  engine positions body text independently of embedded items, so
+  body text may overlap inline/above-line objects in frames whose
+  stored text positions differ from our layout engine's output.
+- HorizontalReferencePoint / VerticalReferencePoint /
+  HorizontalAlignment / VerticalAlignment on the setting are parsed
+  but not consulted (stored geometry already encodes the result).
 
 ## Acceptance criteria
 
-- [ ] Page item with AnchoredObjectSetting AnchorType="Inline" renders
-      at the anchor character's position within the text flow.
-- [ ] Page item with AnchorType="Above Line" renders above the line
-      containing the anchor.
-- [ ] Page item with AnchorType="Anchored" renders at the absolute
-      position derived from AnchorXunit / AnchorYunit.
-
-## Dependencies
-
-- TODO 94 (need to know character positions in the text flow).
+- [x] Page item with AnchoredObjectSetting AnchorType="Inline"
+      renders at its anchored position (stored geometry).
+- [x] Page item with AnchorType="Above Line" renders above the
+      anchored line (stored geometry).
+- [x] Page item with AnchorType="Anchored" renders at the position
+      derived from the anchor (stored geometry; AnchorX/Yoffset
+      parsing verified).

data/TODO.pdf/111-footnote-support.md

@@ -1,40 +1,50 @@
 # TODO PDF 111: Footnote support
 
-## Status: OPEN — gap identified in 2026-08-09 audit
-
-## Problem
-
-IDML has full footnote support:
-- `<Footnote>` elements in Stories (inline footnote markers + text)
-- `<FootnoteOption>` on PSR (numbering rules, layout)
-- `TextFramePreference.FootnotesEnableOverrides`,
-  `FootnotesSpanAcrossColumns`, `FootnotesMinimumSpacing`,
-  `FootnotesSpaceBetween` — frame-level footnote layout
-- `<TextFrameFootnoteOptionsObject>` — per-frame footnote config
-
-The renderer doesn't model footnote content or lay it out.
-Documents with footnotes (academic, legal, technical) currently
-lose footnote text in the PDF.
-
-## What needs to happen
-
-1. Model `<Footnote>` element (story-embedded footnote text +
-   reference marker).
-2. Story parsing extracts footnotes alongside main text.
-3. Footnote text renders at the bottom of the page that contains
-   the reference marker.
-4. Footnote numbering rules from FootnoteOption honored.
-5. Continuous footnotes flow across pages.
-
-This is a large feature — defer until needed by a real fixture.
+## Status: COMPLETE — implemented 2026-08-16
+
+## What was built
+
+- `Elements::Footnote` — schema-faithful model of `Footnote_Object`
+  (Story.rnc): no attributes, PSR/CSR children carrying the footnote
+  text. Wired into `CharacterStyleRange` and `StoryInner` (`footnote`
+  collection). Footnote text is excluded from `text_content` so it
+  never leaks into body text.
+- `Render::Footnote` — footnote semantics unit (MECE):
+  - `Counter`: story-scoped sequential numbering, honoring
+    FootnoteOption `StartAt`.
+  - `marker_run`: superscript marker emitted into the body text at the
+    anchoring CSR's position; inherits the CSR's character styling.
+  - `extract`: footnote paragraphs via StyleResolver with the marker
+    text (`Prefix + number + Suffix`) prefixed to the first run.
+  - `layout_entries` / `reserved_height`: one shared Shaper →
+    LineBreaker → VerticalLayout walk drives both height measurement
+    and rendering, so the reserved area always matches what's drawn.
+  - `emit_separator`: separator rule honoring FootnoteOption RuleOn /
+    RuleLineWeight / RuleWidth / RuleLeftIndent.
+- `TextFrameRenderer`: marker runs are collected during body layout
+  (`register_footnote`), each raising the effective bottom limit so
+  body text avoids the footnote area (incremental reservation,
+  InDesign-style); after body layout, `render_footnote_entries` draws
+  the separator and the footnote paragraphs above the frame's content
+  bottom. Per-column in multi-column frames.
+- `FootnoteOption` (Preferences.xml) honored: StartAt, Prefix, Suffix,
+  RuleOn, RuleLineWeight, RuleWidth, RuleLeftIndent, Spacer
+  (separator gap), SpaceBetween (inter-entry gap).
+
+## Known limitations
+
+- Numbering restarts per story; document-wide continuous numbering
+  and per-section restart are not modeled.
+- Footnote overflow balancing (a footnote too tall for its frame
+  moving wholly to the next frame, NoSplitting) is not modeled.
+- The simple-render fallback (no font metrics) shows markers inline
+  but does not render footnote text at the frame bottom.
+- Footnotes nested in CSRs inside CSRs (CSR > CSR > Footnote) are
+  not extracted; only direct CSR children emit markers.
 
 ## Acceptance criteria
 
-- [ ] Footnote text rendered at bottom of containing page.
-- [ ] Footnote marker in body text links to footnote text.
-- [ ] Numbering restarts per document section per FootnoteOption.
-
-## Dependencies
-
-- TODO 108 (multi-frame story flow) — footnotes need to know which
-  page a reference appears on.
+- [x] Footnote text rendered at bottom of containing frame.
+- [x] Footnote marker in body text (superscript, numbered).
+- [x] Numbering honors FootnoteOption StartAt / Prefix / Suffix
+      (per-story scope).

data/TODO.pdf/114-text-wrap-around-shapes.md

@@ -1,12 +1,20 @@
 # TODO PDF 114: Text wrap around shapes (TextWrapPreference)
 
-## Status: PARTIAL — `Render::TextWrapResolver` computes BoundingBox-mode
-contours from page items declaring TextWrapPreference.
-`overlap_width(line_y, line_height, frame_x, frame_right)` returns the
-horizontal overlap for a text line. Rectangle now carries the
-TextWrapPreference child. Integration with TextFrameRenderer
-(per-line wrap width adjustment during layout) is the remaining work —
-requires line-by-line contour queries in the layout pipeline.
+## Status: DONE for BoundingBox mode — `Render::TextWrapResolver` computes
+wrap contours from page items declaring TextWrapPreference with
+TextWrapMode != "None". SpreadRenderer builds the resolver and passes
+it via RenderContext. TextFrameRenderer's `text_wrap_overlap` queries
+overlap at each run's y position and reduces the wrap width — text
+flows around the shape instead of running over it.
+
+Shape page items (Rectangle, Oval, Polygon, GraphicLine, Path) all
+carry the TextWrapPreference child element. Non-shape items (Page,
+Link) are filtered by WRAPPABLE_TYPES to avoid NoMethodError.
+
+Per-run approximation: all lines in a run get the same reduced width.
+True per-line adjustment (when a run spans the contour boundary)
+requires line-count-aware layout. Shape mode (contour following) and
+Inverse mode remain unsupported.
 
 ## Problem
 

data/lib/idml/elements/character_style_range.rb

@@ -300,6 +300,17 @@ module Idml
                 collection: true
       attribute :table, Idml::Elements::Table, collection: true
       attribute :xml_element, Idml::Elements::XmlElement, collection: true
+      attribute :footnote, Idml::Elements::Footnote, collection: true
+      # Anchored page items embedded in the story flow. Their
+      # AnchoredObjectSetting (child of each item) declares how the
+      # item anchors to the surrounding text.
+      attribute :rectangle, Idml::Elements::Rectangle, collection: true
+      attribute :oval, Idml::Elements::Oval, collection: true
+      attribute :polygon, Idml::Elements::Polygon, collection: true
+      attribute :graphic_line, Idml::Elements::GraphicLine,
+                collection: true
+      attribute :group, Idml::Elements::Group, collection: true
+      attribute :text_frame, Idml::Elements::TextFrame, collection: true
 
       xml do
         root "CharacterStyleRange"
@@ -655,6 +666,13 @@ module Idml
         map_element "HyperlinkTextSource", to: :hyperlink_text_source
         map_element "Table", to: :table
         map_element "XMLElement", to: :xml_element
+        map_element "Footnote", to: :footnote
+        map_element "Rectangle", to: :rectangle
+        map_element "Oval", to: :oval
+        map_element "Polygon", to: :polygon
+        map_element "GraphicLine", to: :graphic_line
+        map_element "Group", to: :group
+        map_element "TextFrame", to: :text_frame
       end
 
       def text_content

data/lib/idml/elements/footnote.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Idml
+  module Elements
+    # `<Footnote>` — story-embedded footnote content. Schema-faithful
+    # model of `Footnote_Object` in
+    # `reference-docs/schemas/package/Stories/Story.rnc`: the element
+    # declares no attributes; its children are HiddenText /
+    # GaijiOwnedItemObject / Table / TextVariableInstance /
+    # ParagraphStyleRange / CharacterStyleRange. Of these, the
+    # ParagraphStyleRange (with its CSR children) and
+    # CharacterStyleRange children carry the footnote text; the rest
+    # are parsed by their own models where relevant.
+    #
+    # A Footnote sits inside the CharacterStyleRange that owns the
+    # anchor position: the body-text marker renders where the CSR's
+    # text ends, and the Footnote's paragraphs render at the bottom
+    # of the frame holding that marker (see Render::Footnote).
+    class Footnote < Lutaml::Model::Serializable
+      attribute :paragraph_style_range, Idml::Elements::ParagraphStyleRange,
+                collection: true
+      attribute :character_style_range, Idml::Elements::CharacterStyleRange,
+                collection: true
+
+      xml do
+        root "Footnote"
+        map_element "ParagraphStyleRange", to: :paragraph_style_range
+        map_element "CharacterStyleRange", to: :character_style_range
+      end
+    end
+  end
+end

data/lib/idml/elements/graphic_line.rb

@@ -18,6 +18,9 @@ module Idml
       attribute :item_layer, :string
       attribute :properties, Idml::Elements::Properties, collection: true
       attribute :transparency_setting, Idml::Elements::TransparencySetting
+      attribute :text_wrap_preference, Idml::Elements::TextWrapPreference
+      attribute :anchored_object_setting,
+                Idml::Elements::AnchoredObjectSetting
 
       xml do
         root "GraphicLine"
@@ -34,6 +37,8 @@ module Idml
         map_attribute "ItemLayer", to: :item_layer
         map_element "Properties", to: :properties
         map_element "TransparencySetting", to: :transparency_setting
+        map_element "TextWrapPreference", to: :text_wrap_preference
+        map_element "AnchoredObjectSetting", to: :anchored_object_setting
       end
 
       def geometric_bounds

data/lib/idml/elements/group.rb

@@ -10,6 +10,8 @@ module Idml
       attribute :item_transform, :string
       attribute :visible, :boolean
       attribute :item_layer, :string
+      attribute :anchored_object_setting,
+                Idml::Elements::AnchoredObjectSetting
       attribute :rectangle, Idml::Elements::Rectangle, collection: true
       attribute :text_frame, Idml::Elements::TextFrame, collection: true
       attribute :polygon, Idml::Elements::Polygon, collection: true
@@ -22,6 +24,7 @@ module Idml
         map_attribute "ItemTransform", to: :item_transform
         map_attribute "Visible", to: :visible
         map_attribute "ItemLayer", to: :item_layer
+        map_element "AnchoredObjectSetting", to: :anchored_object_setting
         map_element "Rectangle", to: :rectangle
         map_element "TextFrame", to: :text_frame
         map_element "Polygon", to: :polygon

data/lib/idml/elements/oval.rb

@@ -29,6 +29,9 @@ module Idml
       attribute :item_layer, :string
       attribute :properties, Idml::Elements::Properties, collection: true
       attribute :transparency_setting, Idml::Elements::TransparencySetting
+      attribute :text_wrap_preference, Idml::Elements::TextWrapPreference
+      attribute :anchored_object_setting,
+                Idml::Elements::AnchoredObjectSetting
       attribute :image, Idml::Elements::Image, collection: true
 
       xml do
@@ -50,6 +53,8 @@ module Idml
         map_attribute "ItemLayer", to: :item_layer
         map_element "Properties", to: :properties
         map_element "TransparencySetting", to: :transparency_setting
+        map_element "TextWrapPreference", to: :text_wrap_preference
+        map_element "AnchoredObjectSetting", to: :anchored_object_setting
         map_element "Image", to: :image
       end
 

data/lib/idml/elements/path.rb

@@ -25,6 +25,9 @@ module Idml
       attribute :item_layer, :string
       attribute :properties, Idml::Elements::Properties, collection: true
       attribute :transparency_setting, Idml::Elements::TransparencySetting
+      attribute :text_wrap_preference, Idml::Elements::TextWrapPreference
+      attribute :anchored_object_setting,
+                Idml::Elements::AnchoredObjectSetting
 
       xml do
         root "Path"
@@ -41,6 +44,8 @@ module Idml
         map_attribute "ItemLayer", to: :item_layer
         map_element "Properties", to: :properties
         map_element "TransparencySetting", to: :transparency_setting
+        map_element "TextWrapPreference", to: :text_wrap_preference
+        map_element "AnchoredObjectSetting", to: :anchored_object_setting
       end
 
       def geometric_bounds

data/lib/idml/elements/polygon.rb

@@ -20,6 +20,9 @@ module Idml
       attribute :item_layer, :string
       attribute :properties, Idml::Elements::Properties, collection: true
       attribute :transparency_setting, Idml::Elements::TransparencySetting
+      attribute :text_wrap_preference, Idml::Elements::TextWrapPreference
+      attribute :anchored_object_setting,
+                Idml::Elements::AnchoredObjectSetting
       attribute :image, Idml::Elements::Image, collection: true
 
       xml do
@@ -39,6 +42,8 @@ module Idml
         map_attribute "ItemLayer", to: :item_layer
         map_element "Properties", to: :properties
         map_element "TransparencySetting", to: :transparency_setting
+        map_element "TextWrapPreference", to: :text_wrap_preference
+        map_element "AnchoredObjectSetting", to: :anchored_object_setting
         map_element "Image", to: :image
       end
 

data/lib/idml/elements/rectangle.rb

@@ -25,6 +25,8 @@ module Idml
       attribute :properties, Idml::Elements::Properties, collection: true
       attribute :transparency_setting, Idml::Elements::TransparencySetting
       attribute :text_wrap_preference, Idml::Elements::TextWrapPreference
+      attribute :anchored_object_setting,
+                Idml::Elements::AnchoredObjectSetting
       attribute :image, Idml::Elements::Image, collection: true
 
       xml do
@@ -48,6 +50,7 @@ module Idml
         map_element "Properties", to: :properties
         map_element "TransparencySetting", to: :transparency_setting
         map_element "TextWrapPreference", to: :text_wrap_preference
+        map_element "AnchoredObjectSetting", to: :anchored_object_setting
         map_element "Image", to: :image
       end
 

data/lib/idml/elements/story_inner.rb

@@ -312,6 +312,7 @@ module Idml
                 collection: true
       attribute :content, Idml::Elements::Content, collection: true
       attribute :xml_element, Idml::Elements::XmlElement, collection: true
+      attribute :footnote, Idml::Elements::Footnote, collection: true
 
       xml do
         root "Story"
@@ -676,6 +677,7 @@ module Idml
         map_element "CharacterStyleRange", to: :character_style_range
         map_element "Content", to: :content
         map_element "XMLElement", to: :xml_element
+        map_element "Footnote", to: :footnote
       end
 
       def text_content

data/lib/idml/elements.rb

@@ -54,6 +54,7 @@ module Idml
              "idml/elements/flex_layout_attribute_option"
     autoload :Font, "idml/elements/font"
     autoload :FontFamily, "idml/elements/font_family"
+    autoload :Footnote, "idml/elements/footnote"
     autoload :FootnoteOption, "idml/elements/pref_footnote_option"
     autoload :FrameFittingOption, "idml/elements/frame_fitting_option"
     autoload :GraphicLine, "idml/elements/graphic_line"

data/lib/idml/render/footnote.rb

@@ -0,0 +1,211 @@
+# frozen_string_literal: true
+
+module Idml
+  module Render
+    # Footnote semantics: story-scoped numbering, body-text marker
+    # synthesis, footnote-paragraph extraction, and the geometry of
+    # the bottom-of-frame footnote area (height reservation +
+    # separator rule). Emission of footnote text lines stays in
+    # TextFrameRenderer — it owns all canvas text drawing — while
+    # this module owns everything footnote-specific (MECE).
+    #
+    # Numbering is sequential per story, honoring FootnoteOption's
+    # StartAt / Prefix / Suffix when the package declares them.
+    # Document-wide continuous numbering and per-section restart
+    # are not modeled.
+    module Footnote
+      # One footnote collected during a frame's layout: its number
+      # and its extracted (already marker-prefixed) paragraphs.
+      Entry = Struct.new(:number, :paragraphs, keyword_init: true)
+
+      # A positioned footnote line plus the run it came from — the
+      # unit TextFrameRenderer emits.
+      PositionedRun = Struct.new(:line, :run, :font_size, keyword_init: true)
+
+      # Story-scoped sequential counter. Mutated as csr_runs walks
+      # the story's style ranges so footnotes number in document
+      # order across paragraphs.
+      class Counter
+        def initialize(start_at = nil)
+          @next = start_at || 1
+        end
+
+        def next_number
+          value = @next
+          @next += 1
+          value
+        end
+      end
+
+      DEFAULT_RULE_WEIGHT = 0.5
+      DEFAULT_RULE_GAP = 3.0
+      MARKER_TEXT_SEPARATOR = " "
+
+      # Returns the package's FootnoteOption (Preferences.xml), or
+      # nil when the package doesn't declare one.
+      def self.option(package)
+        preferences = package&.preferences
+        preferences&.footnote_option&.first
+      end
+
+      def self.counter_for(option)
+        Counter.new(option&.start_at)
+      end
+
+      # Marker text shown in the body text (and prefixed to the
+      # footnote's first paragraph): Prefix + number + Suffix.
+      def self.marker_text(number, option)
+        "#{option&.prefix}#{number}#{option&.suffix}"
+      end
+
+      # Builds the superscript marker run emitted into the body
+      # text where the footnote anchors. Inherits the base run's
+      # character styling so the marker matches its context; when
+      # the owning CSR has no text run, falls back to defaults.
+      def self.marker_run(number, base, paragraphs, option)
+        marker = base || StyleResolver::StyledRun.new(
+          point_size: StyleResolver::DEFAULT_POINT_SIZE,
+        )
+        marker = marker.dup
+        marker.text = marker_text(number, option)
+        marker.position = "Superscript"
+        marker.footnote_number = number
+        marker.footnote_paragraphs = paragraphs
+        marker
+      end
+
+      # Extracts the footnote's paragraphs via StyleResolver and
+      # prefixes the first paragraph's first run with the marker
+      # text ("1 ", "n2." …) so the footnote reads as numbered.
+      def self.extract(element, number, condition_filter: nil,
+                       style_lookup: nil, option: nil)
+        paragraphs = StyleResolver.extract_container_paragraphs(
+          element, condition_filter: condition_filter,
+                   style_lookup: style_lookup
+        )
+        marker = marker_text(number, option)
+        prepend_marker(paragraphs, marker) unless marker.empty?
+        paragraphs
+      end
+
+      def self.prepend_marker(paragraphs, marker)
+        return if paragraphs.empty?
+        return if paragraphs.first.runs.empty?
+
+        first_run = paragraphs.first.runs.first
+        first_run.text = "#{marker}#{MARKER_TEXT_SEPARATOR}#{first_run.text}"
+      end
+      private_class_method :prepend_marker
+
+      # Lays out all entries' paragraphs top-down starting at
+      # `top_y`. Returns `[positioned_runs, bottom_y]` where
+      # bottom_y is the cursor after the last line — the same walk
+      # drives both height measurement and rendering, so the
+      # reserved area always matches what gets drawn.
+      def self.layout_entries(entries, frame, font, top_y, option = nil)
+        positioned = []
+        cursor = top_y
+        wrap_width = TextEngine::VerticalLayout.wrap_width(frame)
+
+        entries.each_with_index do |entry, index|
+          cursor -= (option&.space_between || 0).to_f if index.positive?
+          entry.paragraphs.each do |paragraph|
+            cursor = layout_paragraph(
+              paragraph, frame, font, wrap_width, cursor, positioned
+            )
+          end
+        end
+        [positioned, cursor]
+      end
+
+      # Shapes, wraps, and positions one footnote paragraph,
+      # appending its positioned lines. Returns the next cursor.
+      def self.layout_paragraph(paragraph, frame, font, wrap_width, cursor,
+                                positioned)
+        paragraph.runs.each do |run|
+          size = run.point_size || StyleResolver::DEFAULT_POINT_SIZE
+          glyphs = TextEngine::Shaper.shape(text: run.text, font: font,
+                                            size: size)
+          lines = TextEngine::LineBreaker.break(glyphs: glyphs,
+                                                frame_width: wrap_width)
+          lines.each do |line|
+            TextEngine::Justifier.justify(
+              line: line, frame_width: wrap_width,
+              alignment: paragraph.alignment || :left
+            )
+          end
+          leading = TextEngine::VerticalLayout.leading_for(
+            paragraph.auto_leading, size
+          )
+          block, cursor = TextEngine::VerticalLayout.layout_block(
+            lines: lines, frame: frame, font_size: size, leading: leading,
+            cursor_y: cursor
+          )
+          block.each do |line|
+            positioned << PositionedRun.new(line: line, run: run,
+                                            font_size: size)
+          end
+        end
+        cursor
+      end
+      private_class_method :layout_paragraph
+
+      # Height to reserve at the frame bottom for the entries:
+      # separator gap + the measured paragraph stack.
+      def self.reserved_height(entries, font, frame, option = nil)
+        return 0.0 if entries.empty?
+
+        content_bottom = TextEngine::VerticalLayout.bottom_limit(frame)
+        _, bottom_y = layout_entries(entries, frame, font, content_bottom,
+                                     option)
+        content_bottom - bottom_y + rule_gap(option)
+      end
+
+      # Vertical distance between the footnote area's top edge and
+      # the first footnote line — room for the separator rule.
+      def self.rule_gap(option)
+        option&.spacer || DEFAULT_RULE_GAP
+      end
+
+      # Emits the separator rule at the top of the footnote area.
+      # Honors FootnoteOption RuleOn / RuleLineWeight / RuleWidth /
+      # RuleLeftIndent; defaults approximate InDesign (0.5pt rule
+      # spanning the column).
+      def self.emit_separator(canvas, frame, y, option)
+        return if option&.rule_on == false
+
+        thickness = separator_weight(option)
+        return unless thickness.positive?
+
+        stroke_rule(canvas, separator_left(frame, option), y,
+                    separator_width(frame, option), thickness)
+      end
+
+      def self.separator_weight(option)
+        (option&.rule_line_weight || DEFAULT_RULE_WEIGHT).to_f
+      end
+      private_class_method :separator_weight
+
+      def self.separator_left(frame, option)
+        TextEngine::VerticalLayout.frame_left(frame) +
+          (option&.rule_left_indent || 0).to_f
+      end
+      private_class_method :separator_left
+
+      def self.separator_width(frame, option)
+        option&.rule_width ||
+          TextEngine::VerticalLayout.wrap_width(frame)
+      end
+      private_class_method :separator_width
+
+      def self.stroke_rule(canvas, left, y, width, thickness)
+        canvas.stroke_color([:gray, 1.0])
+        canvas.line_width = thickness
+        canvas.move_to(left, y)
+        canvas.line_to(left + width, y)
+        canvas.stroke
+      end
+      private_class_method :stroke_rule
+    end
+  end
+end

data/lib/idml/render/render_context.rb

@@ -23,6 +23,7 @@ module Idml
       :chain_controller,
       :condition_filter,
       :style_lookup,
+      :text_wrap_resolver,
       keyword_init: true,
     )
   end

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
@@ -436,20 +480,92 @@ module Idml
                                                   rendered_count)
             run_wrap = drop_cap_wrap_width(wrap_width, dc_width,
                                            dc_lines, rendered_count)
+            run_wrap -= text_wrap_overlap(context, layout_frame, cursor_y,
+                                          run)
             positioned, next_y = layout_run(
               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
+        # contours overlap. Per-run approximation: all lines in the
+        # run get the same reduced width (correct when the run is
+        # fully inside or outside the contour; approximate when it
+        # spans the boundary).
+        def self.text_wrap_overlap(context, layout_frame, cursor_y, run)
+          resolver = context.text_wrap_resolver
+          return 0.0 unless resolver
+
+          size = run.point_size || DEFAULT_SIZE
+          frame_x = layout_frame.x + (layout_frame.inset_left || 0)
+          frame_right = layout_frame.x + layout_frame.width -
+            (layout_frame.inset_right || 0)
+          overlap = resolver.overlap_width(cursor_y, size,
+                                           frame_x, frame_right)
+          [overlap, 0.0].max
+        end
+        private_class_method :text_wrap_overlap
+
         # Strips drop cap characters from the first run so they don't
         # render twice (once as the enlarged drop cap, once as normal
         # text). Returns a new run list with the first run's text
@@ -571,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,
@@ -598,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
 
@@ -641,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/spread_renderer.rb

@@ -39,6 +39,7 @@ module Idml
           chain_controller: StoryChainController.new,
           condition_filter: @condition_filter,
           style_lookup: @style_lookup,
+          text_wrap_resolver: build_text_wrap_resolver(spread, page_height),
         }
         images_by_parent = group_images_by_parent(image_refs)
 
@@ -144,6 +145,10 @@ module Idml
 
         ColorResolver.new(@package.graphic)
       end
+
+      def build_text_wrap_resolver(spread, page_height)
+        TextWrapResolver.build(spread, page_height: page_height)
+      end
     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/text_wrap_resolver.rb

@@ -66,16 +66,35 @@ module Idml
       end
       private_class_method :contour_for
 
+      # Page item types that can declare TextWrapPreference per the
+      # Spread schema. Used to guard the attribute read — querying
+      # non-shape items (Page, Link) would raise NoMethodError.
+      WRAPPABLE_TYPES = [
+        Idml::Elements::Rectangle,
+        Idml::Elements::Oval,
+        Idml::Elements::Polygon,
+        Idml::Elements::GraphicLine,
+        Idml::Elements::Path,
+        Idml::Elements::Group,
+      ].freeze
+
       def self.wrap_preference(item)
-        pref = item.text_wrap_preference if item.is_a?(Lutaml::Model::Serializable)
-        return nil unless pref
-        return nil if pref.text_wrap_mode.nil? ||
+        return nil unless wrappable?(item)
+
+        pref = item.text_wrap_preference
+        return nil if pref.nil? ||
+          pref.text_wrap_mode.nil? ||
           pref.text_wrap_mode == "None"
 
         pref
       end
       private_class_method :wrap_preference
 
+      def self.wrappable?(item)
+        WRAPPABLE_TYPES.any? { |type| item.is_a?(type) }
+      end
+      private_class_method :wrappable?
+
       def self.bounding_box_mode?(pref)
         pref.text_wrap_mode == "BoundingBox"
       end

data/lib/idml/render.rb

@@ -22,6 +22,7 @@ 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 :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.6"
+  VERSION = "0.8.8"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: idml
 version: !ruby/object:Gem::Version
-  version: 0.8.6
+  version: 0.8.8
 platform: ruby
 authors:
 - Ribose
@@ -296,6 +296,7 @@ files:
 - lib/idml/elements/flex_layout_attribute_option.rb
 - lib/idml/elements/font.rb
 - lib/idml/elements/font_family.rb
+- lib/idml/elements/footnote.rb
 - lib/idml/elements/frame_fitting_option.rb
 - lib/idml/elements/geometry_path_type.rb
 - lib/idml/elements/gradient.rb
@@ -441,6 +442,7 @@ files:
 - lib/idml/render/drop_cap.rb
 - lib/idml/render/font_reference_resolver.rb
 - lib/idml/render/font_setup.rb
+- lib/idml/render/footnote.rb
 - lib/idml/render/gradient_resolver.rb
 - lib/idml/render/hyperlink_emitter.rb
 - lib/idml/render/hyperlink_resolver.rb