idml 0.9.3 → 0.9.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b5306c44be037a52666aa508b9cdb76978561403d72bc43896ea8575b3f61340
-  data.tar.gz: 1d46f1c6de5f53f564f69ccfc41349d48d12b5f3522b7dfae1d01dc79f92ae00
+  metadata.gz: 41d28cdae1d32efe5815542e9f5f702affff8445c1c77b9e62e3c9229f974dca
+  data.tar.gz: d9144aafa235ef8364cd373bc7f62742bc95ed1b6646f159f00e67f72a1706e2
 SHA512:
-  metadata.gz: 4d6830d86be109139a52ee6c2d780f31c33488eee4090b6a64ca938c871fd78429d9da7dbd9b7911d2a814e6908c1a05d53b6083abbb6b74c9d04fec141fcf18
-  data.tar.gz: '0886ff7d2aea4389f5bd0779151be35e6dd40473c2bec635ca4ff25f10321b196c09b171d104f405c4133ab699cfc008773a11533ad43fd870e755cd29b2e168'
+  metadata.gz: ca86d99a34bfb4cb1ab62580c3283dda29b21a060435f4dacce15e1069a49bf3009701d34c77700f5308b4c1fcd4e5d11788c89f6802398cb05a872516cae803
+  data.tar.gz: 6b7033ff88e4e5ea4edc4fbdfe7ebdb0024fbcc024107a7f5e5c18e3c7196b6323dcc66ec55485dbc743351c6d15f7bfd3eff922531d2d1ce6d713c9efa99dc7

data/TODO.pdf/119-justification-spacing-limits.md

@@ -0,0 +1,34 @@
+# TODO PDF 119: Justification word/letter spacing limits
+
+## Status: COMPLETE — implemented 2026-08-19
+
+## Problem
+
+`TextEngine::Justifier` stretched inter-word spaces without limit
+under full justification — a line with one space could widen that
+gap across the whole column. IDML paragraphs declare
+MaximumWordSpacing / MaximumLetterSpacing (percentages,
+InDesign defaults 133% word, 0% letter) that cap how justification
+slack is distributed.
+
+## What was done
+
+- `Justifier::SpacingLimits` (max_word_spacing, max_letter_spacing
+  percentages). `Justifier.justify` takes `limits:`.
+- Distribution: spaces stretch up to the word-spacing cap
+  (capacity = Σ natural_space_width × (max−100)/100); any residual
+  slack goes to letter spacing — an even per-glyph addition capped
+  at max_letter_spacing% of the natural space width. With
+  InDesign's default letter cap of 0%, residual slack stays
+  unfilled and the line ends short, matching InDesign's behavior
+  when limits bind.
+- `StyleResolver::Paragraph` carries maximum_word_spacing /
+  maximum_letter_spacing from the PSR; the frame renderer and the
+  footnote layout both pass the limits.
+
+## Known limitations
+
+- Glyph scaling (Minimum/Maximum/DesiredGlyphScaling) is not
+  applied as a last resort.
+- Minimum word/letter spacing (line compression) is unused — this
+  justifier only ever stretches (slack ≥ 0).

data/TODO.pdf/120-start-paragraph-breaks.md

@@ -0,0 +1,26 @@
+# TODO PDF 120: StartParagraph frame/column breaks
+
+## Status: COMPLETE — implemented 2026-08-19
+
+## Problem
+
+PSR `StartParagraph` (Anywhere / NextPage / NextColumn / NextFrame
+/ NextOddPage / NextEvenPage) was parsed but ignored — forced-break
+paragraphs (chapter headings, magazine copy) rendered mid-frame.
+
+## What was done
+
+- `StyleResolver::Paragraph` carries `start_paragraph` from the
+  PSR.
+- `TextFrameRenderer.consume_paragraphs` stops filling the current
+  frame/column before a paragraph that requests a break (NextPage /
+  NextColumn / NextFrame / NextOddPage / NextEvenPage) — as long as
+  at least one paragraph was already placed there; the paragraph
+  and everything after it flow to the next frame via the existing
+  chain state. Multi-column frames break per column.
+
+## Known limitations
+
+- All break flavors act at frame/column granularity (NextPage and
+  NextFrame are indistinguishable; odd/even page parity is not
+  modeled — the renderer has no page-parity notion at this layer).

data/TODO.pdf/121-cell-edge-strokes.md

