idml 0.9.2 → 0.9.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: eb1bde51604723b865996a34842c6a5216b3c0ce4f55947902aa9dd92358ed25
-  data.tar.gz: a1e6ed580c3d0fee769287d3619c33fa6e18ed79ee332d1aa0a7976b1352b760
+  metadata.gz: 41d28cdae1d32efe5815542e9f5f702affff8445c1c77b9e62e3c9229f974dca
+  data.tar.gz: d9144aafa235ef8364cd373bc7f62742bc95ed1b6646f159f00e67f72a1706e2
 SHA512:
-  metadata.gz: 989af27c2ad974dac8d370e335e923b70727a0c32991fe67011c2231cd5b526fdf59e73d571df8423ae69e9e27a5fa03dd69cf94a732ec76138cb34188af0792
-  data.tar.gz: d3daaccd0d51e4a78b825f5ea2f7baf6a3c23c11df1c33eb793b649c23b18bac2255de8e3fc3e3e7d62addac871b77f20879931dac73d6f14fec6fe54c10caea
+  metadata.gz: ca86d99a34bfb4cb1ab62580c3283dda29b21a060435f4dacce15e1069a49bf3009701d34c77700f5308b4c1fcd4e5d11788c89f6802398cb05a872516cae803
+  data.tar.gz: 6b7033ff88e4e5ea4edc4fbdfe7ebdb0024fbcc024107a7f5e5c18e3c7196b6323dcc66ec55485dbc743351c6d15f7bfd3eff922531d2d1ce6d713c9efa99dc7

data/TODO.pdf/118-table-band-fills.md

@@ -0,0 +1,33 @@
+# TODO PDF 118: Table alternating row/column band fills
+
+## Status: COMPLETE — implemented 2026-08-18
+
+## Problem
+
+IDML tables declare table-level alternating fills —
+StartRowFillColor/Count + EndRowFillColor/Count (row banding),
+StartColumnFillColor/Count + EndColumnFillColor/Count (column
+banding), ColumnFillsPriority (true = column banding wins),
+SkipFirst/LastAlternatingFillRows/Columns (edge suppression), and
+per-band tints. All attributes are modeled (TODO 104) but the
+renderer only honored per-Cell FillColor, so banded tables (zebra
+stripes, ledger shading) rendered without their backgrounds.
+
+## What was done
+
+- `SchemaLayout#band_fill(col, row)` computes the effective band
+  color + tint for a cell position: row banding by default; column
+  banding when ColumnFillsPriority is true or row banding is
+  unconfigured; SkipFirst/Last offsets suppress banding at the
+  table edges; "Color/None" band colors render nothing.
+- `TableRenderer` paints the band rect behind each cell BEFORE the
+  cell's own background — an explicit Cell FillColor overrides the
+  band, matching InDesign.
+- `each_cell` now also yields the cell's column/row indices.
+
+## Acceptance criteria
+
+- [x] Rows alternate Start/End colors in the declared counts.
+- [x] Cell-level fill overrides the band.
+- [x] Column banding wins when ColumnFillsPriority is true.
+- [x] SkipFirstAlternatingFillRows suppresses leading bands.

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

@@ -70,15 +70,40 @@ module Idml
         # derived from `column_count` attribute or max col + 1.
         def self.render_schema_faithful(canvas, table, box, context)
           layout = SchemaLayout.new(table: table, box: box)
