idml 0.10.3 → 0.10.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 79a78b04b80af7bc0018d4fde7500d164d8bc8b587a425c2fba89c5be19a7bb8
-  data.tar.gz: 0b835730671e71723e043372530b1fbb6765029c50da2025315408dd2caf4fa7
+  metadata.gz: f60b5f9020e44d5131e9f50e2ddfb673f9caca65bbdee8428b4670baaf96108f
+  data.tar.gz: 1f19b80511a14cea5fab0b76404be809a8f28e680deb91ee1b4caf9353a1b756
 SHA512:
-  metadata.gz: 3f79b3ee1dbe8a3d5cb01346f55935196e10d21ca3cd7d477132aaedafc200df0880179b568b8c071d5dbce62e77b2fe6275fdedb1a6d8fbbeb868f61b16a70f
-  data.tar.gz: 5d556bd0f53b5817051dd5ae419fab76c4e91534e3ff0f1415ff5e22fc10949743f2e6fb5992d0c2a669ea5e8aa4e3e2c20ebac7ddfe8ae991495267cd5a2671
+  metadata.gz: 9bea97bee388cae4ab403c3bea6cae233c3a378c569c0c678620bdb59a3ed5534ab9aa560866fad103d8a724351e396c72e9a533671fd44189719958f83d811e
+  data.tar.gz: 151917cdee9265410c788c85fb6f28d45d07ffc37cc3c4e3fc14b4578f2be57adee09393c284a53a883f1f1dbe105920ecd745a264f0311cc38c0c8f92d94a05

data/Gemfile

@@ -9,10 +9,12 @@ gem "lutaml-model", "~> 0.8.0"
 gem "pdfrb", "~> 0.7"
 gem "rake"
 gem "rspec"
-gem "rubocop"
-gem "rubocop-performance"
-gem "rubocop-rake"
-gem "rubocop-rspec"
+# Pinned: new rubocop majors introduce cops that fail CI
+# unexpectedly (1.90 did on 2026-08-25). Bump deliberately.
+gem "rubocop", "1.90.0"
+gem "rubocop-performance", "1.27.0"
+gem "rubocop-rake", "0.7.1"
+gem "rubocop-rspec", "3.10.2"
 gem "simplecov", require: false
 gem "thor"
 gem "yard"

data/TODO.pdf/117-endnote-support.md

@@ -1,7 +1,6 @@
 # TODO PDF 117: Endnote support
 
-## Status: PARTIAL (modeling + reference markers COMPLETE
-2026-08-18/19; endnote TEXT rendering OPEN pending a real fixture)
+## Status: COMPLETE — implemented 2026-08-26
 
 ## Problem
 
@@ -27,7 +26,7 @@ story flagged `IsEndnoteStory="true"`. Documents with endnotes
   references instead of dropping them. `StoryInner` also parses
   `StoryPreference` (vertical writing support).
 
-## Design for rendering (needs a real InDesign fixture to validate)
+## End-of-story text rendering (2026-08-26)
 
 1. ~~Marker~~ DONE 2026-08-19: CSR-level EndnoteRange emits a
    superscript marker run at the CSR's position (same pattern as
@@ -48,3 +47,22 @@ The marker-position machinery (text-range resolution) cannot be
 validated without a real fixture; blind implementation risks wrong
 anchor placement on production files. Schema modeling + round-trip
 is complete and verified.
+
+## Final implementation notes
+
+When a main story carries EndnoteRange markers, the package's
+endnote stories (IsEndnoteStory="true", package order) append
+after the main flow via the chain state — end-of-story placement
+per the design above. Each endnote story's first run is prefixed
+with its ordinal ("1 …", "2 …") matching the body markers'
+sequential numbering. Verified by an end-to-end synthetic-package
+spec (3 text blocks with the marker, 1 without).
+
+## Known limitations
+
+- Multi-story linkage is not modeled: ALL endnote stories follow
+  the marker-bearing story (correct for single-article documents;
+  the EndnoteTextRange chain remains the fixture-gated refinement
+  for multi-article layouts).
+- EndnoteOption (Scope / StartAt / Prefix / Suffix) is not yet
+  modeled in Preferences; numbering is ordinal.

data/TODO.pdf/13-cjk-text-layout.md

@@ -1,8 +1,9 @@
 # TODO PDF 13: CJK text layout
 
-## Status: PARTIAL — vertical writing mode implemented 2026-08-19
-(horizontal-mode CJK was complete 2026-08-17: glyph measurement,
-kinsoku shori, ruby annotations).
+## Status: COMPLETE — final mojikumi pair compression landed
+2026-08-26. Vertical writing (2026-08-19), kinsoku shori, ruby,
+tate-chu-yoko, script spacing, and line-end compression were
+already in.
 
 ## Vertical mode (2026-08-19)
 