@@ -0,0 +1,29 @@
+# TODO PDF 121: Per-side cell edge strokes
+
+## Status: COMPLETE — implemented 2026-08-19
+
+## Problem
+
+`TableRenderer` stroked every cell as a uniform rectangle with the
+canvas default line width. IDML cells declare per-side edge stroke
+weights (TopEdgeStrokeWeight, LeftEdgeStrokeWeight,
+BottomEdgeStrokeWeight, RightEdgeStrokeWeight — with the matching
+stroke colors/tints), and the table declares fallback defaults
+(DefaultRowStrokeWeight / DefaultColumnStrokeWeight).
+
+## What was done
+
+- Cell_Object schema completion: `Elements::Cell` declares all 95
+  schema attributes (77 added — per-side edge strokes + diagonal
+  lines + cell style overrides), generated in schema order like the
+  Table completion (TODO 104).
+- `TableRenderer.render_cell_border` draws each side separately
+  with the cell's edge stroke weight, falling back to the table's
+  default row/column stroke weight, and resolves stroke colors via
+  the color resolver (black fallback). Sides with zero weight are
+  skipped, so weightless cells no longer draw hairlines.
+
+## Known limitations
+
+- Diagonal cell strokes (DiagonalLine*) are modeled but not drawn.
+- Edge stroke types (dashes) fall back to solid.

data/lib/idml/elements/cell.rb

@@ -38,6 +38,88 @@ module Idml
       attribute :paragraph_style_range, Idml::Elements::ParagraphStyleRange,
                 collection: true
 
+      # The remaining Cell_Object attributes (per-side edge strokes,
+      # diagonal lines, cell style overrides, …) in schema order —
+      # generated by `scripts/rnc_to_lutaml.rb` from
+      # reference-docs/schemas/package/Stories/Story.rnc.
+      attribute :top_inset, :float
+      attribute :left_inset, :float
+      attribute :bottom_inset, :float
+      attribute :right_inset, :float
+      attribute :top_left_diagonal_line, :boolean
+      attribute :top_right_diagonal_line, :boolean
+      attribute :diagonal_line_in_front, :boolean
+      attribute :diagonal_line_stroke_weight, :float
+      attribute :diagonal_line_stroke_type, :string
+      attribute :diagonal_line_stroke_color, :string
+      attribute :diagonal_line_stroke_tint, :float
+      attribute :diagonal_line_stroke_overprint, :boolean
+      attribute :diagonal_line_stroke_gap_color, :string
+      attribute :diagonal_line_stroke_gap_tint, :float
+      attribute :diagonal_line_stroke_gap_overprint, :boolean
+      attribute :clip_content_to_cell, :boolean
+      attribute :first_baseline_offset, :string
+      attribute :minimum_first_baseline_offset, :float
+      attribute :left_edge_stroke_weight, :float
+      attribute :left_edge_stroke_type, :string
+      attribute :left_edge_stroke_color, :string
+      attribute :left_edge_stroke_tint, :float
+      attribute :left_edge_stroke_overprint, :boolean
+      attribute :left_edge_stroke_gap_color, :string
+      attribute :left_edge_stroke_gap_tint, :float
+      attribute :left_edge_stroke_gap_overprint, :boolean
+      attribute :top_edge_stroke_weight, :float
+      attribute :top_edge_stroke_type, :string
+      attribute :top_edge_stroke_color, :string
+      attribute :top_edge_stroke_tint, :float
+      attribute :top_edge_stroke_overprint, :boolean
+      attribute :top_edge_stroke_gap_color, :string
+      attribute :top_edge_stroke_gap_tint, :float
+      attribute :top_edge_stroke_gap_overprint, :boolean
+      attribute :right_edge_stroke_weight, :float
+      attribute :right_edge_stroke_type, :string
+      attribute :right_edge_stroke_color, :string
+      attribute :right_edge_stroke_tint, :float
+      attribute :right_edge_stroke_overprint, :boolean
+      attribute :right_edge_stroke_gap_color, :string
+      attribute :right_edge_stroke_gap_tint, :float
+      attribute :right_edge_stroke_gap_overprint, :boolean
+      attribute :bottom_edge_stroke_weight, :float
+      attribute :bottom_edge_stroke_type, :string
+      attribute :bottom_edge_stroke_color, :string
+      attribute :bottom_edge_stroke_tint, :float
+      attribute :bottom_edge_stroke_overprint, :boolean
+      attribute :bottom_edge_stroke_gap_color, :string
+      attribute :bottom_edge_stroke_gap_tint, :float
+      attribute :bottom_edge_stroke_gap_overprint, :boolean
+      attribute :inner_row_stroke_weight, :float
+      attribute :inner_row_stroke_type, :string
+      attribute :inner_row_stroke_color, :string
+      attribute :inner_row_stroke_tint, :float
+      attribute :inner_row_stroke_overprint, :boolean
+      attribute :inner_row_stroke_gap_color, :string
+      attribute :inner_row_stroke_gap_tint, :float
+      attribute :inner_row_stroke_gap_overprint, :boolean
+      attribute :inner_column_stroke_weight, :float
+      attribute :inner_column_stroke_type, :string
+      attribute :inner_column_stroke_color, :string
+      attribute :inner_column_stroke_tint, :float
+      attribute :inner_column_stroke_overprint, :boolean
+      attribute :inner_column_stroke_gap_color, :string
+      attribute :inner_column_stroke_gap_tint, :float
+      attribute :inner_column_stroke_gap_overprint, :boolean
+      attribute :top_edge_stroke_priority, :integer
+      attribute :left_edge_stroke_priority, :integer
+      attribute :bottom_edge_stroke_priority, :integer
+      attribute :right_edge_stroke_priority, :integer
+      attribute :graphic_left_inset, :float
+      attribute :graphic_top_inset, :float
+      attribute :graphic_right_inset, :float
+      attribute :graphic_bottom_inset, :float
+      attribute :clip_content_to_graphic_cell, :boolean
+      attribute :writing_direction, :boolean
+      attribute :applied_cell_style_priority, :integer
+
       xml do
         root "Cell"
         map_attribute "Self", to: :self_attr
