idml 0.7.0 → 0.7.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0f40610210789018b1fbe0625c1541cfe3611169d0004543891ebb9efd6c74ea
-  data.tar.gz: 6998d5c66bd56eed147dfb88d60a602be32fee2adb9b9fa9f08413af4cb2103f
+  metadata.gz: c6cc7058e67830e2dc6ea523ea6ca054f702ce29b51989a19deb023e5a840bee
+  data.tar.gz: 434b5af5ea49b9f2b48728b100b612ff0cd784079abfd6d419dbeb16554b3ebb
 SHA512:
-  metadata.gz: 02c03bf2c81b2ebb81b04ae4b413b25d484adf806b1d8c7c0768e557323bca7c30de46d5174cff27c90e2275f6f89070ac5f981df567cb20867e5c17382b0c42
-  data.tar.gz: 642103e8e48d2b5b52a4b669d7e09329f5706e4f165f4da8de6df51ef38125686ca75db28de194a974f94cdc9273a193c76a653bf8727b3a16f6b5ac2a9c5f3c
+  metadata.gz: a59cabfafa44138cb40ed8b6e493396c110ffe43728c0d0ea94d8ef4d8039efad635ba23660852b1040b58ce7141b6e301bf27ecb96599efd6d72069e6d81a95
+  data.tar.gz: d142ebcfc9eb6591827c72d3cd33303ee3a4c70637031b03622ea1355d453cac4aac1654f60ee7a3ee54a050755e88fb84c32c01df11df802c434442c0f9a4e2

data/TODO.pdf/101-paragraph-rules-borders.md

@@ -1,6 +1,15 @@
 # TODO PDF 101: Paragraph borders and rules (RuleAbove, RuleBelow, ParagraphBorder)
 
-## Status: OPEN — gap identified in 2026-08-08 audit
+## Status: PARTIAL — RuleAbove and RuleBelow implemented via new
+`Render::ParagraphRules` helper; TextFrameRenderer emits them at
+paragraph top/bottom. Rule color comes from PSR#stroke_color (IDML's
+PSR doesn't have a dedicated RuleAboveColor attribute). RuleAboveWidth
+"Text" vs "Column" honored. Tint scaling + line weight + offset honored.
+
+ParagraphBorder and ParagraphShading remain open — they need the
+paragraph's bounding rect, which the renderer doesn't currently
+expose to ParagraphRules. Will add when a real document fixture
+exercises them.
 
 ## Problem
 

data/TODO.pdf/108-multi-frame-story-flow.md

@@ -0,0 +1,54 @@
+# TODO PDF 108: Multi-frame story flow (use StoryThreader)
+
+## Status: DONE — `Render::StoryChainController` threads paragraph/run
+state across linked TextFrames. TextFrameRenderer no longer treats
+chain non-heads as standalone; it picks up leftover state from the
+controller, renders what fits, and stores the new leftover for the
+next frame. Overflow text is no longer silently dropped.
+
+## Problem
+
+`Render::StoryThreader` exists with specs (`spec/idml/render_layer_threader_spec.rb`).
+It builds text-frame chains from PreviousTextFrame/NextTextFrame
+links. The intent: a story flows across linked frames, with each
+frame getting the lines that fit and overflow going to the next.
+
+But `TextFrameRenderer` doesn't use it. The renderer treats each
+frame independently:
+- `chain_head?` filter skips non-head frames (correct — they'd
+  double-render)
+- Each chain-head frame renders its entire story from the top
+- Overflow that doesn't fit is silently dropped
+
+For real documents with multi-page stories (books, magazines,
+newspapers), this loses text. The PDF shows only what fits in the
+first frame.
+
+## What needs to happen
+
+1. TextFrameRenderer accepts the chain (list of frames) instead
+   of one frame at a time.
+2. For each chain:
+   - Lay out story text starting at frame 1's top
+   - When text overflows frame 1's bottom, continue at frame 2's top
+   - Repeat until either text ends or chain ends
+3. The PageItemRenderer dispatch needs to know about chains, not
+   just per-item rendering.
+
+Architecture: the chain context needs to live in RenderContext
+(or a new RenderChainContext). Each frame's render call passes the
+current y cursor + remaining paragraphs/runs/lines, and the next
+frame's render call picks up where the previous left off.
+
+## Acceptance criteria
+
+- [ ] Story that overflows frame 1 continues in frame 2.
+- [ ] Hyperlink rects resolve correctly across frames.
+- [ ] Spec: 2 linked TextFrames, story of 50 lines, each frame fits
+      20 lines → frame 1 shows lines 1-20, frame 2 shows 21-40,
+      frame 3 (if present) shows 41-50.
+
+## Dependencies
+
+- None — independent feature work, but changes the renderer's
+  per-frame abstraction significantly.

data/TODO.pdf/109-dry-color-tint.md