@@ -22,10 +23,12 @@ kinsoku shori, ruby annotations).
 
 2026-08-20 completions: tate-chu-yoko (TODO 124), Latin rotation
 and vertical ruby (TODO 122), CJK/Latin automatic script spacing
-(TODO 125, a mojikumi subset wired into Shaper). The remaining
-stretch goal is full class-based mojikumi (per-pair punctuation
-compression tables); line-end punctuation compression landed
-2026-08-23 as TODO 132. See `lib/idml/text_engine/cjk_layout.rb` and
+(TODO 125, a mojikumi subset wired into Shaper). Final piece (2026-08-26): class-based pair compression — a
+full-width closing/middle glyph followed by another full-width
+punctuation compresses to half advance within the line (。」、
+ー）… pairs), completing the three real mojikumi behaviors of
+InDesign's default sets alongside script spacing (TODO 125) and
+line-end compression (TODO 132). See `lib/idml/text_engine/cjk_layout.rb` and
 `lib/idml/text_engine/vertical_text_layout.rb`.
 
 ## Progress 2026-08-17

data/TODO.pdf/135-minimum-glyph-scaling.md

@@ -0,0 +1,28 @@
+# TODO PDF 135: MinimumGlyphScaling justification compression
+
+## Status: COMPLETE — implemented 2026-08-26
+
+## Problem
+
+InDesign's justification dialog exposes MinimumGlyphScaling: overlong
+justified lines may squeeze glyphs uniformly down to that percent.
+The gem applied only MaximumGlyphScaling (stretching, TODO 129) —
+overlong lines overflowed the frame instead of compressing.
+
+## Solution
+
+`TextEngine::Justifier#justify_line` now handles negative slack:
+`compress_glyphs` scales every glyph uniformly, capped at
+`min_glyph_scaling` percent (default 100 disables it, matching
+InDesign). The limit threads through `SpacingLimits#min_glyph_scaling`,
+resolved from the PSR's `MinimumGlyphScaling` via `StyleResolver`
+(`Paragraph#minimum_glyph_scaling`) and applied at both call sites
+(frame renderer and footnote layout).
+
+## Files
+
+- `lib/idml/text_engine/justifier.rb`
+- `lib/idml/render/style_resolver.rb`
+- `lib/idml/render/renderers/text_frame_renderer.rb`
+- `lib/idml/render/footnote.rb`
+- `spec/idml/text_engine/text_engine_spec.rb`

data/TODO.pdf/136-diagonal-cell-strokes.md

@@ -0,0 +1,24 @@
+# TODO PDF 136: Diagonal cell strokes drawn
+
+## Status: COMPLETE — implemented 2026-08-26
+
+## Problem
+
+The Table schema (TODO 104) modeled `TopLeftDiagonalLine`,
+`TopRightDiagonalLine`, and the `DiagonalLineStroke*` attributes, but
+the renderer never drew them — struck-through table cells (common in
+forms) rendered as plain boxes.
+
+## Solution
+
+`TableRenderer#render_cell_diagonals` draws after cell borders:
+TopLeftDiagonalLine from top-left to bottom-right corner,
+TopRightDiagonalLine from top-right to bottom-left. Weight defaults
+to 1pt and color to black when the flags are set without explicit
+stroke attributes (InDesign defaults); `DiagonalLineStrokeTint`
+applies via `ColorHelper.apply_tint`.
+
+## Files
+
+- `lib/idml/render/renderers/table_renderer.rb`
+- `spec/idml/render/table_renderer_spec.rb`

data/TODO.pdf/137-simple-render-footnote-text.md

@@ -0,0 +1,22 @@
+# TODO PDF 137: Footnote text in the simple-render fallback
+
+## Status: COMPLETE — implemented 2026-08-26
+
+## Problem
+
+Without FontMetrics the text renderer falls back to `simple_render`
+(one `text_rich` per frame). Footnote markers rendered but the
+footnote text itself was dropped entirely.
+
+## Solution
+
+`emit_simple_footnotes` emits after the body block: one `text_rich`
+line per footnote paragraph, stacked upward from the frame's bottom
+edge below a hairline separator rule (0.5pt, quarter-width — InDesign's
+footnote rule proportions). Paragraphs carry their marker prefix from
+extraction, so numbering reads correctly.
+
+## Files
+
+- `lib/idml/render/renderers/text_frame_renderer.rb`
+- `spec/idml/render/simple_footnote_render_spec.rb`

data/TODO.pdf/138-text-wrap-sides.md