@@ -58,6 +140,106 @@ module Idml
         map_attribute "ParagraphSpacingLimit", to: :paragraph_spacing_limit
         map_attribute "RotationAngle", to: :rotation_angle
         map_attribute "AppliedCellStyle", to: :applied_cell_style
+        map_attribute "TopInset", to: :top_inset
+        map_attribute "LeftInset", to: :left_inset
+        map_attribute "BottomInset", to: :bottom_inset
+        map_attribute "RightInset", to: :right_inset
+        map_attribute "TopLeftDiagonalLine", to: :top_left_diagonal_line
+        map_attribute "TopRightDiagonalLine", to: :top_right_diagonal_line
+        map_attribute "DiagonalLineInFront", to: :diagonal_line_in_front
+        map_attribute "DiagonalLineStrokeWeight",
+                      to: :diagonal_line_stroke_weight
+        map_attribute "DiagonalLineStrokeType", to: :diagonal_line_stroke_type
+        map_attribute "DiagonalLineStrokeColor", to: :diagonal_line_stroke_color
+        map_attribute "DiagonalLineStrokeTint", to: :diagonal_line_stroke_tint
+        map_attribute "DiagonalLineStrokeOverprint",
+                      to: :diagonal_line_stroke_overprint
+        map_attribute "DiagonalLineStrokeGapColor",
+                      to: :diagonal_line_stroke_gap_color
+        map_attribute "DiagonalLineStrokeGapTint",
+                      to: :diagonal_line_stroke_gap_tint
+        map_attribute "DiagonalLineStrokeGapOverprint",
+                      to: :diagonal_line_stroke_gap_overprint
+        map_attribute "ClipContentToCell", to: :clip_content_to_cell
+        map_attribute "FirstBaselineOffset", to: :first_baseline_offset
+        map_attribute "MinimumFirstBaselineOffset",
+                      to: :minimum_first_baseline_offset
+        map_attribute "LeftEdgeStrokeWeight", to: :left_edge_stroke_weight
+        map_attribute "LeftEdgeStrokeType", to: :left_edge_stroke_type
+        map_attribute "LeftEdgeStrokeColor", to: :left_edge_stroke_color
+        map_attribute "LeftEdgeStrokeTint", to: :left_edge_stroke_tint
+        map_attribute "LeftEdgeStrokeOverprint", to: :left_edge_stroke_overprint
+        map_attribute "LeftEdgeStrokeGapColor", to: :left_edge_stroke_gap_color
+        map_attribute "LeftEdgeStrokeGapTint", to: :left_edge_stroke_gap_tint
+        map_attribute "LeftEdgeStrokeGapOverprint",
+                      to: :left_edge_stroke_gap_overprint
+        map_attribute "TopEdgeStrokeWeight", to: :top_edge_stroke_weight
+        map_attribute "TopEdgeStrokeType", to: :top_edge_stroke_type
+        map_attribute "TopEdgeStrokeColor", to: :top_edge_stroke_color
+        map_attribute "TopEdgeStrokeTint", to: :top_edge_stroke_tint
+        map_attribute "TopEdgeStrokeOverprint", to: :top_edge_stroke_overprint
+        map_attribute "TopEdgeStrokeGapColor", to: :top_edge_stroke_gap_color
+        map_attribute "TopEdgeStrokeGapTint", to: :top_edge_stroke_gap_tint
+        map_attribute "TopEdgeStrokeGapOverprint",
+                      to: :top_edge_stroke_gap_overprint
+        map_attribute "RightEdgeStrokeWeight", to: :right_edge_stroke_weight
+        map_attribute "RightEdgeStrokeType", to: :right_edge_stroke_type
+        map_attribute "RightEdgeStrokeColor", to: :right_edge_stroke_color
+        map_attribute "RightEdgeStrokeTint", to: :right_edge_stroke_tint
+        map_attribute "RightEdgeStrokeOverprint",
+                      to: :right_edge_stroke_overprint
+        map_attribute "RightEdgeStrokeGapColor",
+                      to: :right_edge_stroke_gap_color
+        map_attribute "RightEdgeStrokeGapTint", to: :right_edge_stroke_gap_tint
+        map_attribute "RightEdgeStrokeGapOverprint",
+                      to: :right_edge_stroke_gap_overprint
+        map_attribute "BottomEdgeStrokeWeight", to: :bottom_edge_stroke_weight
+        map_attribute "BottomEdgeStrokeType", to: :bottom_edge_stroke_type
+        map_attribute "BottomEdgeStrokeColor", to: :bottom_edge_stroke_color
+        map_attribute "BottomEdgeStrokeTint", to: :bottom_edge_stroke_tint
+        map_attribute "BottomEdgeStrokeOverprint",
+                      to: :bottom_edge_stroke_overprint
+        map_attribute "BottomEdgeStrokeGapColor",
+                      to: :bottom_edge_stroke_gap_color
+        map_attribute "BottomEdgeStrokeGapTint",
+                      to: :bottom_edge_stroke_gap_tint
+        map_attribute "BottomEdgeStrokeGapOverprint",
+                      to: :bottom_edge_stroke_gap_overprint
+        map_attribute "InnerRowStrokeWeight", to: :inner_row_stroke_weight
+        map_attribute "InnerRowStrokeType", to: :inner_row_stroke_type
+        map_attribute "InnerRowStrokeColor", to: :inner_row_stroke_color
+        map_attribute "InnerRowStrokeTint", to: :inner_row_stroke_tint
+        map_attribute "InnerRowStrokeOverprint", to: :inner_row_stroke_overprint
+        map_attribute "InnerRowStrokeGapColor", to: :inner_row_stroke_gap_color
+        map_attribute "InnerRowStrokeGapTint", to: :inner_row_stroke_gap_tint
+        map_attribute "InnerRowStrokeGapOverprint",
+                      to: :inner_row_stroke_gap_overprint
+        map_attribute "InnerColumnStrokeWeight", to: :inner_column_stroke_weight
+        map_attribute "InnerColumnStrokeType", to: :inner_column_stroke_type
+        map_attribute "InnerColumnStrokeColor", to: :inner_column_stroke_color
+        map_attribute "InnerColumnStrokeTint", to: :inner_column_stroke_tint
+        map_attribute "InnerColumnStrokeOverprint",
+                      to: :inner_column_stroke_overprint
+        map_attribute "InnerColumnStrokeGapColor",
+                      to: :inner_column_stroke_gap_color
+        map_attribute "InnerColumnStrokeGapTint",
+                      to: :inner_column_stroke_gap_tint
+        map_attribute "InnerColumnStrokeGapOverprint",
+                      to: :inner_column_stroke_gap_overprint
+        map_attribute "TopEdgeStrokePriority", to: :top_edge_stroke_priority
+        map_attribute "LeftEdgeStrokePriority", to: :left_edge_stroke_priority
+        map_attribute "BottomEdgeStrokePriority",
+                      to: :bottom_edge_stroke_priority
+        map_attribute "RightEdgeStrokePriority", to: :right_edge_stroke_priority
+        map_attribute "GraphicLeftInset", to: :graphic_left_inset
+        map_attribute "GraphicTopInset", to: :graphic_top_inset
+        map_attribute "GraphicRightInset", to: :graphic_right_inset
+        map_attribute "GraphicBottomInset", to: :graphic_bottom_inset
+        map_attribute "ClipContentToGraphicCell",
+                      to: :clip_content_to_graphic_cell
+        map_attribute "WritingDirection", to: :writing_direction
+        map_attribute "AppliedCellStylePriority",
+                      to: :applied_cell_style_priority
         map_element "ParagraphStyleRange", to: :paragraph_style_range
       end
 