@@ -0,0 +1,42 @@
+# TODO PDF 109: DRY color tint application (ColorHelper vs CharacterStyle vs ParagraphRules)
+
+## Status: DONE — `ColorHelper.apply_tint(color, tint)` is the single
+canonical tint helper. CharacterStyle and ParagraphRules both delegate
+to it. 7 new specs cover nil tint, tint >= 1.0, RGB/CMYK scaling,
+tint 0.0, unknown models, nil input.
+
+## Problem
+
+Color tint (scaling a color's components toward zero) is implemented
+in three places with slightly different shapes:
+
+1. `Render::CharacterStyle.apply_tint(color, tint)` — used for
+   text fill color.
+2. `Render::ParagraphRules.scale_color(color, tint_value)` — used
+   for paragraph rule colors.
+3. (Implicit) `Render::ColorResolver` resolves tints on its own
+   when reading ColorValue, before returning the color hash.
+
+The first two are essentially the same logic with different method
+names. The third means a `ColorResolver.resolve` result might or
+might not have tint already applied — callers can't tell.
+
+## What needs to happen
+
+1. Pick one canonical tint helper. Either:
+   - Move to `ColorHelper.apply_tint(color, tint)`, or
+   - Create `Render::ColorTint.apply(color, tint)`.
+2. CharacterStyle and ParagraphRules call the canonical helper.
+3. ColorResolver documents whether it applies tint or returns raw
+   colors (today it appears to apply tint internally).
+
+## Acceptance criteria
+
+- [ ] Single tint helper in one place.
+- [ ] CharacterStyle and ParagraphRules both delegate to it.
+- [ ] ColorResolver's tint behavior is documented.
+- [ ] Spec coverage for tint 0.0, 0.5, 1.0 on RGB and CMYK colors.
+
+## Dependencies
+
+- None — pure refactor.

data/TODO.pdf/110-conditional-text.md

@@ -0,0 +1,43 @@
+# TODO PDF 110: Conditional text (AppliedConditions)
+
+## Status: DONE — `Elements::Condition` models the `<Condition>`
+element from designmap.rnc. `Render::ConditionFilter` indexes
+conditions by Self and answers `visible?(applied_conditions_string)`
+per run. `StyleResolver.extract_paragraphs` takes optional
+`condition_filter:` kwarg and drops PSRs/CSRs whose AppliedConditions
+reference a hidden Condition. Pipeline constructs the filter from
+`designmap.condition` and threads it through RenderContext.
+
+## Problem
+
+PSR and CSR both carry an `AppliedConditions` attribute (a list of
+condition Self IDs). In InDesign, conditions let authors mark text
+as conditional (e.g., "show only in instructor edition", "draft
+review comments"). Each `<Condition>` in Resources/Styles.xml
+declares whether it's visible, its highlight color, etc.
+
+Today the renderer ignores `AppliedConditions` — all conditional
+text renders regardless of condition visibility. For documents that
+use conditions heavily (textbooks, legal, regulatory), this means
+the PDF always shows every variant instead of the chosen subset.
+
+## What needs to happen
+
+1. Verify `Elements::Condition` exists in the model (Resources/Styles.rnc).
+2. Add `Render::ConditionFilter` that reads visible conditions from
+   Resources/Styles.xml.
+3. StyleResolver filters PSRs/CSRs whose AppliedConditions reference
+   a hidden condition.
+4. Spec: PSR with condition A (hidden) doesn't render; condition B
+   (visible) renders.
+
+## Acceptance criteria
+
+- [ ] Condition model from RNC.
+- [ ] ConditionFilter.from_styles(graphic_or_styles).
+- [ ] StyleResolver.extract_paragraphs takes optional ConditionFilter.
+- [ ] Hidden-condition runs filtered out.
+
+## Dependencies
+
+- None — pure feature work on existing models.

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

@@ -0,0 +1,40 @@
+# 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.
+
+## 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.

data/lib/idml/elements/condition.rb

@@ -0,0 +1,31 @@
+# frozen_string: true
+
+module Idml
+  module Elements
+    # `<Condition>` — a single condition declared in `designmap.xml`.
+    # Authors tag text runs with one or more conditions (the CSR's
+    # `AppliedConditions` attribute is a list of condition Self IDs).
+    # The condition's `Visible` flag controls whether tagged text
+    # appears in the rendered output.
+    #
+    # Schema: `Condition_Object` in
+    # `reference-docs/schemas/package/designmap.rnc`.
+    class Condition < Lutaml::Model::Serializable
+      attribute :self_attr, :string
+      attribute :name, :string
+      attribute :indicator_method, :string
+      attribute :underline_indicator_appearance, :string
+      attribute :visible, :boolean, default: true
+
+      xml do
+        root "Condition"
+        map_attribute "Self", to: :self_attr
+        map_attribute "Name", to: :name
+        map_attribute "IndicatorMethod", to: :indicator_method
+        map_attribute "UnderlineIndicatorAppearance",
+                      to: :underline_indicator_appearance
+        map_attribute "Visible", to: :visible
+      end
+    end
+  end
+end

data/lib/idml/elements.rb

@@ -17,6 +17,7 @@ module Idml
     autoload :ButtonPreference, "idml/elements/pref_button_preference"
     autoload :Bookmark, "idml/elements/bookmark"
     autoload :Cell, "idml/elements/cell"
+    autoload :Condition, "idml/elements/condition"
     autoload :CellStyle, "idml/elements/cell_style"
     autoload :CellStyleGroup, "idml/elements/cell_style_group"
     autoload :ChapterNumberPreference,

data/lib/idml/parts/designmap.rb

@@ -48,6 +48,7 @@ module Idml
 
       attribute :layer, Idml::Elements::Layer, collection: true
       attribute :bookmark, Idml::Elements::Bookmark, collection: true
+      attribute :condition, Idml::Elements::Condition, collection: true
       attribute :hyperlink, Idml::Elements::Hyperlink, collection: true
       attribute :hyperlink_page_destination,
                 Idml::Elements::HyperlinkPageDestination, collection: true
@@ -92,6 +93,7 @@ module Idml
         map_attribute "ActiveProcess", to: :active_process
         map_element "Layer", to: :layer
         map_element "Bookmark", to: :bookmark
+        map_element "Condition", to: :condition
         map_element "Hyperlink", to: :hyperlink
         map_element "HyperlinkPageDestination",
                     to: :hyperlink_page_destination

data/lib/idml/render/character_style.rb

@@ -20,7 +20,10 @@ module Idml
       # Yields with the run's fill color applied, then draws underline
       # and/or strike-through rules above/below the text baseline.
       # `x`, `y`, `width`, `size` describe the line's geometry so the
-      # rules can be positioned correctly.
+      # rules can be positioned correctly. The block's emitted text
+      # gets the run's character-level adjustments baked in via
+      # `text_kwargs` (caller passes the canvas.text kwargs in, and
+      # CharacterStyle adds tracking/scale on top).
       def self.apply(canvas, run, context, x:, y:, width:, size:)
         apply_fill_color(canvas, run, context)
         yield
@@ -28,6 +31,42 @@ module Idml
         draw_strike_through(canvas, run, x, y, width, size)
       end
 
+      # Returns the canvas.text kwargs augmented with the run's
+      # Tracking (PDF char_spacing). IDML Tracking is in points;
+      # pdfrb's char_spacing is also in text-space units, so the
+      # mapping is 1:1.
+      def self.text_kwargs(run, base_kwargs)
+        return base_kwargs unless run.tracking
+
+        base_kwargs.merge(char_spacing: run.tracking.to_f)
+      end
+
+      # Yields within a transformed coordinate space when the run
+      # declares glyph scaling. IDML HorizontalScale/VerticalScale
+      # are percentages (100 = no scaling). When both are 100 / nil,
+      # yields without transformation (no graphics-state push).
+      def self.with_glyph_scaling(canvas, run, &)
+        sx = scale_factor(run.horizontal_scale)
+        sy = scale_factor(run.vertical_scale)
+        return yield if scaling_identity?(sx, sy)
+
+        canvas.scale(sx, sy, &)
+      end
+
+      def self.scaling_identity?(sx, sy)
+        (sx - 1.0).abs < FLOAT_EPSILON && (sy - 1.0).abs < FLOAT_EPSILON
+      end
+
+      FLOAT_EPSILON = 1e-9
+      private_constant :FLOAT_EPSILON
+
+      # Returns the run's baseline shift (in PDF units). Positive
+      # values shift up; negative shift down. Used to offset the
+      # text's `at: y` for CSR's BaselineShift.
+      def self.baseline_offset(run)
+        run.baseline_shift&.nonzero? ? run.baseline_shift.to_f : 0.0
+      end
+
       # Transforms the text per the CSR's Capitalization attribute.
       # AllCaps/SmallCaps → uppercase (true small-caps would require
       # an OpenType feature; deferred). Other values pass through.
@@ -55,10 +94,19 @@ module Idml
         color = context.color_resolver&.resolve(run.fill_color)
         return unless color
 
-        canvas.fill_color(ColorHelper.to_canvas(color))
+        tinted = ColorHelper.apply_tint(color, run.fill_tint)
+        canvas.fill_color(ColorHelper.to_canvas(tinted))
       end
       private_class_method :apply_fill_color
 
+      def self.scale_factor(declared)
+        return 1.0 unless declared
+        return 1.0 if declared <= 0
+
+        declared.to_f / 100.0
+      end
+      private_class_method :scale_factor
+
       def self.draw_underline(canvas, run, x, y, width, size)
         return unless run.underline
 

data/lib/idml/render/color_helper.rb

@@ -1,9 +1,10 @@
-# frozen_string_literal: true
+# frozen_string: true
 
 module Idml
   module Render
-    # Converts IDML color hashes to pdfrb Canvas color arrays.
-    # Centralizes the mapping so all renderers use a consistent format.
+    # Converts IDML color hashes to pdfrb Canvas color arrays and
+    # applies tint scaling. Centralizes the mapping so all renderers
+    # use a consistent format.
     module ColorHelper
       module_function
 
@@ -18,6 +19,29 @@ module Idml
         when :cmyk then [:cmyk, color[:c], color[:m], color[:y], color[:k]]
         end
       end
+
+      # Scales a color's components by `tint` (1.0 = full strength,
+      # 0.5 = halved). Tint is the IDML mechanism for lightening a
+      # color without defining a new one. Returns the original color
+      # unchanged when tint is nil or >= 1.0. Single canonical
+      # implementation — CharacterStyle, ParagraphRules, and any
+      # future caller should all delegate here.
+      def apply_tint(color, tint)
+        return color unless color
+        return color unless tint
+        return color if tint >= 1.0
+
+        case color[:model]
+        when :rgb
+          { model: :rgb, r: color[:r] * tint, g: color[:g] * tint,
+            b: color[:b] * tint }
+        when :cmyk
+          { model: :cmyk, c: color[:c] * tint, m: color[:m] * tint,
+            y: color[:y] * tint, k: color[:k] * tint }
+        else
+          color
+        end
+      end
     end
   end
 end

data/lib/idml/render/condition_filter.rb

@@ -0,0 +1,57 @@
+# frozen_string: true
+
+module Idml
+  module Render
+    # Resolves whether a styled run should render based on its
+    # AppliedConditions and the visibility flags declared on the
+    # corresponding `<Condition>` elements in `designmap.xml`.
+    #
+    # A run is visible when either:
+    # - It has no AppliedConditions (the common case), OR
+    # - Every condition it references is itself Visible.
+    #
+    # A run is hidden when ANY referenced condition is hidden. This
+    # matches InDesign's "hide any text the user has toggled off"
+    # semantics.
+    #
+    # Construction: `ConditionFilter.from_designmap(designmap)`
+    # reads the condition collection and indexes by Self. Use
+    # `filter.visible?(applied_conditions_string)` per run; pass nil
+    # or empty string for untagged runs.
+    class ConditionFilter
+      def self.from_designmap(designmap)
+        conditions = designmap ? designmap.condition : []
+        new(conditions)
+      end
+
+      def initialize(conditions)
+        @visibility_by_self = conditions.to_h do |cond|
+          [cond.self_attr, condition_visible?(cond)]
+        end
+      end
+
+      # `applied_conditions` is the raw PSR/CSR string. IDML encodes
+      # it as a space-separated list of condition Self IDs. Returns
+      # true when the run should render.
+      def visible?(applied_conditions)
+        return true if applied_conditions.nil?
+        return true if applied_conditions.strip.empty?
+
+        applied_conditions.split.uniq.all? do |cond_self|
+          condition_visible?(cond_self)
+        end
+      end
+
+      private
+
+      # A condition is visible when explicitly Visible="true" OR when
+      # the Visibility flag is unset (default true). Only an explicit
+      # Visible="false" hides it.
+      def condition_visible?(cond_or_self)
+        return @visibility_by_self.fetch(cond_or_self, true) if cond_or_self.is_a?(String)
+
+        cond_or_self.visible.nil? || cond_or_self.visible
+      end
+    end
+  end
+end

data/lib/idml/render/paragraph_rules.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+module Idml
+  module Render
+    # Emits paragraph-level rules (RuleAbove / RuleBelow) on a pdfrb
+    # canvas. Centralizes the IDML → PDF mapping for the paragraph
+    # rule attributes carried by `StyleResolver::Paragraph`.
+    #
+    # Each rule is a horizontal stroke above (RuleAbove) or below
+    # (RuleBelow) the paragraph block. The rule's weight, color,
+    # tint, offset, and indent come from the PSR's RuleAbove* /
+    # RuleBelow* attributes; defaults approximate InDesign behavior
+    # when an attribute is missing.
+    #
+    # Used by `TextFrameRenderer` so paragraph rules live in one
+    # place (DRY).
+    module ParagraphRules
+      DEFAULT_LINE_WEIGHT = 0.5
+      DEFAULT_TINT = 1.0
+      DEFAULT_OFFSET = 0.0
+
+      # Emits RuleAbove if `paragraph.rule_above` is true. The rule
+      # sits above the paragraph's first line. `top_y` is the y of
+      # the paragraph's top edge (before SpaceBefore is applied);
+      # `frame_left` / `frame_right` are the column's text bounds.
+      def self.emit_rule_above(canvas, paragraph, context, top_y,
+                               frame_left, frame_right)
+        return unless paragraph.rule_above
+
+        emit_rule(canvas, paragraph, context, top_y, frame_left,
+                  frame_right,
+                  weight: paragraph.rule_above_line_weight,
+                  color: paragraph.rule_above_color,
+                  tint: paragraph.rule_above_tint,
+                  offset: paragraph.rule_above_offset,
+                  left_indent: paragraph.rule_above_left_indent,
+                  right_indent: paragraph.rule_above_right_indent,
+                  width_mode: paragraph.rule_above_width,
+                  position: :above)
+      end
+
+      # Emits RuleBelow if `paragraph.rule_below` is true. The rule
+      # sits below the paragraph's last line. `bottom_y` is the y of
+      # the paragraph's bottom edge (after SpaceAfter is applied).
+      def self.emit_rule_below(canvas, paragraph, context, bottom_y,
+                               frame_left, frame_right)
+        return unless paragraph.rule_below
+
+        emit_rule(canvas, paragraph, context, bottom_y, frame_left,
+                  frame_right,
+                  weight: paragraph.rule_below_line_weight,
+                  color: paragraph.rule_below_color,
+                  tint: paragraph.rule_below_tint,
+                  offset: paragraph.rule_below_offset,
+                  left_indent: paragraph.rule_below_left_indent,
+                  right_indent: paragraph.rule_below_right_indent,
+                  width_mode: paragraph.rule_below_width,
+                  position: :below)
+      end
+
+      def self.emit_rule(canvas, paragraph, context, anchor_y,
+                         frame_left, frame_right,
+                         weight:, color:, tint:, offset:,
+                         left_indent:, right_indent:, width_mode:,
+                         position:)
+        thickness = (weight || DEFAULT_LINE_WEIGHT).to_f
+        return unless thickness.positive?
+
+        tint_value = (tint || DEFAULT_TINT).to_f
+        return unless tint_value.positive?
+
+        offset_value = (offset || DEFAULT_OFFSET).to_f
+        x1, x2 = rule_extents(frame_left, frame_right, left_indent,
+                              right_indent, width_mode, paragraph)
+        y = rule_y(anchor_y, offset_value, position)
+
+        apply_rule_color(canvas, color, tint_value, context)
+        canvas.line_width = thickness
+        canvas.move_to(x1, y)
+        canvas.line_to(x2, y)
+        canvas.stroke
+      end
+      private_class_method :emit_rule
+
+      # Returns `[x1, x2]` for the rule. Width mode "Text" indents
+      # the rule by the paragraph's left/right indent (matches the
+      # text bounds); "Column" (default) spans the full column.
+      def self.rule_extents(frame_left, frame_right, rule_left_indent,
+                            rule_right_indent, width_mode, paragraph)
+        left = frame_left
+        right = frame_right
+        if width_mode == "Text"
+          left += (paragraph.left_indent || 0).to_f
+          right -= (paragraph.right_indent || 0).to_f
+        end
+        left += (rule_left_indent || 0).to_f
+        right -= (rule_right_indent || 0).to_f
+        [left, right]
+      end
+      private_class_method :rule_extents
+
+      def self.rule_y(anchor_y, offset, position)
+        position == :above ? anchor_y + offset : anchor_y - offset
+      end
+      private_class_method :rule_y
+
+      def self.apply_rule_color(canvas, color_name, tint_value, context)
+        color = resolve_color(color_name, tint_value, context)
+        canvas.stroke_color(color)
+      end
+      private_class_method :apply_rule_color
+
+      def self.resolve_color(color_name, tint_value, context)
+        return [:gray, 1.0 * tint_value] unless color_name
+        return [:gray, 1.0 * tint_value] if color_name == "Color/None"
+
+        color = context&.color_resolver&.resolve(color_name)
+        return [:gray, 1.0 * tint_value] unless color
+
+        ColorHelper.apply_tint(color, tint_value)
+      end
+      private_class_method :resolve_color
+    end
+  end
+end

data/lib/idml/render/pipeline.rb

@@ -38,6 +38,7 @@ module Idml
         structure = StructureTracker.new(enabled: @tagged)
         position_tracker = PositionTracker.new
         layer_filter = LayerFilter.from_designmap(@package.designmap)
+        condition_filter = ConditionFilter.from_designmap(@package.designmap)
         font_ref_resolver = FontReferenceResolver.build(@package)
         font_setup = FontSetup.new(package: @package,
                                    font_search_paths: @font_search_paths)
@@ -50,7 +51,8 @@ module Idml
           page_index = render_spread(writer, spread, layer_filter,
                                      font_ref_resolver, font_resource,
                                      font_metrics, font_map, structure,
-                                     position_tracker, page_index)
+                                     position_tracker, condition_filter,
+                                     page_index)
         end
 
         structure.flush(writer)
@@ -90,14 +92,14 @@ module Idml
 
       def render_spread(writer, spread, layer_filter, font_ref_resolver,
                         font_resource, font_metrics, font_map, structure,
-                        position_tracker, page_offset)
+                        position_tracker, condition_filter, page_offset)
         pages = spread.spread.flat_map(&:page)
         image_refs = ImageCollector.new(writer: writer,
                                         base_dir: File.dirname(@package.path),
                                         page_height: DEFAULT_HEIGHT).collect(spread)
         renderer = build_renderer(layer_filter, font_ref_resolver,
                                   font_resource, font_metrics, font_map,
-                                  structure, position_tracker)
+                                  structure, position_tracker, condition_filter)
         current = page_offset
 
         pages.each do |page|