@@ -0,0 +1,36 @@
+# TODO PDF 138: Side-aware text wrap (TextWrapSide)
+
+## Status: COMPLETE — implemented 2026-08-26
+
+## Problem
+
+TextWrapSide was parsed but ignored: every wrap mode narrowed the run
+width by the contour overlap, which smears text over objects that sit
+at a frame edge (text starts at the frame's left edge regardless of
+where the object is).
+
+## Solution
+
+`TextWrapResolver#wrap_adjustment` returns
+`[width_reduction, x_shift]` per line band:
+
+- `LeftSide` — text stays left of the contour: reduce so the line
+  ends at the contour's left edge, no shift.
+- `RightSide` — text flows right of the contour: shift lines past the
+  contour's right edge (`Line#x_offset += shift` after justification)
+  and reduce by the same amount.
+- `LargestArea` — pick the roomier side of the two.
+- `BothSides` (default) and the spine variants — narrow by the full
+  overlap; true two-segment lines and binding-side context remain
+  approximations.
+- Inverse contours keep their flip-to-inside semantics.
+
+Multiple contours combine by max (per-run approximation, as before).
+Shape contours (Contour mode) narrow by polygon overlap without side
+awareness.
+
+## Files
+
+- `lib/idml/render/text_wrap_resolver.rb`
+- `lib/idml/render/renderers/text_frame_renderer.rb`
+- `spec/idml/render/text_wrap_resolver_spec.rb`

data/TODO.pdf/61-known-limitations.md

@@ -1,6 +1,6 @@
 # TODO PDF 61: Known limitations and future work
 
-## Status: DOCUMENTED — refreshed 2026-08-20
+## Status: DOCUMENTED — refreshed 2026-08-26
 
 Previously listed limitations (font embedding, tagged PDF, per-run
 styling, dead code) were resolved by TODOs 52/53/55/67/76 long ago;
@@ -11,10 +11,10 @@ this list reflects the current state.
 ### Text layout
 - **Hyphenation** is not implemented (Hyphenation* attributes are
   parsed but unused); a hyphenation dictionary would be required.
-- **Justification**: word/letter spacing caps apply (TODO 119) and
-  MaximumGlyphScaling stretches as the last resort (TODO 129);
-  MinimumGlyphScaling compression and ToBinding / RTL binding
-  alignment are not applied.
+- **Justification**: word/letter spacing caps apply (TODO 119),
+  MaximumGlyphScaling stretches (TODO 129) and MinimumGlyphScaling
+  compresses overlong lines (TODO 135); ToBinding / RTL binding
+  alignment is not applied.
 - **Keep options**: KeepAllLinesTogether (TODO 123), KeepWithNext
   (TODO 127), and the KeepFirstLines / KeepLastLines windows
   (TODO 133, line-count approximation) are honored.
@@ -23,35 +23,35 @@ this list reflects the current state.
 - **StartParagraph** breaks act at frame/column granularity — no
   odd/even page parity.
 - **Text wrap**: BoundingBoxTextWrap, Contour, and Inverse modes
-  render (TODOs 130-131); JumpObject/NextColumn approximate as
-  the box; side-aware narrowing is not implemented.
+  render (TODOs 130-131) with TextWrapSide side-awareness (TODO 138:
+  LeftSide / RightSide / LargestArea pick the flow side; spine
+  variants approximate as BothSides); JumpObject/NextColumn
+  approximate as the box; Contour-mode shapes are not side-aware.
 
 ### CJK
-- **Mojikumi**: CJK/Latin auto script spacing (TODO 125) and
-  line-end punctuation compression (TODO 132) are applied; full
-  class-based compression tables are not.
+- **Mojikumi**: script spacing (TODO 125), line-end compression
+  (TODO 132), and class-based pair compression (2026-08-26) are
+  applied; named mojikumi sets (詳細 etc.) are not modeled.
 - **Vertical mode**: Latin rotation is per glyph (not run-grouped);
   ruby placement is beside-column; keep options do not apply.
 
 ### Structural features
-- **Endnotes** (TODO 117): reference markers render; endnote TEXT
-  rendering is gated on a real fixture (the EndnoteTextRange
-  reference chain is opaque without one).
+- **Endnotes** (TODO 117): reference markers render and endnote TEXT
+  renders end-of-story with ordinal prefixes; multi-story linkage
+  (which endnotes belong to which main story) is not modeled.
 - **Footnotes** number per story; overflow balancing (NoSplitting)
-  is not modeled; the simple-render fallback shows markers without
-  footnote text.
+  is not modeled; the simple-render fallback shows markers with
+  footnote text stacked at the frame bottom (TODO 137).
 - **Anchored objects** render at stored geometry; AnchorType
   text-reflow is not simulated.
 - **Tables** flow across chained frames with repeated header rows
-  (TODO 134); row-spanning cells break at frame boundaries and
-  diagonal cell strokes are modeled but not drawn.
+  (TODO 134) and diagonal cell strokes draw (TODO 136);
+  row-spanning cells break at frame boundaries.
 - **Inline anchored objects / footnotes inside table cells** are
   not handled.
 
 ## Future enhancements
 
 - Hyphenation dictionary integration
-- Shape-mode text wrap contours
-- Frame-spanning tables with header repeats
-- Class-based mojikumi tables
+- Shape-mode text wrap contours (side-aware)
 - Performance benchmark for 100+ page documents

data/TODO.pdf/README.md