data/lib/idml/render/footnote.rb

@@ -128,11 +128,16 @@ module Idml
                                             size: size)
           lines = TextEngine::LineBreaker.break(glyphs: glyphs,
                                                 frame_width: wrap_width)
+          limits = TextEngine::Justifier::SpacingLimits.new(
+            max_word_spacing: paragraph.maximum_word_spacing,
+            max_letter_spacing: paragraph.maximum_letter_spacing,
+          )
           lines.each_with_index do |line, index|
             TextEngine::Justifier.justify(
               line: line, frame_width: wrap_width,
               alignment: paragraph.alignment || :left,
-              last_line: last_line?(paragraph, run, index, lines)
+              last_line: last_line?(paragraph, run, index, lines),
+              limits: limits
             )
           end
           leading = TextEngine::VerticalLayout.leading_for(

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

@@ -76,7 +76,8 @@ module Idml
                                    cell_x, cell_y, cell_w, cell_h, context)
             render_cell_background(canvas, cell, cell_x, cell_y, cell_w, cell_h,
                                    context)
-            render_cell_border(canvas, cell_x, cell_y, cell_w, cell_h)
+            render_cell_border(canvas, cell, table, cell_x, cell_y,
+                               cell_w, cell_h, context)
             render_cell_text(canvas, cell, cell_x, cell_y, cell_h, context)
           end
         end