@@ -126,7 +128,8 @@ module Idml
       end
 
       def build_renderer(layer_filter, font_ref_resolver, font_resource,
-                         font_metrics, font_map, structure, position_tracker)
+                         font_metrics, font_map, structure, position_tracker,
+                         condition_filter)
         SpreadRenderer.new(
           font_metrics: font_metrics,
           font_ps_name: font_resource,
@@ -136,6 +139,7 @@ module Idml
           font_ref_resolver: font_ref_resolver,
           structure: structure,
           position_tracker: position_tracker,
+          condition_filter: condition_filter,
         )
       end
 

data/lib/idml/render/render_context.rb

@@ -20,6 +20,8 @@ module Idml
       :structure,
       :page_index,
       :position_tracker,
+      :chain_controller,
+      :condition_filter,
       keyword_init: true,
     )
   end

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

@@ -30,7 +30,6 @@ module Idml
         def self.render(canvas, context)
           frame = context.item
           return unless frame.parent_story
-          return unless chain_head?(frame)
 
           story = context.package&.story_by_id(frame.parent_story)
           return unless story
@@ -38,12 +37,53 @@ module Idml
           box = frame_box(frame, context.page_height)
           render_inline_tables(canvas, story, box, context)
 
-          paragraphs = StyleResolver.extract_paragraphs(story)
-          return if paragraphs.empty?
+          state = initial_chain_state(frame, story, context)
+          return unless state
 