-          layout.each_cell do |cell_x, cell_y, cell_w, cell_h, cell|
+          layout.each_cell do |cell_x, cell_y, cell_w, cell_h, cell,
+                               col_idx, row_idx|
+            render_band_background(canvas, cell, layout, col_idx, row_idx,
+                                   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
         private_class_method :render_schema_faithful
 
+        # Table-level alternating band fill behind a cell. An
+        # explicit Cell FillColor wins; Color/None bands and zero
+        # tints render nothing.
+        def self.render_band_background(canvas, cell, layout, col_idx,
+                                        row_idx, x, y, w, h, context)
+          return if cell_fill_color(cell, context)
+
+          name, tint = layout.band_fill(col_idx, row_idx)
+          return unless name
+          return if name == "Color/None"
+
+          color = context.color_resolver&.resolve(name)
+          return unless color
+
+          color = ColorHelper.apply_tint(color, tint)
+          canvas.fill_color(ColorHelper.to_canvas(color))
+          canvas.rectangle(x, y, w, h)
+          canvas.fill
+        end
+        private_class_method :render_band_background
+
         def self.render_cell_background(canvas, cell, x, y, w, h, context)
           color = cell_fill_color(cell, context)
           return unless color
@@ -89,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"
@@ -244,7 +359,7 @@ module Idml
 
                 yield cell_x(col_idx), cell_y(row_idx, col_span, row_span),
                       cell_w(col_idx, col_span), cell_h(row_idx, row_span),
-                      cell
+                      cell, col_idx, row_idx
               end
             end
           end
@@ -269,6 +384,79 @@ module Idml
             table.row
           end
 
+          # Table-level alternating band fill for a cell position:
+          # [color_name, tint] or nil. Row banding by default; column
+          # banding when ColumnFillsPriority is true or rows are
+          # unconfigured.
+          def band_fill(col, row)
+            column_band = column_band_fill(col)
+            return column_band if column_band &&
+              (table.column_fills_priority || row_band_fill(row).nil?)
+
+            row_band_fill(row)
+          end
+
+          def row_band_fill(row)
+            band_pair(table.start_row_fill_color, table.start_row_fill_count,
+                      table.end_row_fill_color, table.end_row_fill_count,
+                      table.start_row_fill_tint, table.end_row_fill_tint,
+                      row, row_count,
+                      table.skip_first_alternating_fill_rows,
+                      table.skip_last_alternating_fill_rows)
+          end
+          private :row_band_fill
+
+          def column_band_fill(col)
+            band_pair(table.start_column_fill_color,
+                      table.start_column_fill_count,
+                      table.end_column_fill_color,
+                      table.end_column_fill_count,
+                      table.start_column_fill_tint,
+                      table.end_column_fill_tint,
+                      col, col_count,
+                      table.skip_first_alternating_fill_columns,
+                      table.skip_last_alternating_fill_columns)
+          end
+          private :column_band_fill
+
+          # Alternating band for one axis: the first `start_count`
+          # positions take the start color, the next `end_count` the
+          # end color, repeating from after the skipped edge rows.
+          # Zero-count cycles band nothing.
+          def band_pair(start_color, start_count, end_color, end_count,
+                        start_tint, end_tint, index, total,
+                        skip_first, skip_last)
+            return nil unless start_color
+            return nil if suppressed?(index, total, skip_first, skip_last)
+
+            cycle = band_cycle(start_count, end_count)
+            return nil unless cycle.positive?
+
+            if in_start_band?(index, skip_first, cycle, start_count)
+              [start_color, start_tint]
+            else
+              [end_color, end_tint]
+            end
+          end
+          private :band_pair
+
+          def band_cycle(start_count, end_count)
+            (start_count || 1) + (end_count || 1)
+          end
+          private :band_cycle
+
+          def in_start_band?(index, skip_first, cycle, start_count)
+            ((index - (skip_first || 0)) % cycle) < (start_count || 1)
+          end
+          private :in_start_band?
+
+          # Banding suppressed at the leading/trailing edges.
+          def suppressed?(index, total, skip_first, skip_last)
+            index < (skip_first || 0) ||
+              index >= total - (skip_last || 0)
+          end
+          private :suppressed?
+
           def cells
             table.cell
           end

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.2"
+  VERSION = "0.9.4"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: idml
 version: !ruby/object:Gem::Version
-  version: 0.9.2
+  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
@@ -175,7 +175,11 @@ files:
 - TODO.pdf/116-applied-style-resolution.md
 - 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