@@ -113,12 +114,102 @@ module Idml
         end
         private_class_method :render_cell_background
 
-        def self.render_cell_border(canvas, x, y, w, h)
-          canvas.rectangle(x, y, w, h)
-          canvas.stroke
+        # Cell borders: per-side strokes when the cell or table
+        # declare edge weights (legacy single rect otherwise, so
+        # undeclared tables keep their existing look). Top/bottom
+        # fall back to the table's default row stroke, left/right
+        # to the default column stroke; zero-weight sides draw
+        # nothing.
+        def self.render_cell_border(canvas, cell, table, x, y, w, h, context)
+          sides = cell_edge_weights(cell, table)
+          if sides.nil?
+            canvas.rectangle(x, y, w, h)
+            canvas.stroke
+            return
+          end
+
+          top, right, bottom, left = sides
+          stroke_cell_side(canvas, context,
+                           cell.top_edge_stroke_color,
+                           table.default_row_stroke_color, top) do
+            canvas.move_to(x, y + h)
+            canvas.line_to(x + w, y + h)
+          end
+          stroke_cell_side(canvas, context,
+                           cell.bottom_edge_stroke_color,
+                           table.default_row_stroke_color, bottom) do
+            canvas.move_to(x, y)
+            canvas.line_to(x + w, y)
+          end
+          stroke_cell_side(canvas, context,
+                           cell.left_edge_stroke_color,
+                           table.default_column_stroke_color, left) do
+            canvas.move_to(x, y)
+            canvas.line_to(x, y + h)
+          end
+          stroke_cell_side(canvas, context,
+                           cell.right_edge_stroke_color,
+                           table.default_column_stroke_color, right) do
+            canvas.move_to(x + w, y)
+            canvas.line_to(x + w, y + h)
+          end
         end
         private_class_method :render_cell_border
 