@@ -12,7 +12,12 @@ without InDesign Server. The pipeline has three layers:
    output together. IDML Package → typed model → render plan →
    pdfrb Document → PDF file.
 
-All entries below are functionally DONE (basic CJK in TODO 13 is
-the only PARTIAL — vertical writing mode, kinsoku, ruby, and
-tate-chu-yoko remain stretch goals). Each file carries a
-`## Status:` header with a brief implementation summary.
+All entries are DONE — including TODO 117 (end-of-story endnote
+TEXT rendering), TODO 13's class-based mojikumi pair compression,
+and the final known-limitation sweep (TODOs 135–138:
+MinimumGlyphScaling compression, diagonal cell strokes, footnote
+text in the simple-render fallback, and side-aware TextWrapSide).
+Vertical writing, kinsoku, ruby, and tate-chu-yoko all landed
+(TODOs 122-125). TODO 61 is the live known-limitations index. Each
+file carries a `## Status:` header with a brief implementation
+summary.

data/idml.gemspec

@@ -12,7 +12,14 @@ Gem::Specification.new do |spec|
   spec.authors = ["Ribose"]
   spec.email = ["open.source@ribose.com"]
 
-  spec.summary = "Parse, manipulate, and round-trip Adobe IDML files."
+  spec.summary = "Parse, validate, compose, and render Adobe IDML files to PDF."
+  spec.description = "Pure-Ruby toolkit for Adobe InDesign IDML: " \
+                     "schema-faithful models with byte-faithful " \
+                     "round-trip, RelaxNG validation, composition " \
+                     "operations, and a full " \
+                     "IDML-to-PDF rendering pipeline (text layout, " \
+                     "tables, CJK " \
+                     "vertical writing, text wrap, footnotes, PDF/A)."
   spec.homepage      = "https://github.com/metanorma/idml"
   spec.license       = "BSD-2-Clause"
   spec.required_ruby_version = Gem::Requirement.new(">= 3.3.0")

data/lib/idml/render/footnote.rb

@@ -132,6 +132,7 @@ module Idml
             max_word_spacing: paragraph.maximum_word_spacing,
             max_letter_spacing: paragraph.maximum_letter_spacing,
             max_glyph_scaling: paragraph.maximum_glyph_scaling,
+            min_glyph_scaling: paragraph.minimum_glyph_scaling,
           )
           lines.each_with_index do |line, index|
             TextEngine::Justifier.justify(

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

@@ -104,6 +104,8 @@ module Idml
                                    cell_h, context)
             render_cell_border(canvas, cell, table, cell_x, cell_y,
                                cell_w, cell_h, context)
+            render_cell_diagonals(canvas, cell, cell_x, cell_y,
+                                  cell_w, cell_h, context)
             render_cell_text(canvas, cell, cell_x, cell_y, cell_h, context)
           end
         end
@@ -220,6 +222,56 @@ module Idml
         end
         private_class_method :render_cell_border
 
+        # TopLeftDiagonalLine runs from the cell's top-left to its
+        # bottom-right corner; TopRightDiagonalLine from top-right
+        # to bottom-left. Stroke weight defaults to 1pt and color
+        # to black when the flags are set without explicit stroke
+        # attributes (InDesign defaults). DiagonalLineInFront is
+        # accepted; diagonals always paint after the cell fill.
+        def self.render_cell_diagonals(canvas, cell, x, y, w, h, context)
+          return unless cell.top_left_diagonal_line ||
+            cell.top_right_diagonal_line
+
+          weight = cell.diagonal_line_stroke_weight
+          thickness = weight.nil? ? 1.0 : weight.to_f
+          return unless thickness.positive?
+
+          canvas.line_width = thickness
+          canvas.stroke_color(diagonal_color(cell, context))
+          diagonals_for(cell, x, y, w, h).each do |from, to|
+            canvas.move_to(from[0], from[1])
+            canvas.line_to(to[0], to[1])
+            canvas.stroke
+          end
+        end
+        private_class_method :render_cell_diagonals
+
+        def self.diagonals_for(cell, x, y, w, h)
+          [].tap do |diagonals|
+            diagonals << [[x, y + h], [x + w, y]] if cell.top_left_diagonal_line
+            diagonals << [[x + w, y + h], [x, y]] if cell.top_right_diagonal_line
+          end
+        end
+        private_class_method :diagonals_for
+
+        def self.diagonal_color(cell, context)
+          color = diagonal_resolved_color(cell, context)
+          color ? ColorHelper.to_canvas(color) : [:gray, 0.0]
+        end
+        private_class_method :diagonal_color
+
+        def self.diagonal_resolved_color(cell, context)
+          name = cell.diagonal_line_stroke_color
+          return nil if name.nil? || name == "Color/None"
+
+          resolved = context.color_resolver&.resolve(name)
+          return nil unless resolved
+
+          tint = cell.diagonal_line_stroke_tint
+          tint ? ColorHelper.apply_tint(resolved, tint) : resolved
+        end
+        private_class_method :diagonal_resolved_color
+
         # [top, right, bottom, left] effective weights, or nil when
         # neither cell edges nor table defaults declare any stroke
         # (the legacy uniform-rect case).

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