-          render_text(canvas, paragraphs, context, box)
+          render_text(canvas, state, context, box)
+          store_chain_state(frame, state, context)
         end
 
+        # Returns the StoryChainController::State to render this frame
+        # with. For chain heads (no predecessor), this is a fresh
+        # state built from extract_paragraphs. For chain non-heads,
+        # this is the leftover state from the previous frame in the
+        # chain (nil when there's nothing left to render).
+        def self.initial_chain_state(frame, story, context)
+          controller = context.chain_controller
+          return fresh_state(story, context) if chain_head?(frame)
+          return nil unless controller
+
+          controller.state_for(frame.parent_story)
+        end
+        private_class_method :initial_chain_state
+
+        # Records the post-render state for the chain so the next
+        # frame in the chain picks up where this one left off. Only
+        # meaningful when a chain_controller is wired.
+        def self.store_chain_state(frame, state, context)
+          controller = context.chain_controller
+          return unless controller
+
+          controller.store_state(frame.parent_story, state)
+        end
+        private_class_method :store_chain_state
+
+        def self.fresh_state(story, context)
+          paragraphs = StyleResolver.extract_paragraphs(
+            story, condition_filter: context.condition_filter
+          )
+          return nil if paragraphs.empty?
+
+          StoryChainController::State.new(
+            paragraphs: paragraphs,
+            current_paragraph: nil,
+            runs_remaining: [],
+            char_cursor: 0,
+          )
+        end
+        private_class_method :fresh_state
+
         # Discovers Tables inlined in the story (Story > PSR > CSR >
         # Table — the real IDML structure) and renders each within
         # the frame's bounds. Real IDML Tables have no own geometry,