+        # [top, right, bottom, left] effective weights, or nil when
+        # neither cell edges nor table defaults declare any stroke
+        # (the legacy uniform-rect case).
+        def self.cell_edge_weights(cell, table)
+          return nil unless stroke_declared?(cell, table)
+
+          [
+            side_weight(cell.top_edge_stroke_weight,
+                        table.default_row_stroke_weight),
+            side_weight(cell.right_edge_stroke_weight,
+                        table.default_column_stroke_weight),
+            side_weight(cell.bottom_edge_stroke_weight,
+                        table.default_row_stroke_weight),
+            side_weight(cell.left_edge_stroke_weight,
+                        table.default_column_stroke_weight),
+          ]
+        end
+        private_class_method :cell_edge_weights
+
+        def self.stroke_declared?(cell, table)
+          [
+            cell.top_edge_stroke_weight, cell.right_edge_stroke_weight,
+            cell.bottom_edge_stroke_weight, cell.left_edge_stroke_weight,
+            table.default_row_stroke_weight,
+            table.default_column_stroke_weight
+          ].compact.any?
+        end
+        private_class_method :stroke_declared?
+
+        def self.side_weight(cell_weight, default_weight)
+          cell_weight || default_weight || 0
+        end
+        private_class_method :side_weight
+
+        def self.stroke_cell_side(canvas, context, cell_color,
+                                  table_color, weight)
+          thickness = weight.to_f
+          return unless thickness.positive?
+
+          apply_cell_stroke_color(canvas, context, cell_color, table_color)
+          canvas.line_width = thickness
+          yield
+          canvas.stroke
+        end
+        private_class_method :stroke_cell_side
+
+        def self.apply_cell_stroke_color(canvas, context, cell_color,
+                                         table_color)
+          name = cell_color || table_color
+          color = name && context.color_resolver&.resolve(name)
+          canvas.stroke_color(color ? ColorHelper.to_canvas(color) : [:gray, 1.0])
+        end
+        private_class_method :apply_cell_stroke_color
+
         def self.cell_fill_color(cell, context)
           return nil unless cell.fill_color
           return nil if cell.fill_color == "Color/None"

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

@@ -410,6 +410,7 @@ module Idml
           pending = 0
           state.paragraphs.each do |paragraph|
             break if cursor_y < bottom_limit
+            break if paragraph_break?(paragraph) && pending.positive?
 
             remaining_runs, cursor_y, char_cursor = render_runs_for_paragraph(
               canvas, paragraph, paragraph.runs, context,
@@ -741,16 +742,30 @@ module Idml
         end
         private_class_method :layout_run
 
+        # True when the paragraph requests a forced break to the
+        # next frame/column (StartParagraph). All break flavors act
+        # at frame/column granularity.
+        def self.paragraph_break?(paragraph)
+          %w[NextPage NextColumn NextFrame NextOddPage NextEvenPage]
+            .include?(paragraph.start_paragraph)
+        end
+        private_class_method :paragraph_break?
+
         # Justifies the run's lines; only the final line of the
         # paragraph's final run stays ragged under full
         # justification.
         def self.justify_lines(lines, paragraph, wrap_width,
                                paragraph_last)
+          limits = TextEngine::Justifier::SpacingLimits.new(
+            max_word_spacing: paragraph.maximum_word_spacing,
+            max_letter_spacing: paragraph.maximum_letter_spacing,
+          )
           lines.each_with_index do |line, index|
             TextEngine::Justifier.justify(
               line: line, frame_width: wrap_width,
               alignment: paragraph.alignment || :left,
-              last_line: paragraph_last && index == lines.length - 1
+              last_line: paragraph_last && index == lines.length - 1,
+              limits: limits
             )
           end
         end

data/lib/idml/render/style_resolver.rb

@@ -64,6 +64,12 @@ module Idml
         :right_indent,
         :auto_leading,
         :drop_cap_lines,
+        # Justification distribution caps (percent; from PSR).
+        :maximum_word_spacing,
+        :maximum_letter_spacing,
+        # Forced paragraph break (StartParagraph: NextPage /
+        # NextColumn / NextFrame / NextOddPage / NextEvenPage).
+        :start_paragraph,
         :bullets_and_numbering_list_type,
         :bullet_character_value,
         :bullets_text_after,
@@ -183,6 +189,14 @@ module Idml
             left_indent: resolve_attr(style_lookup, psr, :left_indent),
             right_indent: resolve_attr(style_lookup, psr, :right_indent),
             auto_leading: resolve_attr(style_lookup, psr, :auto_leading),
+            maximum_word_spacing: resolve_attr(
+              style_lookup, psr, :maximum_word_spacing
+            ),
+            maximum_letter_spacing: resolve_attr(
+              style_lookup, psr, :maximum_letter_spacing
+            ),
+            start_paragraph: resolve_attr(style_lookup, psr,
+                                          :start_paragraph),
             drop_cap_lines: resolve_attr(style_lookup, psr, :drop_cap_lines),
             drop_cap_characters: resolve_attr(style_lookup, psr,
                                               :drop_cap_characters),

data/lib/idml/text_engine/justifier.rb

@@ -7,15 +7,25 @@ module Idml
     # spaces for justified text. `last_line:` (the paragraph's final
     # line) keeps ragged right under :justified, as InDesign does.
     class Justifier
+      # Justification distribution caps, in percent (100 = natural).
+      # InDesign defaults: word spacing max 133%, letter spacing 0%.
+      SpacingLimits = Struct.new(
+        :max_word_spacing, :max_letter_spacing, keyword_init: true
+      )
+
+      DEFAULT_MAX_WORD_SPACING = 133.0
+      DEFAULT_MAX_LETTER_SPACING = 0.0
+
       def self.justify(line:, frame_width:, alignment: :left,
-                       last_line: false)
-        new(frame_width, alignment, last_line).justify(line)
+                       last_line: false, limits: nil)
+        new(frame_width, alignment, last_line, limits).justify(line)
       end
 