@@ -77,6 +77,7 @@ module Idml
                    style_lookup: context.style_lookup,
                    footnote_option: Footnote.option(context.package)
           )
+          paragraphs.concat(endnote_paragraphs(story, context))
           tables = tables_in_story(story).map { |table| [table, 0] }
           return nil if paragraphs.empty? && tables.empty?
 
@@ -114,6 +115,55 @@ module Idml
         end
         private_class_method :render_inline_tables
 
+        # End-of-story endnote text (TODO 117): when the main
+        # story carries endnote markers, the package's endnote
+        # stories (IsEndnoteStory="true", in designmap StoryList
+        # order) append after the main flow, each prefixed with
+        # its ordinal so it reads as numbered. Multi-story linkage
+        # (which endnotes belong to which main story) is not
+        # modeled — all endnote stories follow the marker-bearing
+        # story, which matches single-article documents.
+        def self.endnote_paragraphs(story, context)
+          return [] unless endnotes_marked?(story, context)
+
+          number = 0
+          context.package.stories.filter_map do |endnote_story|
+            next unless endnote_story.inner&.is_endnote_story
+
+            number += 1
+            paragraphs = StyleResolver.extract_paragraphs(
+              endnote_story,
+              condition_filter: context.condition_filter,
+              style_lookup: context.style_lookup,
+              footnote_option: Footnote.option(context.package),
+            )
+            prefix_endnote_number(paragraphs, number)
+            paragraphs
+          end.flatten
+        end
+        private_class_method :endnote_paragraphs
+
+        def self.endnotes_marked?(story, context)
+          return false unless context.package
+          return false unless story_csrs(story).any? do |csr|
+            !csr.endnote_range.empty?
+          end
+
+          context.package.stories.any? do |candidate|
+            candidate.inner&.is_endnote_story
+          end
+        end
+        private_class_method :endnotes_marked?
+
+        def self.prefix_endnote_number(paragraphs, number)
+          return if paragraphs.empty?
+          return if paragraphs.first.runs.empty?
+
+          first_run = paragraphs.first.runs.first
+          first_run.text = "#{number} #{first_run.text}"
+        end
+        private_class_method :prefix_endnote_number
+
         def self.tables_in_story(story)
           story_csrs(story).flat_map(&:table).compact
         end
@@ -789,14 +839,17 @@ 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)
+            wrap_reduction, wrap_shift = text_wrap_adjust(
+              context, layout_frame, cursor_y, run
+            )
+            run_wrap -= wrap_reduction
             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, bottom_limit,
-              paragraph_last: run.equal?(runs.last)
+              paragraph_last: run.equal?(runs.last),
+              wrap_shift: wrap_shift
             )
             char_cursor += positioned.length
             cursor_y = next_y
@@ -855,26 +908,27 @@ module Idml
         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)
+        # Computes the text-wrap adjustment for a run at its current y
+        # position: [width_reduction, x_shift]. The reduction narrows
+        # the wrap width; the shift moves wrapped lines right past a
+        # contour the text must flow around (TextWrapSide RightSide /
+        # LargestArea). Uses the run's point_size as the line height
+        # approximation. Returns [0.0, 0.0] when no resolver is wired
+        # or no contours overlap. Per-run approximation: all lines in
+        # the run get the same reduced width and shift (correct when
+        # the run is fully inside or outside the contour; approximate
+        # when it spans the boundary).
+        def self.text_wrap_adjust(context, layout_frame, cursor_y, run)
           resolver = context.text_wrap_resolver
-          return 0.0 unless resolver
+          return [0.0, 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
+          resolver.wrap_adjustment(cursor_y, size, frame_x, frame_right)
         end
-        private_class_method :text_wrap_overlap
+        private_class_method :text_wrap_adjust
 
         # Strips drop cap characters from the first run so they don't
         # render twice (once as the enlarged drop cap, once as normal
@@ -997,7 +1051,8 @@ 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, bottom_limit, paragraph_last: false)
+                            char_cursor, bottom_limit, paragraph_last: false,
+                            wrap_shift: 0.0)
           size = run.point_size || DEFAULT_SIZE
           glyphs = TextEngine::Shaper.shape(
             text: run.text, font: font, size: size,
@@ -1006,6 +1061,7 @@ module Idml
             glyphs: glyphs, frame_width: wrap_width,
           )
           justify_lines(lines, paragraph, wrap_width, paragraph_last)