@@ -70,12 +110,12 @@ module Idml
         end
         private_class_method :tables_in_story
 
-        def self.render_text(canvas, paragraphs, context, box)
+        def self.render_text(canvas, state, context, box)
           font = context.font_metrics
           if font
-            engine_render(canvas, paragraphs, context, box, font)
+            engine_render(canvas, state, context, box, font)
           else
-            simple_render(canvas, paragraphs, context, box)
+            simple_render(canvas, state, context, box)
           end
         end
         private_class_method :render_text
@@ -109,59 +149,97 @@ module Idml
         end
         private_class_method :layout_frame
 
-        # Walks paragraphs and emits one `canvas.text` per line via
-        # the Shaper → LineBreaker → Justifier → VerticalLayout
-        # pipeline. Cursor y descends monotonically across
-        # paragraphs so text flows top-to-bottom (the previous
-        # implementation reset every run to the frame top).
-        def self.engine_render(canvas, paragraphs, context, box, font)
+        # Walks the chain state's paragraphs/runs and emits one
+        # `canvas.text` per line via the Shaper → LineBreaker →
+        # Justifier → VerticalLayout pipeline. Cursor y descends
+        # monotonically across paragraphs. When a paragraph partially
+        # fits, its remaining runs go back into the state for the
+        # next frame in the chain.
+        def self.engine_render(canvas, state, context, box, font)
           layout_frame = layout_frame(context.item, box)
           cursor_y = box[:y] + box[:height] - (layout_frame.inset_top || 0)
           bottom_limit = TextEngine::VerticalLayout.bottom_limit(layout_frame)
-          char_cursor = 0
-
-          paragraphs.each do |paragraph|
-            break if cursor_y < bottom_limit
+          char_cursor = state.char_cursor
 
