idml 0.7.0 → 0.7.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0f40610210789018b1fbe0625c1541cfe3611169d0004543891ebb9efd6c74ea
-  data.tar.gz: 6998d5c66bd56eed147dfb88d60a602be32fee2adb9b9fa9f08413af4cb2103f
+  metadata.gz: f43caa091c83d9d8288f22f3913d21760bf5a5dac986f76b72521bb19f5110e0
+  data.tar.gz: 4e33ef7a0c119936d16c0eecb687d153e04d9dc29d789511633fb6fff7f1a152
 SHA512:
-  metadata.gz: 02c03bf2c81b2ebb81b04ae4b413b25d484adf806b1d8c7c0768e557323bca7c30de46d5174cff27c90e2275f6f89070ac5f981df567cb20867e5c17382b0c42
-  data.tar.gz: 642103e8e48d2b5b52a4b669d7e09329f5706e4f165f4da8de6df51ef38125686ca75db28de194a974f94cdc9273a193c76a653bf8727b3a16f6b5ac2a9c5f3c
+  metadata.gz: 16b0f93a7c8993c5f98ad84c6e186ed61ebcaaabcdda63b26c9d1e4bfadd1c3986bef933d2a832d2b3463ab5b23324778a37e92e62cbeb8ce0876dbc26bebcbe
+  data.tar.gz: 9950c7afceda42f377e0d2bef226c4caa346c9d79ac4b3b61dcba99612a321c646eecd6b341be88fd7f8a46c695ecc2449d1bf4d900e4338ed1a4c9f76ea4d45

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,50 @@
+# TODO PDF 108: Multi-frame story flow (use StoryThreader)
+
+## Status: OPEN — gap identified in 2026-08-09 audit
+
+## 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,37 @@
+# TODO PDF 110: Conditional text (AppliedConditions)
+
+## Status: OPEN — gap identified in 2026-08-09 audit
+
+## 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/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/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/renderers/text_frame_renderer.rb

@@ -137,14 +137,37 @@ module Idml
             layout_frame, paragraph.right_indent || 0
           )
           para_attrs = paragraph_attrs(paragraph)
+          frame_left, frame_right = paragraph_frame_extents(layout_frame)
+
+          # RuleAbove sits at the paragraph's top edge (before
+          # space_before is subtracted), so emit it first using the
+          # incoming cursor_y as the anchor.
+          ParagraphRules.emit_rule_above(canvas, paragraph, context,
+                                         cursor_y, frame_left, frame_right)
+
           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]
+          after_y = cursor_y - para_attrs[:space_after]
+
+          # RuleBelow sits at the paragraph's bottom edge (after the
+          # last line + space_after), so emit it last using after_y
+          # as the anchor.
+          ParagraphRules.emit_rule_below(canvas, paragraph, context,
+                                         after_y, frame_left, frame_right)
+          [after_y, char_cursor]
         end
         private_class_method :render_paragraph
 
+        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,
@@ -223,23 +246,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

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,
       )
 
@@ -102,6 +120,22 @@ 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

data/lib/idml/render.rb

@@ -14,6 +14,7 @@ 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 :LayerFilter,         "#{__dir__}/render/layer_filter"
     autoload :Placement,           "#{__dir__}/render/placement"
     autoload :ImageCollector,      "#{__dir__}/render/image_collector"

data/lib/idml/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: idml
 version: !ruby/object:Gem::Version
-  version: 0.7.0
+  version: 0.7.1
 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
@@ -435,6 +439,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