+          lines.each { |line| line.x_offset += wrap_shift }
           leading = leading_for(paragraph, size)
 
           positioned, next_y = TextEngine::VerticalLayout.layout_block(
@@ -1158,6 +1214,7 @@ module Idml
             max_word_spacing: paragraph.maximum_word_spacing,
             max_letter_spacing: paragraph.maximum_letter_spacing,
             max_glyph_scaling: paragraph.maximum_glyph_scaling,
+            min_glyph_scaling: paragraph.minimum_glyph_scaling,
           )
           lines.each_with_index do |line, index|
             TextEngine::Justifier.justify(
@@ -1301,12 +1358,38 @@ module Idml
             runs_for,
             at: [box[:x], box[:y] + box[:height] - first_size],
           )
+          emit_simple_footnotes(canvas, runs, context, box)
           state.paragraphs = []
           state.current_paragraph = nil
           state.runs_remaining = []
         end
         private_class_method :simple_render
 
+        # Footnote text for the rough (no-metrics) path: one line
+        # per footnote paragraph, stacked upward from the frame's
+        # bottom edge below a hairline separator. Paragraphs are
+        # already marker-prefixed at extraction.
+        def self.emit_simple_footnotes(canvas, runs, context, box)
+          paragraphs = runs.flat_map(&:footnote_paragraphs).compact
+          return if paragraphs.empty?
+
+          size = paragraphs.first.runs.first&.point_size || DEFAULT_SIZE
+          block_top = box[:y] + (paragraphs.length * size)
+          canvas.line_width = 0.5
+          canvas.stroke_color([:gray, 0.0])
+          canvas.move_to(box[:x], block_top + (size * 0.3))
+          canvas.line_to(box[:x] + (box[:width] * 0.25), block_top + (size * 0.3))
+          canvas.stroke
+
+          paragraphs.reverse_each.with_index do |paragraph, index|
+            canvas.text_rich(
+              build_rich_runs(paragraph.runs, context),
+              at: [box[:x], box[:y] + ((index + 1) * size)],
+            )
+          end
+        end
+        private_class_method :emit_simple_footnotes
+
         def self.collect_runs(state)
           runs = state.runs_remaining || []
           if state.current_paragraph

data/lib/idml/render/style_resolver.rb

@@ -69,6 +69,7 @@ module Idml
         :maximum_word_spacing,
         :maximum_letter_spacing,
         :maximum_glyph_scaling,
+        :minimum_glyph_scaling,
         # Forced paragraph break (StartParagraph: NextPage /
         # NextColumn / NextFrame / NextOddPage / NextEvenPage).
         :start_paragraph,
@@ -212,6 +213,9 @@ module Idml
             maximum_glyph_scaling: resolve_attr(
               style_lookup, psr, :maximum_glyph_scaling
             ),