-            cursor_y, char_cursor = render_paragraph(
-              canvas, paragraph, context, layout_frame, font,
+          if state.current_paragraph
+            cursor_y, char_cursor = resume_paragraph(
+              canvas, state, context, layout_frame, font,
               cursor_y, bottom_limit, char_cursor
             )
+            return if state.current_paragraph
           end
+
+          consume_paragraphs(canvas, state, context, layout_frame, font,
+                             cursor_y, bottom_limit, char_cursor)
         end
         private_class_method :engine_render
 
-        def self.render_paragraph(canvas, paragraph, context, layout_frame,
-                                  font, cursor_y, bottom_limit, char_cursor)
+        def self.resume_paragraph(canvas, state, context, layout_frame, font,
+                                  cursor_y, bottom_limit, char_cursor)
+          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
+          )
+          if remaining_runs.any?
+            state.runs_remaining = remaining_runs
+          else
+            state.current_paragraph = nil
+            state.runs_remaining = []
+          end
+          [cursor_y, char_cursor]
+        end
+        private_class_method :resume_paragraph
+
+        def self.consume_paragraphs(canvas, state, context, layout_frame, font,
+                                    cursor_y, bottom_limit, char_cursor)
+          pending = 0
+          state.paragraphs.each do |paragraph|
+            break if cursor_y < bottom_limit
+
+            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?
+            )
+            if remaining_runs.any?
+              state.current_paragraph = paragraph
+              state.runs_remaining = remaining_runs
+              break
+            end
+            pending += 1
+          end
+
+          state.paragraphs = state.paragraphs[pending..]
+          state.char_cursor = char_cursor
+        end
+        private_class_method :consume_paragraphs
+
+        # Renders a paragraph's runs (a subset when resuming mid-para).
+        # Returns [remaining_runs, cursor_y, char_cursor] where
+        # remaining_runs is the runs that didn't fit (empty when all
+        # done). Emits RuleAbove before the first run and RuleBelow
+        # after the last successfully-rendered run.
+        def self.render_runs_for_paragraph(canvas, paragraph, runs, context,
+                                           layout_frame, font, cursor_y,
+                                           bottom_limit, char_cursor,
+                                           first_paragraph:)
           wrap_width = TextEngine::VerticalLayout.wrap_width(
             layout_frame, paragraph.right_indent || 0
           )
           para_attrs = paragraph_attrs(paragraph)
-          cursor_y, char_cursor = render_runs(
-            canvas, paragraph, context, layout_frame, font,
-            wrap_width, cursor_y, bottom_limit, char_cursor, para_attrs
-          )
-          [cursor_y - para_attrs[:space_after], char_cursor]
-        end
-        private_class_method :render_paragraph
+          frame_left, frame_right = paragraph_frame_extents(layout_frame)
 
-        def self.paragraph_attrs(paragraph)
-          {
-            space_before: paragraph.space_before || 0,
-            space_after: paragraph.space_after || 0,
-            first_line_indent: paragraph.first_line_indent || 0,
-            left_indent: paragraph.left_indent || 0,
-          }
-        end
-        private_class_method :paragraph_attrs
+          emit_paragraph_top_rule(canvas, paragraph, context, cursor_y,
+                                  frame_left, frame_right, first_paragraph)
 
-        def self.render_runs(canvas, paragraph, context, layout_frame, font,
-                             wrap_width, cursor_y, bottom_limit, char_cursor,
-                             para_attrs)
-          space_before = para_attrs[:space_before]
-          paragraph.runs.each do |run|
+          rendered_count = 0
+          runs.each do |run|
             break if cursor_y < bottom_limit
 
+            space_before = paragraph_space_before(para_attrs, first_paragraph,
+                                                  rendered_count)
             positioned, next_y = layout_run(
               canvas, run, paragraph, context, layout_frame, font,
               wrap_width, cursor_y, space_before,
@@ -170,11 +248,69 @@ module Idml
             )
             char_cursor += positioned.length
             cursor_y = next_y
-            space_before = 0
+            rendered_count += 1
           end
-          [cursor_y, char_cursor]
+
+          remaining_runs = runs[rendered_count..]
+          cursor_y = emit_paragraph_bottom_rule(canvas, paragraph, context,
+                                                cursor_y, frame_left,
+                                                frame_right, para_attrs,
+                                                remaining_runs)
+          [remaining_runs, cursor_y, char_cursor]
+        end
+        private_class_method :render_runs_for_paragraph
+
+        def self.emit_paragraph_top_rule(canvas, paragraph, context, cursor_y,
+                                         frame_left, frame_right,
+                                         first_paragraph)
+          return unless first_paragraph
+
+          ParagraphRules.emit_rule_above(canvas, paragraph, context,
+                                         cursor_y, frame_left, frame_right)
+        end
+        private_class_method :emit_paragraph_top_rule
+
+        def self.paragraph_space_before(para_attrs, first_paragraph,
+                                        rendered_count)
+          return 0 unless first_paragraph && rendered_count.zero?
+
+          para_attrs[:space_before]
+        end
+        private_class_method :paragraph_space_before
+
+        # Emits RuleBelow after a paragraph's last run. Returns the
+        # updated cursor_y (subtracting space_after when the paragraph
+        # completed).
+        def self.emit_paragraph_bottom_rule(canvas, paragraph, context,
+                                            cursor_y, frame_left,
+                                            frame_right, para_attrs,
+                                            remaining_runs)
+          return cursor_y unless remaining_runs.empty?
+
+          after_y = cursor_y - para_attrs[:space_after]
+          ParagraphRules.emit_rule_below(canvas, paragraph, context,
+                                         after_y, frame_left, frame_right)
+          after_y
+        end
+        private_class_method :emit_paragraph_bottom_rule
+
+        def self.paragraph_frame_extents(layout_frame)
+          inset_left = layout_frame.inset_left || 0
+          inset_right = layout_frame.inset_right || 0
+          [layout_frame.x + inset_left,
+           layout_frame.x + layout_frame.width - inset_right]
+        end
+        private_class_method :paragraph_frame_extents
+
+        def self.paragraph_attrs(paragraph)
+          {
+            space_before: paragraph.space_before || 0,
+            space_after: paragraph.space_after || 0,
+            first_line_indent: paragraph.first_line_indent || 0,
+            left_indent: paragraph.left_indent || 0,
+          }
         end
-        private_class_method :render_runs
+        private_class_method :paragraph_attrs
 
         # Shapes one run's text, wraps to the inset/indent-adjusted
         # width, justifies per paragraph alignment, and asks
@@ -223,23 +359,32 @@ module Idml
         private_class_method :layout_run
 
         # Emits one positioned line: applies character-level styling
-        # (fill color, capitalization, position) via CharacterStyle,
-        # then draws underline/strike-through rules after the text.
+        # (fill color + tint, capitalization, position, tracking,
+        # glyph scaling, baseline shift) via CharacterStyle, then
+        # draws underline/strike-through rules after the text.
         def self.emit_line(canvas, line, run, context, size)
           text = CharacterStyle.transform_text(line_text(line),
                                                run.capitalization)