-      def initialize(frame_width, alignment, last_line)
+      def initialize(frame_width, alignment, last_line, limits)
         @frame_width = frame_width
         @alignment = alignment
         @last_line = last_line
+        @limits = limits
       end
 
       def justify(line)
@@ -45,13 +55,42 @@ module Idml
         slack = @frame_width - line.width
         return if spaces.zero? || slack <= 0
 
-        extra = slack / spaces
+        word_share = [slack, word_capacity(line, spaces)].min
+        extra = word_share / spaces
         line.glyphs.each do |glyph|
           next unless glyph.is_space
 
           glyph.width += extra
         end
+        residual = slack - word_share
+        distribute_letter_spacing(line, residual) if residual.positive?
+      end
+
+      # Total room the word spaces may grow within the max-word-
+      # spacing cap (percent of each space's natural width).
+      def word_capacity(line, _spaces)
+        max_pct = @limits&.max_word_spacing || DEFAULT_MAX_WORD_SPACING
+        grow = [(max_pct - 100) / 100.0, 0].max
+        line.glyphs.sum { |g| g.is_space ? g.width * grow : 0.0 } * 1.0
+      end
+      private :word_capacity
+
+      # Even per-glyph letter spacing for residual slack, capped at
+      # max_letter_spacing percent of the natural space width. With
+      # the default 0% cap nothing is added — the line ends short,
+      # as InDesign does when limits bind.
+      def distribute_letter_spacing(line, residual)
+        max_pct = @limits&.max_letter_spacing || DEFAULT_MAX_LETTER_SPACING
+        return unless max_pct.positive?
+
+        space_ref = line.glyphs.find(&:is_space)&.width || 0
+        return unless space_ref.positive?
+
+        cap = (max_pct / 100.0) * space_ref * line.glyphs.length
+        add = [residual, cap].min / line.glyphs.length
+        line.glyphs.each { |glyph| glyph.width += add }
       end
+      private :distribute_letter_spacing
     end
   end
 end

data/lib/idml/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: idml
 version: !ruby/object:Gem::Version
-  version: 0.9.3
+  version: 0.9.4
 platform: ruby
 authors:
 - Ribose
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-08-18 00:00:00.000000000 Z
+date: 2026-08-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bigdecimal
@@ -176,7 +176,10 @@ files:
 - TODO.pdf/116-justification-last-line.md
 - TODO.pdf/117-endnote-support.md
 - TODO.pdf/118-table-band-fills.md
+- TODO.pdf/119-justification-spacing-limits.md
 - TODO.pdf/12-idml-to-pdf-pipeline.md
+- TODO.pdf/120-start-paragraph-breaks.md
+- TODO.pdf/121-cell-edge-strokes.md
 - TODO.pdf/13-cjk-text-layout.md
 - TODO.pdf/14-page-item-element-models.md
 - TODO.pdf/15-wire-spread-children.md