+            minimum_glyph_scaling: resolve_attr(
+              style_lookup, psr, :minimum_glyph_scaling
+            ),
             start_paragraph: resolve_attr(style_lookup, psr,
                                           :start_paragraph),
             keep_all_lines_together: resolve_attr(

data/lib/idml/render/text_wrap_resolver.rb

@@ -9,12 +9,16 @@ module Idml
     # text line to compute the effective wrap width — lines that
     # overlap a contour get their width reduced by the overlap.
     #
-    # Supported: BoundingBox mode (rectangle intersection).
-    # Unsupported: Shape mode (contour following), Inverse mode.
+    # Supported: BoundingBox mode (rectangle intersection) with
+    # TextWrapSide awareness (LeftSide / RightSide / LargestArea
+    # pick the side text flows on; BothSides and the spine variants
+    # narrow by the full overlap). Shape contours (Contour mode)
+    # narrow by polygon overlap without side awareness.
+    # Unsupported: Inverse mode's side behavior.
     class TextWrapResolver
       # A wrap contour: a PDF-coordinate rectangle the text avoids.
       Contour = Struct.new(
-        :x, :y, :width, :height, :inverse,
+        :x, :y, :width, :height, :inverse, :side,
         keyword_init: true
       )
 
@@ -37,6 +41,80 @@ module Idml
 
       attr_reader :contours
 
+      # Side-aware adjustment for a text line: returns
+      # [width_reduction, x_shift]. LeftSide keeps text left of the
+      # contour (reduce, no shift); RightSide moves text past the
+      # contour's right edge (reduce + shift); LargestArea picks the
+      # roomier side; BothSides and the spine variants (which need
+      # binding-side context) reduce by the full overlap. Multiple
+      # contours combine by max — the per-run approximation.
+      def wrap_adjustment(line_y, line_height, frame_x, frame_right)
+        reduction = 0.0
+        shift = 0.0
+        @contours.each do |contour|
+          unless contour.is_a?(WrapContour::Shape)
+            r, s = box_adjustment(contour, line_y, line_height,
+                                  frame_x, frame_right)
+            reduction = [reduction, r].max
+            shift = [shift, s].max
+            next
+          end
+
+          width = WrapContour.overlap_width(contour, line_y,
+                                            line_height, frame_x,
+                                            frame_right)
+          next unless contour.inverse
+
+          reduction = [reduction,
+                       (frame_right - frame_x) - width].max
+        end
+        [reduction, shift]
+      end
+
+      def box_adjustment(contour, line_y, line_height, frame_x,
+                         frame_right)
+        overlap = if y_overlap?(contour, line_y, line_height) &&
+            x_overlap?(contour, frame_x, frame_right)
+                    x_overlap_width(contour, frame_x, frame_right)
+                  else
+                    0.0
+                  end
+        # Inverse contours: text flows only inside, so the reduction
+        # is the frame width minus the covered part (the full width
+        # when the line misses the object entirely).
+        return [(frame_right - frame_x) - overlap, 0.0] if contour.inverse
+
+        return [0.0, 0.0] if overlap.zero?
+
+        side_adjustment(contour, overlap, frame_x, frame_right)
+      end
+      private :box_adjustment
+
+      def side_adjustment(contour, overlap, frame_x, frame_right)
+        case contour.side
+        when "LeftSide"
+          [frame_right - contour.x, 0.0]
+        when "RightSide"
+          shift = contour.x + contour.width - frame_x
+          [shift, shift]
+        when "LargestArea"
+          largest_side_adjustment(contour, frame_x, frame_right)
+        else
+          [overlap, 0.0]
+        end
+      end
+      private :side_adjustment
+
+      def largest_side_adjustment(contour, frame_x, frame_right)
+        left_free = contour.x - frame_x
+        right_free = frame_right - (contour.x + contour.width)
+        return [frame_right - contour.x, 0.0] if left_free >= right_free
+
+        shift = contour.x + contour.width - frame_x
+        [shift, shift]
+      end
+      private :largest_side_adjustment
+
       # Returns the total horizontal overlap of all contours with a
       # text line at the given y range within the given x range.
       # Sum, not max — multiple overlapping contours compound.
@@ -73,12 +151,12 @@ module Idml
         if contour_mode?(pref)
           WrapContour.shape(item, pref, page_height)
         else
-          box_contour(item, page_height)
+          box_contour(item, page_height, pref)
         end
       end
       private_class_method :contour_for
 
-      def self.box_contour(item, page_height)
+      def self.box_contour(item, page_height, pref = nil)
         bounds = item.geometric_bounds
         return nil unless bounds
 
@@ -86,7 +164,8 @@ module Idml
                                        page_height)
         Contour.new(
           x: rect[:x], y: rect[:y],
-          width: rect[:width], height: rect[:height]
+          width: rect[:width], height: rect[:height],
+          side: pref&.text_wrap_side
         )
       end
       private_class_method :box_contour

data/lib/idml/render.rb

@@ -50,14 +50,13 @@ module Idml
 
     # Render an IDML package to a PDF file. All options except
     # `package:` and `to:` are keyword-only and optional.
-    # rubocop:disable Metrics/ParameterLists
+    # rubocop:disable-next Metrics/ParameterLists
     def self.render(package:, to:, font_search_paths: nil, compliance: nil,
                    tagged: false, subset_fonts: true, compress: false)
       Pipeline.new(package, to, font_search_paths,
                    compliance: compliance, tagged: tagged,
                    subset_fonts: subset_fonts, compress: compress).call
     end
-    # rubocop:enable Metrics/ParameterLists
   end
 end
 

data/lib/idml/text_engine/cjk_layout.rb

@@ -74,6 +74,68 @@ module Idml
         TRAILING_COMPRESSION_CODEPOINTS.include?(codepoint)
       end
 