-          scaled_size, baseline_offset = CharacterStyle.position_scale(
+          scaled_size, position_offset = CharacterStyle.position_scale(
             run.position, size
           )
+          baseline_offset = CharacterStyle.baseline_offset(run) +
+            position_offset
+          text_at = [line.x, line.y + baseline_offset]
+          text_kwargs = CharacterStyle.text_kwargs(
+            run,
+            {
+              at: text_at,
+              font: font_for_run(run, context),
+              size: scaled_size,
+            },
+          )
           CharacterStyle.apply(canvas, run, context,
                                x: line.x, y: line.y + baseline_offset,
                                width: line.width, size: scaled_size) do
-            canvas.text(
-              text,
-              at: [line.x, line.y + baseline_offset],
-              font: font_for_run(run, context),
-              size: scaled_size,
-            )
+            CharacterStyle.with_glyph_scaling(canvas, run) do
+              canvas.text(text, **text_kwargs)
+            end
           end
         end
         private_class_method :emit_line
@@ -289,8 +434,11 @@ module Idml
 
         # Fallback when no metrics are available: emit all runs as
         # one `text_rich` block, letting pdfrb measure advance widths.
-        def self.simple_render(canvas, paragraphs, context, box)
-          runs = paragraphs.flat_map(&:runs)
+        # Chain threading is best-effort here — the simple path
+        # doesn't wrap, so the first frame's render typically emits
+        # all content and clears the chain state.
+        def self.simple_render(canvas, state, context, box)
+          runs = collect_runs(state)
           return if runs.empty?
 
           runs_for = build_rich_runs(runs, context)
@@ -299,9 +447,22 @@ module Idml
             runs_for,
             at: [box[:x], box[:y] + box[:height] - first_size],
           )
+          state.paragraphs = []
+          state.current_paragraph = nil
+          state.runs_remaining = []
         end
         private_class_method :simple_render
 
+        def self.collect_runs(state)
+          runs = state.runs_remaining || []
+          if state.current_paragraph
+            runs + state.current_paragraph.runs
+          else
+            runs + state.paragraphs.flat_map(&:runs)
+          end
+        end
+        private_class_method :collect_runs
+
         def self.build_rich_runs(runs, context)
           runs.map do |run|
             {

data/lib/idml/render/spread_renderer.rb

@@ -7,7 +7,8 @@ module Idml
       def initialize(font_metrics: nil, font_ps_name: Render::DEFAULT_FONT,
                      package: nil, layer_filter: LayerFilter::EXCLUDE_NONE,
                      font_ref_resolver: nil, structure: nil,
-                     position_tracker: nil, font_map: {})
+                     position_tracker: nil, font_map: {},
+                     condition_filter: nil)
         @font_metrics = font_metrics
         @font_ps_name = font_ps_name
         @package = package
@@ -16,6 +17,7 @@ module Idml
         @structure = structure
         @position_tracker = position_tracker
         @font_map = font_map
+        @condition_filter = condition_filter
       end
 
       def render(canvas, spread, page_width:, page_height:, image_refs: [],
@@ -33,6 +35,8 @@ module Idml
           structure: @structure,
           page_index: page_index,
           position_tracker: @position_tracker,
+          chain_controller: StoryChainController.new,
+          condition_filter: @condition_filter,
         }
 
         canvas.save_graphics_state do

data/lib/idml/render/story_chain_controller.rb

@@ -0,0 +1,66 @@
+# frozen_string: true
+
+module Idml
+  module Render
+    # Threads story-rendering state across linked TextFrames in a
+    # chain. A story overflows from frame 1 → frame 2 → frame 3 etc.
+    # via PreviousTextFrame/NextTextFrame links; without chain
+    # awareness, the renderer would silently truncate overflow text.
+    #
+    # State is per story_id (the ParentStory attribute). State is
+    # populated when a chain head renders and consumed when chain
+    # non-head frames render.
+    #
+    # Threading granularity: paragraphs and runs. If a run partially
+    # fits in a frame, the next frame picks up where the previous
+    # left off (the partially-rendered lines stay in the previous
+    # frame; remaining lines come from re-wrapping the run).
+    class StoryChainController
+      # `paragraphs` : Array<Paragraph> not yet started
+      # `current_paragraph` : Paragraph in progress (nil if none)
+      # `runs_remaining` : Array<StyledRun> in current_paragraph not yet rendered
+      # `char_cursor` : global character cursor (for hyperlink tracking)
+      State = Struct.new(
+        :paragraphs,
+        :current_paragraph,
+        :runs_remaining,
+        :char_cursor,
+        keyword_init: true,
+      )
+
+      def initialize
+        @states = {}
+      end
+
+      # Returns the chain state for a story, or nil if the story has
+      # no leftover content. Chain heads (no predecessor) get no
+      # state — they render from scratch.
+      def state_for(story_id)
+        @states[story_id]
+      end
+
+      # Records the chain state for a story after a frame's render.
+      # Removes the state entirely when no content remains.
+      def store_state(story_id, state)
+        if state.nil? || empty_state?(state)
+          @states.delete(story_id)
+        else
+          @states[story_id] = state
+        end
+      end
+
+      # True when a story has pending content from a previous frame.
+      def has_pending?(story_id)
+        @states.key?(story_id)
+      end
+
+      private
+
+      def empty_state?(state)
+        state.paragraphs.empty? &&
+          state.current_paragraph.nil? &&
+          state.runs_remaining&.empty?
+      end
+    end
+  end
+end

data/lib/idml/render/style_resolver.rb

@@ -54,6 +54,24 @@ module Idml
         :left_indent,
         :right_indent,
         :auto_leading,
+        # RuleAbove / RuleBelow — paragraph rules (horizontal lines
+        # above/below the paragraph block). Driven by PSR attributes.
+        :rule_above,
+        :rule_above_line_weight,
+        :rule_above_color,
+        :rule_above_tint,
+        :rule_above_offset,
+        :rule_above_left_indent,
+        :rule_above_right_indent,
+        :rule_above_width,
+        :rule_below,
+        :rule_below_line_weight,
+        :rule_below_color,
+        :rule_below_tint,
+        :rule_below_offset,
+        :rule_below_left_indent,
+        :rule_below_right_indent,
+        :rule_below_width,
         keyword_init: true,
       )
 