+      # Class-based mojikumi pair compression: a full-width
+      # closing/middle glyph followed by another full-width
+      # punctuation glyph compresses to half advance within the
+      # line (。」、ー） … pairs), matching InDesign's default
+      # mojikumi behavior for consecutive 約物.
+      OPENING_CODEPOINTS = [
+        0x300C, # 「
+        0x300E, # 『
+        0x3008, # 〈
+        0x300A, # 《
+        0x3010, # 【
+        0x3014, # 〔
+        0xFF08, # （fullwidth left paren
+        0xFF3B, # ［
+        0xFF5B, # ｛
+      ].freeze
+
+      MIDDLE_CODEPOINTS = [
+        0x30FB, # ・ fullwidth middle dot
+        0x30FC, # ー prolonged sound mark
+        0x2025, # ‥ two-dot leader
+        0x2026, # … ellipsis
+      ].freeze
+
+      def apply_pair_compression(lines)
+        lines.each do |line|
+          glyphs = line.glyphs
+          (0...(glyphs.length - 1)).each do |index|
+            leading = glyphs[index]
+            following = glyphs[index + 1]
+            next unless pair_compressible?(leading, following)
+
+            leading.width /= 2.0
+          end
+          line.width = glyphs.sum(&:width)
+        end
+        lines
+      end
+
+      # Closing/middle glyph followed by full-width punctuation
+      # compresses the leading glyph to half advance.
+      def pair_compressible?(leading, following)
+        return false unless fullwidth_punct?(following.codepoint)
+
+        closing?(leading.codepoint) ||
+          (middle?(leading.codepoint) &&
+           !OPENING_CODEPOINTS.include?(following.codepoint))
+      end
+
+      def closing?(codepoint)
+        TRAILING_COMPRESSION_CODEPOINTS.include?(codepoint)
+      end
+
+      def middle?(codepoint)
+        MIDDLE_CODEPOINTS.include?(codepoint)
+      end
+
+      def fullwidth_punct?(codepoint)
+        closing?(codepoint) || middle?(codepoint) ||
+          OPENING_CODEPOINTS.include?(codepoint)
+      end
+
       CJK_RANGES = [
         0x3000..0x303F, # CJK Symbols and Punctuation
         0x3040..0x309F, # Hiragana

data/lib/idml/text_engine/justifier.rb

@@ -11,12 +11,14 @@ module Idml
       # InDesign defaults: word spacing max 133%, letter spacing 0%.
       SpacingLimits = Struct.new(
         :max_word_spacing, :max_letter_spacing, :max_glyph_scaling,
+        :min_glyph_scaling,
         keyword_init: true
       )
 
       DEFAULT_MAX_WORD_SPACING = 133.0
       DEFAULT_MAX_LETTER_SPACING = 0.0
       DEFAULT_MAX_GLYPH_SCALING = 100.0
+      DEFAULT_MIN_GLYPH_SCALING = 100.0
 
       def self.justify(line:, frame_width:, alignment: :left,
                        last_line: false, limits: nil)
@@ -55,6 +57,8 @@ module Idml
       def justify_line(line)
         spaces = line.glyphs.count(&:is_space)
         slack = @frame_width - line.width
+        return compress_glyphs(line, slack) if slack.negative?
+
         return if spaces.zero? || slack <= 0
 
         word_share = [slack, word_capacity(line, spaces)].min
@@ -99,6 +103,23 @@ module Idml
       end
       private :distribute_letter_spacing
 
+      # Overlong justified line: compress all glyphs uniformly,
+      # capped at min_glyph_scaling percent. InDesign's default cap
+      # (100%) disables it; only documents that lower the cap get
+      # squeezed glyphs.
+      def compress_glyphs(line, slack)
+        min_pct = @limits&.min_glyph_scaling || DEFAULT_MIN_GLYPH_SCALING
+        shrink = (100 - min_pct) / 100.0
+        return unless shrink.positive?
+
+        total = line.glyphs.sum(&:width)
+        return unless total.positive?
+
+        factor = [-slack / total, shrink].min
+        line.glyphs.each { |glyph| glyph.width *= (1 - factor) }
+      end
+      private :compress_glyphs
+
       # Last resort: uniform glyph scaling for any remaining slack,
       # capped at max_glyph_scaling percent. InDesign's default cap
       # (100%) disables it; only documents that relax the cap get

data/lib/idml/text_engine/line_breaker.rb

@@ -15,6 +15,7 @@ module Idml
         return lines unless cjk_run?(glyphs)
 
         lines = CjkLayout.apply_kinsoku(lines)
+        CjkLayout.apply_pair_compression(lines)
         CjkLayout.apply_line_end_compression(lines)
       end
 

data/lib/idml/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: idml
 version: !ruby/object:Gem::Version
-  version: 0.10.3
+  version: 0.10.6
 platform: ruby
 authors:
 - Ribose
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-08-24 00:00:00.000000000 Z
+date: 2026-08-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bigdecimal
@@ -94,7 +94,10 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description:
+description: 'Pure-Ruby toolkit for Adobe InDesign IDML: schema-faithful models with
+  byte-faithful round-trip, RelaxNG validation, composition operations, and a full
+  IDML-to-PDF rendering pipeline (text layout, tables, CJK vertical writing, text
+  wrap, footnotes, PDF/A).'
 email:
 - open.source@ribose.com
 executables:
@@ -194,6 +197,10 @@ files:
 - TODO.pdf/132-line-end-compression.md
 - TODO.pdf/133-keep-windows.md
 - TODO.pdf/134-table-row-flow.md
+- TODO.pdf/135-minimum-glyph-scaling.md
+- TODO.pdf/136-diagonal-cell-strokes.md
+- TODO.pdf/137-simple-render-footnote-text.md
+- TODO.pdf/138-text-wrap-sides.md
 - TODO.pdf/14-page-item-element-models.md
 - TODO.pdf/15-wire-spread-children.md
 - TODO.pdf/16-typed-model-pipeline.md
@@ -1149,5 +1156,5 @@ requirements: []
 rubygems_version: 3.5.22
 signing_key:
 specification_version: 4
-summary: Parse, manipulate, and round-trip Adobe IDML files.
+summary: Parse, validate, compose, and render Adobe IDML files to PDF.
 test_files: []