@@ -86,11 +104,13 @@ module Idml
       # its runs and carries the paragraph-level attributes from the
       # owning PSR. Empty paragraphs (no runs after filtering) are
       # skipped.
-      def self.extract_paragraphs(story)
+      def self.extract_paragraphs(story, condition_filter: nil)
         return [] unless story&.inner
 
         story.inner.paragraph_style_range.filter_map do |psr|
-          runs = csr_runs(psr)
+          next unless condition_visible?(psr, condition_filter)
+
+          runs = csr_runs(psr, condition_filter: condition_filter)
           next if runs.empty?
 
           Paragraph.new(
@@ -102,12 +122,30 @@ module Idml
             left_indent: psr.left_indent,
             right_indent: psr.right_indent,
             auto_leading: psr.auto_leading,
+            rule_above: psr.rule_above,
+            rule_above_line_weight: psr.rule_above_line_weight,
+            rule_above_color: psr.stroke_color,
+            rule_above_tint: psr.rule_above_tint,
+            rule_above_offset: psr.rule_above_offset,
+            rule_above_left_indent: psr.rule_above_left_indent,
+            rule_above_right_indent: psr.rule_above_right_indent,
+            rule_above_width: psr.rule_above_width,
+            rule_below: psr.rule_below,
+            rule_below_line_weight: psr.rule_below_line_weight,
+            rule_below_color: psr.stroke_color,
+            rule_below_tint: psr.rule_below_tint,
+            rule_below_offset: psr.rule_below_offset,
+            rule_below_left_indent: psr.rule_below_left_indent,
+            rule_below_right_indent: psr.rule_below_right_indent,
+            rule_below_width: psr.rule_below_width,
           )
         end
       end
 
-      def self.csr_runs(psr)
+      def self.csr_runs(psr, condition_filter: nil)
         psr.character_style_range.filter_map do |csr|
+          next unless condition_visible?(csr, condition_filter)
+
           text = csr.text_content
           next if text.nil? || text.empty?
 
@@ -136,6 +174,16 @@ module Idml
       end
       private_class_method :csr_runs
 
+      # Drops the PSR/CSR when any of its AppliedConditions
+      # references a hidden Condition. Returns true when no filter
+      # is supplied (caller doesn't care about conditions).
+      def self.condition_visible?(psr_or_csr, condition_filter)
+        return true unless condition_filter
+
+        condition_filter.visible?(psr_or_csr.applied_conditions)
+      end
+      private_class_method :condition_visible?
+
       def self.alignment_for(csr)
         ALIGNMENT_MAP[csr.justification] || :left
       end

data/lib/idml/render.rb

@@ -14,7 +14,10 @@ module Idml
     autoload :Blending,            "#{__dir__}/render/blending"
     autoload :StrokeStyle,         "#{__dir__}/render/stroke_style"
     autoload :CharacterStyle,      "#{__dir__}/render/character_style"
+    autoload :ParagraphRules,      "#{__dir__}/render/paragraph_rules"
+    autoload :StoryChainController, "#{__dir__}/render/story_chain_controller"
     autoload :LayerFilter,         "#{__dir__}/render/layer_filter"
+    autoload :ConditionFilter,     "#{__dir__}/render/condition_filter"
     autoload :Placement,           "#{__dir__}/render/placement"
     autoload :ImageCollector,      "#{__dir__}/render/image_collector"
     autoload :StructureTracker,    "#{__dir__}/render/structure_tracker"

data/lib/idml/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: idml
 version: !ruby/object:Gem::Version
-  version: 0.7.0
+  version: 0.7.2
 platform: ruby
 authors:
 - Ribose
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-08-08 00:00:00.000000000 Z
+date: 2026-08-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bigdecimal
@@ -163,7 +163,11 @@ files:
 - TODO.pdf/105-whole-package-round-trip.md
 - TODO.pdf/106-page-item-type-coverage.md
 - TODO.pdf/107-image-rendering-unification.md
+- TODO.pdf/108-multi-frame-story-flow.md
+- TODO.pdf/109-dry-color-tint.md
 - TODO.pdf/11-font-embedding.md
+- TODO.pdf/110-conditional-text.md
+- TODO.pdf/111-footnote-support.md
 - TODO.pdf/12-idml-to-pdf-pipeline.md
 - TODO.pdf/13-cjk-text-layout.md
 - TODO.pdf/14-page-item-element-models.md
@@ -272,6 +276,7 @@ files:
 - lib/idml/elements/character_style_group.rb
 - lib/idml/elements/character_style_range.rb
 - lib/idml/elements/color.rb
+- lib/idml/elements/condition.rb
 - lib/idml/elements/content.rb
 - lib/idml/elements/content_transparency_setting.rb
 - lib/idml/elements/contour_option.rb
@@ -424,6 +429,7 @@ files:
 - lib/idml/render/character_style.rb
 - lib/idml/render/color_helper.rb
 - lib/idml/render/color_resolver.rb
+- lib/idml/render/condition_filter.rb
 - lib/idml/render/font_reference_resolver.rb
 - lib/idml/render/font_setup.rb
 - lib/idml/render/gradient_resolver.rb
@@ -435,6 +441,7 @@ files:
 - lib/idml/render/layer_filter.rb
 - lib/idml/render/metadata_builder.rb
 - lib/idml/render/page_item_renderer.rb
+- lib/idml/render/paragraph_rules.rb
 - lib/idml/render/pdfa_packet.rb
 - lib/idml/render/pdfrb_writer.rb
 - lib/idml/render/pipeline.rb
@@ -449,6 +456,7 @@ files:
 - lib/idml/render/renderers/table_renderer.rb
 - lib/idml/render/renderers/text_frame_renderer.rb
 - lib/idml/render/spread_renderer.rb
+- lib/idml/render/story_chain_controller.rb
 - lib/idml/render/story_threader.rb
 - lib/idml/render/stroke_style.rb
 - lib/idml/render/structure_mapper.rb