idml 0.10.6 → 0.10.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f60b5f9020e44d5131e9f50e2ddfb673f9caca65bbdee8428b4670baaf96108f
-  data.tar.gz: 1f19b80511a14cea5fab0b76404be809a8f28e680deb91ee1b4caf9353a1b756
+  metadata.gz: e05a75aaa533dcd8f478d6b4ab635d15cf6c64ac85bebbd42fe3b136ed0c6783
+  data.tar.gz: 3a478cdb4b23ac26ceb9914d5e3740286ef6fda60c80605a01dc6f2a38086b7a
 SHA512:
-  metadata.gz: 9bea97bee388cae4ab403c3bea6cae233c3a378c569c0c678620bdb59a3ed5534ab9aa560866fad103d8a724351e396c72e9a533671fd44189719958f83d811e
-  data.tar.gz: 151917cdee9265410c788c85fb6f28d45d07ffc37cc3c4e3fc14b4578f2be57adee09393c284a53a883f1f1dbe105920ecd745a264f0311cc38c0c8f92d94a05
+  metadata.gz: effb89c7a3869aa7c268027e4653ecc2072fc41402d53ff2ad8ca0405862b83076bd82637cc9f64a369cd3ceb2ca23b2e6e9ca7ba300de2fd9f073801c65c199
+  data.tar.gz: 371206ab57061b8fa94733db6e489565eeb0cd588ffb6b0908a9a0c6e84fcec2d64745501dd8ec7b8147cb3044119c47d08f479e50cec26e939a35f5127ecf9e

data/TODO.pdf/139-hyphen-break-opportunities.md

@@ -0,0 +1,24 @@
+# TODO PDF 139: Hyphen break opportunities in the LineBreaker
+
+## Status: COMPLETE — implemented 2026-08-27
+
+## Problem
+
+The greedy line breaker only treated spaces as break opportunities.
+Long compound words ("state-of-the-art", "e-mail") overflowed the
+frame as one unbreakable run instead of wrapping after a hyphen.
+
+## Solution
+
+`LineBreaker#break_after?` treats hyphen-minus (U+002D), Unicode
+hyphen (U+2010), non-breaking hyphen (U+2011), and soft hyphen
+(U+00AD) as break-after points: the hyphen stays on the first line
+and the remainder wraps. Soft hyphens break without adding a
+visible hyphen. Dictionary-based hyphenation (Knuth-Liang) remains
+out of scope — the Hyphenation* PSR attributes stay parsed but
+unused.
+
+## Files
+
+- `lib/idml/text_engine/line_breaker.rb`
+- `spec/idml/text_engine/text_engine_spec.rb`

data/TODO.pdf/140-cap-xheight-first-baselines.md

@@ -0,0 +1,29 @@
+# TODO PDF 140: CapHeight / XHeight / EmboxHeight first baselines
+
+## Status: COMPLETE — implemented 2026-08-27
+
+## Problem
+
+FirstBaselineOffset honored AscentOffset and FixedHeight (TODO 128)
+but approximated CapHeight, XHeight, and EmboxHeight as leading —
+text sat noticeably lower than InDesign places it.
+
+## Solution
+
+`TextFrameRenderer#baseline_target` now handles all five modes:
+
+- **CapHeight** — the font's cap-height metric when the provider
+  fills it; pdfrb 0.7.1 never does, so the fallback is the standard
+  0.72 em proportion (Arial and Helvetica both sit within 1%).
+- **XHeight** — 0.52 em (no x-height metric exists in pdfrb).
+- **EmboxHeight** — the em box itself: the first paragraph's point
+  size.
+
+`PdfrbFontMetrics#cap_height` exposes the metric for when pdfrb
+starts populating it.
+
+## Files
+
+- `lib/idml/render/renderers/text_frame_renderer.rb`
+- `lib/idml/text_engine/pdfrb_font_metrics.rb`
+- `spec/idml/render/first_baseline_spec.rb`

data/TODO.pdf/141-perf-hundred-pages.md

@@ -0,0 +1,22 @@
+# TODO PDF 141: 100+ page performance regression guard
+
+## Status: COMPLETE — implemented 2026-08-27
+
+## Problem
+
+No test guarded against per-page complexity blowups — a regression
+to O(document) work per page would only surface as slow user
+renders.
+
+## Solution
+
+`perf_hundred_pages_spec.rb` builds a synthetic 120-spread package
+(one page + one text frame each, all sharing a wordy story) and
+renders it end-to-end through `Idml::Render.render`. Asserts all
+120 PDF pages emit and the render completes under a generous 60s
+ceiling — sized to trip only on pathological blowups, not machine
+noise. Baseline on this branch: ~2s for 120 pages.
+
+## Files
+
+- `spec/idml/render/perf_hundred_pages_spec.rb`

data/TODO.pdf/142-vertical-latin-run-groups.md

@@ -0,0 +1,27 @@
+# TODO PDF 142: Run-grouped Latin rotation in vertical writing
+
+## Status: COMPLETE — implemented 2026-08-27
+
+## Problem
+
+In vertical (StoryOrientation="Vertical") text, every non-CJK glyph
+rotated 90° individually — each Latin letter got its own rotated
+graphics state and stacked one cell apart. InDesign rotates a whole
+Latin run as one block (the word reads sideways as a unit).
+
+## Solution
+
+`TextFrameRenderer#emit_vertical_stack` partitions a vertical run's
+glyphs: CJK singletons stay upright; consecutive non-CJK glyphs
+(groups never span columns, x-reset on column change) render as ONE
+text op inside a single rotated graphics state. The font's natural
+advances land each glyph exactly where per-glyph rotation placed
+it, so the change is lossless for position — but a whole word now
+rotates as a unit and emits one op instead of N. The per-glyph
+`emit_vertical_glyph` path is gone (dead after grouping covered it).
+
+## Files
+
+- `lib/idml/render/renderers/text_frame_renderer.rb`
+- `spec/idml/render/vertical_render_spec.rb`
+- `spec/idml/render/vertical_multirun_spec.rb`

data/TODO.pdf/143-jump-object-below.md

@@ -0,0 +1,31 @@
+# TODO PDF 143: JumpObject wrap — text below the object
+
+## Status: COMPLETE — implemented 2026-08-27
+
+## Problem
+
+JumpObjectTextWrap approximated as the bounding box: text narrowed
+beside the object. InDesign's JumpObject means text NEVER flows
+beside the object — it continues below it.
+
+## Solution
+
+- `TextWrapResolver::Contour` gains a `jump` flag, set from
+  `TextWrapMode="JumpObjectTextWrap"`.
+- A jump contour blocks the FULL frame width in
+  `wrap_adjustment`.
+- `TextFrameRenderer#skip_below_jump_object`: when the run's band
+  is fully blocked (wrap width below the point size), the cursor
+  skips to `jump_contour_bottom` — the blocking object's bottom
+  edge — and the wrap re-measures there once. Text resumes below
+  the object, never beside it.
+
+NextColumn still approximates as the box (it needs column-jump
+chaining, documented in TODO.pdf/61).
+
+## Files
+
+- `lib/idml/render/text_wrap_resolver.rb`
+- `lib/idml/render/renderers/text_frame_renderer.rb`
+- `spec/idml/render/text_wrap_resolver_spec.rb`
+- `spec/idml/render/jump_object_render_spec.rb` (end-to-end)

data/TODO.pdf/144-mojikumi-table-model.md

@@ -0,0 +1,36 @@
+# TODO PDF 144: Named mojikumi sets modeled
+
+## Status: COMPLETE (modeling) — implemented 2026-08-27
+
+## Problem
+
+Designmap-level `<MojikumiTable>` elements (named mojikumi sets:
+詳細 etc. with per-class-pair aki overrides) were ignored by the
+model — a document declaring custom spacing lost that information
+on round-trip.
+
+## Solution
+
+New elements per `designmap.rnc` / `datatype.rnc`:
+
+- `Elements::MojikumiTable` — Self / Name / BasedOnMojikumiSet +
+  `#aki_overrides` (flattened document-order overrides).
+- `Elements::MojikumiTableProperties` — OverrideMojikumiAkiList.
+- `Elements::OverrideMojikumiAkiList` — the entries.
+- `Elements::OverrideMojikumiAki` — all 8 typedef attributes
+  (Target/SideMojikumiClass, SideIsAfterTarget, Minimum/Desired/
+  Maximum, CompressionPriority, AkiDoesNotFloat).
+
+`Parts::Designmap` maps the children; round-trip verified.
+
+**Not yet applied**: rendering still uses the built-in class-based
+aki rules (TODOs 125/132/13); consuming BasedOnMojikumiSet and the
+override entries in `CjkLayout` is the follow-up (TODO.pdf/61).
+
+## Files
+
+- `lib/idml/elements/mojikumi_table.rb`
+- `lib/idml/parts/designmap.rb`
+- `lib/idml/elements.rb`
+- `spec/idml/elements/mojikumi_table_spec.rb`
+- `spec/idml/parts/designmap_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-26
+## Status: DOCUMENTED — refreshed 2026-08-27 (second refresh)
 
 Previously listed limitations (font embedding, tagged PDF, per-run
 styling, dead code) were resolved by TODOs 52/53/55/67/76 long ago;
@@ -9,8 +9,9 @@ this list reflects the current state.
 ## Known limitations
 
 ### Text layout
-- **Hyphenation** is not implemented (Hyphenation* attributes are
-  parsed but unused); a hyphenation dictionary would be required.
+- **Hyphenation**: dictionary-based hyphenation is not implemented
+  (Hyphenation* attributes are parsed but unused); compound words
+  wrap after explicit hyphens (TODO 139).
 - **Justification**: word/letter spacing caps apply (TODO 119),
   MaximumGlyphScaling stretches (TODO 129) and MinimumGlyphScaling
   compresses overlong lines (TODO 135); ToBinding / RTL binding
@@ -18,22 +19,27 @@ this list reflects the current state.
 - **Keep options**: KeepAllLinesTogether (TODO 123), KeepWithNext
   (TODO 127), and the KeepFirstLines / KeepLastLines windows
   (TODO 133, line-count approximation) are honored.
-- **First baseline**: AscentOffset and FixedHeight are honored
-  (TODO 128); CapHeight / XHeight approximate as leading.
+- **First baseline**: all five modes honor their metrics (TODOs
+  128/140); CapHeight / XHeight use standard font proportions
+  (0.72 / 0.52 em) until a metrics provider fills them.
 - **StartParagraph** breaks act at frame/column granularity — no
   odd/even page parity.
 - **Text wrap**: BoundingBoxTextWrap, Contour, and Inverse modes
   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.
+  variants approximate as BothSides); JumpObject moves text below
+  the object (TODO 143); NextColumn approximates as the box;
+  Contour-mode shapes are not side-aware.
 
 ### CJK
 - **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.
+  (TODO 132), and class-based pair compression are applied; named
+  mojikumi sets are modeled (TODO 144: MojikumiTable +
+  OverrideMojikumiAki parse and round-trip) but not yet APPLIED to
+  layout — the built-in class-based aki rules stand in.
+- **Vertical mode**: Latin runs rotate as one group per segment
+  (TODO 142); ruby placement is beside-column; keep options do
+  not apply.
 
 ### Structural features
 - **Endnotes** (TODO 117): reference markers render and endnote TEXT
@@ -54,4 +60,7 @@ this list reflects the current state.
 
 - Hyphenation dictionary integration
 - Shape-mode text wrap contours (side-aware)
-- Performance benchmark for 100+ page documents
+- Apply named mojikumi sets to CJK layout (consume TODO 144's model)
+- NextColumn wrap via column-jump chaining
+- ToBinding / RTL binding alignment
+- Vertical-mode keep options

data/lib/idml/elements/mojikumi_table.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module Idml
+  module Elements
+    # One aki override (per `OverrideMojikumiAkiType_TypeDef`):
+    # spacing between the Target and Side character classes, as
+    # minimum / desired / maximum.
+    class OverrideMojikumiAki < Lutaml::Model::Serializable
+      attribute :target_mojikumi_class, :integer
+      attribute :side_mojikumi_class, :integer
+      attribute :side_is_after_target, :boolean
+      attribute :minimum, :float
+      attribute :desired, :float
+      attribute :maximum, :float
+      attribute :compression_priority, :integer
+      attribute :aki_does_not_float, :boolean
+
+      xml do
+        root "OverrideMojikumiAkiType"
+        map_attribute "TargetMojikumiClass", to: :target_mojikumi_class
+        map_attribute "SideMojikumiClass", to: :side_mojikumi_class
+        map_attribute "SideIsAfterTarget", to: :side_is_after_target
+        map_attribute "Minimum", to: :minimum
+        map_attribute "Desired", to: :desired
+        map_attribute "Maximum", to: :maximum
+        map_attribute "CompressionPriority", to: :compression_priority
+        map_attribute "AkiDoesNotFloat", to: :aki_does_not_float
+      end
+    end
+
+    # `<OverrideMojikumiAkiList>` — the per-class-pair override
+    # entries of a named mojikumi set.
+    class OverrideMojikumiAkiList < Lutaml::Model::Serializable
+      attribute :override_mojikumi_aki, OverrideMojikumiAki,
+                collection: true
+
+      xml do
+        root "OverrideMojikumiAkiList"
+        map_element "OverrideMojikumiAkiType",
+                    to: :override_mojikumi_aki
+      end
+    end
+
+    # `<Properties>` inside a MojikumiTable — carries the aki
+    # override list.
+    class MojikumiTableProperties < Lutaml::Model::Serializable
+      attribute :override_mojikumi_aki_list, OverrideMojikumiAkiList,
+                collection: true
+
+      xml do
+        root "Properties"
+        map_element "OverrideMojikumiAkiList",
+                    to: :override_mojikumi_aki_list
+      end
+    end
+
+    # Typed model of `<MojikumiTable>` (TODO 144) — a named
+    # mojikumi set declared at the designmap level. Named sets are
+    # modeled (parsed and round-tripped) but not yet APPLIED: the
+    # renderer keeps using the built-in class-based aki rules (see
+    # TODO.pdf/61).
+    class MojikumiTable < Lutaml::Model::Serializable
+      attribute :self_attr, :string
+      attribute :name, :string
+      attribute :based_on_mojikumi_set, :string
+      attribute :properties, MojikumiTableProperties, collection: true
+
+      xml do
+        root "MojikumiTable"
+        map_attribute "Self", to: :self_attr
+        map_attribute "Name", to: :name
+        map_attribute "BasedOnMojikumiSet", to: :based_on_mojikumi_set
+        map_element "Properties", to: :properties
+      end
+
+      # Aki overrides in document order, flattened across the
+      # Properties > OverrideMojikumiAkiList chain.
+      def aki_overrides
+        properties.flat_map do |prop|
+          prop.override_mojikumi_aki_list.flat_map(&:override_mojikumi_aki)
+        end
+      end
+    end
+  end
+end

data/lib/idml/elements.rb

@@ -90,6 +90,10 @@ module Idml
     autoload :MasterSpreadObject, "idml/elements/master_spread_object"
     autoload :MixedInk, "idml/elements/mixed_ink"
     autoload :MixedInkGroup, "idml/elements/mixed_ink_group"
+    autoload :MojikumiTable, "idml/elements/mojikumi_table"
+    autoload :MojikumiTableProperties, "idml/elements/mojikumi_table"
+    autoload :OverrideMojikumiAki, "idml/elements/mojikumi_table"
+    autoload :OverrideMojikumiAkiList, "idml/elements/mojikumi_table"
     autoload :MojikumiUiPreference, "idml/elements/pref_mojikumi_ui_preference"
     autoload :ObjectExportOption, "idml/elements/object_export_option"
     autoload :ObjectStyle, "idml/elements/object_style"

data/lib/idml/parts/designmap.rb

@@ -54,6 +54,8 @@ module Idml
                 Idml::Elements::HyperlinkPageDestination, collection: true
       attribute :hyperlink_url_destination,
                 Idml::Elements::HyperlinkURLDestination, collection: true
+      attribute :mojikumi_table, Idml::Elements::MojikumiTable,
+                collection: true
 
       xml do
         root "Document"
@@ -99,6 +101,7 @@ module Idml
                     to: :hyperlink_page_destination
         map_element "HyperlinkURLDestination",
                     to: :hyperlink_url_destination
+        map_element "MojikumiTable", to: :mojikumi_table
       end
     end
   end

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

@@ -332,13 +332,60 @@ module Idml
               emit_upright_glyph(canvas, glyph, run, context, size)
             end
           else
-            positioned.each do |glyph|
-              emit_vertical_glyph(canvas, glyph, run, context, size)
-            end
+            emit_vertical_stack(canvas, positioned, run, context, size)
           end
         end
         private_class_method :emit_vertical_run
 
+        # Vertical-stack emission: CJK glyphs stand upright per
+        # glyph; consecutive non-CJK glyphs rotate as ONE group
+        # (the whole Latin word sideways, as InDesign does). The
+        # group's string renders as a single text op inside one
+        # rotated graphics state — the font's advances land each
+        # glyph exactly where per-glyph rotation placed it. A group
+        # never spans columns (x reset) and shares the run's
+        # styling, so one text op is lossless.
+        def self.emit_vertical_stack(canvas, positioned, run, context,
+                                     size)
+          segment = []
+          positioned.each do |glyph|
+            if TextEngine::CjkLayout.cjk?(glyph.codepoint)
+              flush_vertical_segment(canvas, segment, run, context, size)
+              emit_upright_glyph(canvas, glyph, run, context, size)
+            else
+              if !segment.empty? && segment.last.x != glyph.x
+                flush_vertical_segment(canvas, segment, run, context, size)
+              end
+              segment << glyph
+            end
+          end
+          flush_vertical_segment(canvas, segment, run, context, size)
+        end
+        private_class_method :emit_vertical_stack
+
+        def self.flush_vertical_segment(canvas, segment, run, context,
+                                        size)
+          return if segment.empty?
+
+          text = segment.map { |g| [g.codepoint].pack("U") }.join
+          first = segment.first
+          canvas.save_graphics_state do
+            # 90° clockwise: exact matrix (rotate would emit
+            # cos/sin float noise like 6.1e-17).
+            canvas.concat(0, -1, 1, 0, first.x, first.y)
+            text_kwargs = CharacterStyle.text_kwargs(
+              run,
+              {
+                at: [0, 0],
+                font: font_for_run(run, context),
+                size: size,
+              },
+            )
+            canvas.text(text, **text_kwargs)
+          end
+        end
+        private_class_method :flush_vertical_segment
+
         def self.emit_upright_glyph(canvas, positioned, run, context,
                                     size)
           text = [positioned.codepoint].pack("U")
@@ -361,43 +408,6 @@ module Idml
         end
         private_class_method :vertical_fits?
 
-        # Emits one upright glyph at its vertical position with the
-        # run's character styling.
-        # Emits one glyph in vertical mode: CJK upright; Latin
-        # (non-CJK) rotated 90° clockwise per the vertical-writing
-        # convention, via a graphics-state transform.
-        def self.emit_vertical_glyph(canvas, positioned, run, context,
-                                     size)
-          text = [positioned.codepoint].pack("U")
-          if TextEngine::CjkLayout.cjk?(positioned.codepoint)
-            text_kwargs = CharacterStyle.text_kwargs(
-              run,
-              {
-                at: [positioned.x, positioned.y],
-                font: font_for_run(run, context),
-                size: size,
-              },
-            )
-            canvas.text(text, **text_kwargs)
-          else
-            canvas.save_graphics_state do
-              # 90° clockwise: exact matrix (rotate would emit
-              # cos/sin float noise like 6.1e-17).
-              canvas.concat(0, -1, 1, 0, positioned.x, positioned.y)
-              text_kwargs = CharacterStyle.text_kwargs(
-                run,
-                {
-                  at: [0, 0],
-                  font: font_for_run(run, context),
-                  size: size,
-                },
-              )
-              canvas.text(text, **text_kwargs)
-            end
-          end
-        end
-        private_class_method :emit_vertical_glyph
-
         # Emits the run's ruby alongside its vertical glyphs:
         # stacked top-to-bottom beside the column — right side by
         # default, left for Below* RubyPosition values (the
@@ -629,12 +639,19 @@ module Idml
         # the first line's baseline sits. The layout's default is
         # leading-based; AscentOffset shifts by (ascent − leading)
         # and FixedHeight by (MinimumFirstBaselineOffset − leading).
-        # CapHeight / XHeight / EmboxHeight approximate as leading.
-        # Returns the extra shift to subtract from the cursor.
+        # CapHeight uses the font's cap-height metric (leading
+        # fallback when the font reports none); XHeight approximates
+        # as 70% of cap height; EmboxHeight uses the em box (the
+        # first paragraph's point size). Returns the extra shift to
+        # subtract from the cursor.
+        FIRST_BASELINE_MODES = %w[
+          AscentOffset FixedHeight CapHeight XHeight EmboxHeight
+        ].freeze
+
         def self.first_baseline_offset(context, state, font)
           pref = context.item&.text_frame_preference&.first
           mode = pref&.first_baseline_offset
-          return 0.0 unless %w[AscentOffset FixedHeight].include?(mode)
+          return 0.0 unless FIRST_BASELINE_MODES.include?(mode)
 
           baseline_target(pref, mode, state, font) -
             first_paragraph_leading(state)
@@ -643,21 +660,52 @@ module Idml
 
         # Distance from the top inset to the first baseline under
         # the given mode.
+        # pdfrb 0.7.1 never fills the cap_height metric, so
+        # CapHeight / XHeight fall back to standard font
+        # proportions (cap ≈ 0.72 em, x ≈ 0.52 em — Arial and
+        # Helvetica both sit within 1% of these).
+        CAP_HEIGHT_RATIO = 0.72
+        X_HEIGHT_RATIO = 0.52
+
         def self.baseline_target(pref, mode, state, font)
-          if mode == "AscentOffset"
-            ascent_scaled(font) * first_paragraph_leading(state)
+          leading = first_paragraph_leading(state)
+          case mode
+          when "AscentOffset"
+            ratio_scaled(font.ascent, font) * leading
+          when "CapHeight"
+            cap_ratio(font) * leading
+          when "XHeight"
+            X_HEIGHT_RATIO * leading
+          when "EmboxHeight"
+            first_paragraph_size(state)
           else
-            pref.minimum_first_baseline_offset ||
-              first_paragraph_leading(state)
+            pref.minimum_first_baseline_offset || leading
           end
         end
         private_class_method :baseline_target
 
-        def self.ascent_scaled(font)
-          upem = font.units_per_em.zero? ? 1 : font.units_per_em
-          font.ascent / upem
+        def self.cap_ratio(font)
+          cap = font.cap_height
+          return CAP_HEIGHT_RATIO unless cap
+
+          ratio_scaled(cap, font)
+        end
+        private_class_method :cap_ratio
+
+        def self.ratio_scaled(metric, font)
+          upem = font.units_per_em
+          return 1.0 if upem.zero?
+
+          metric / upem
         end
-        private_class_method :ascent_scaled
+        private_class_method :ratio_scaled
+
+        def self.first_paragraph_size(state)
+          paragraph = state.current_paragraph || state.paragraphs.first
+          first_run = paragraph&.runs&.first
+          first_run&.point_size || DEFAULT_SIZE
+        end
+        private_class_method :first_paragraph_size
 
         def self.first_paragraph_leading(state)
           paragraph = state.current_paragraph || state.paragraphs.first
@@ -843,6 +891,10 @@ module Idml
               context, layout_frame, cursor_y, run
             )
             run_wrap -= wrap_reduction
+            cursor_y, run_wrap, wrap_shift = skip_below_jump_object(
+              context, layout_frame, cursor_y, run, run_wrap, wrap_shift,
+              wrap_reduction, bottom_limit
+            )
             positioned, next_y = layout_run(
               canvas, run, paragraph, context, layout_frame, font,
               run_wrap, cursor_y, space_before,
@@ -908,6 +960,42 @@ module Idml
         end
         private_class_method :render_footnote_entries
 
+        # JumpObjectTextWrap blocks the full column width: when the
+        # run's band is fully blocked, move the cursor below the
+        # object's bottom edge and re-measure once. InDesign's
+        # semantics — text flows under the object, never beside it.
+        # Returns the (possibly skipped) cursor and re-measured
+        # wrap geometry.
+        def self.skip_below_jump_object(context, layout_frame, cursor_y,
+                                        run, run_wrap, wrap_shift,
+                                        wrap_reduction, bottom_limit)
+          min_width = run.point_size || DEFAULT_SIZE
+          return [cursor_y, run_wrap, wrap_shift] if run_wrap >= min_width
+
+          skip_y = text_wrap_jump_below(context, layout_frame, cursor_y, run)
+          return [cursor_y, run_wrap, wrap_shift] unless skip_y
+          return [cursor_y, run_wrap, wrap_shift] if skip_y >= cursor_y
+          return [cursor_y, run_wrap, wrap_shift] if skip_y <= bottom_limit
+
+          reduction, shift = text_wrap_adjust(context, layout_frame,
+                                              skip_y, run)
+          [skip_y, [run_wrap + wrap_reduction - reduction, 0].max, shift]
+        end
+        private_class_method :skip_below_jump_object
+
+        def self.text_wrap_jump_below(context, layout_frame, cursor_y, run)
+          resolver = context.text_wrap_resolver
+          return nil 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)
+          resolver.jump_contour_bottom(cursor_y, size, frame_x,
+                                       frame_right)
+        end
+        private_class_method :text_wrap_jump_below
+
         # 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

data/lib/idml/render/text_wrap_resolver.rb

@@ -18,7 +18,7 @@ module Idml
     class TextWrapResolver
       # A wrap contour: a PDF-coordinate rectangle the text avoids.
       Contour = Struct.new(
-        :x, :y, :width, :height, :inverse, :side,
+        :x, :y, :width, :height, :inverse, :side, :jump,
         keyword_init: true
       )
 
@@ -86,10 +86,34 @@ module Idml
 
         return [0.0, 0.0] if overlap.zero?
 
+        # JumpObject: text never flows beside the object — the full
+        # frame width is blocked and the renderer skips the run
+        # below the object's bottom edge.
+        return [frame_right - frame_x, 0.0] if contour.jump
+
         side_adjustment(contour, overlap, frame_x, frame_right)
       end
       private :box_adjustment
 
+      # Bottom edge of the lowest jump contour overlapping the given
+      # band — where text resumes below a JumpObject. nil when no
+      # jump contour blocks the band.
+      def jump_contour_bottom(line_y, line_height, frame_x, frame_right)
+        bottoms = @contours.filter_map do |contour|
+          next unless box_contour?(contour) && contour.jump
+          next unless y_overlap?(contour, line_y, line_height) &&
+            x_overlap?(contour, frame_x, frame_right)
+
+          contour.y
+        end
+        bottoms.min
+      end
+
+      def box_contour?(contour)
+        !contour.is_a?(WrapContour::Shape)
+      end
+      private :box_contour?
+
       def side_adjustment(contour, overlap, frame_x, frame_right)
         case contour.side
         when "LeftSide"
@@ -165,7 +189,8 @@ module Idml
         Contour.new(
           x: rect[:x], y: rect[:y],
           width: rect[:width], height: rect[:height],
-          side: pref&.text_wrap_side
+          side: pref&.text_wrap_side,
+          jump: pref&.text_wrap_mode == "JumpObjectTextWrap"
         )
       end
       private_class_method :box_contour

data/lib/idml/text_engine/line_breaker.rb

@@ -6,10 +6,16 @@ module Idml
     Line = Struct.new(:glyphs, :width, :x_offset)
 
     # Greedy word-wrap line breaker. Accumulates glyphs until
-    # exceeding the frame width, then breaks at the last space.
-    # CJK runs get a kinsoku shori post-pass (no line starts or
-    # ends with a forbidden character).
+    # exceeding the frame width, then breaks at the last break
+    # opportunity: a space, or a hyphen (compound words wrap after
+    # the hyphen, which stays on the first line). CJK runs get a
+    # kinsoku shori post-pass (no line starts or ends with a
+    # forbidden character).
     class LineBreaker
+      # Break-after opportunities besides spaces: hyphen-minus,
+      # the Unicode hyphens, and the soft hyphen (which breaks
+      # without adding a visible hyphen).
+      HYPHEN_CODEPOINTS = [0x2D, 0x2010, 0x2011, 0x00AD].freeze
       def self.break(glyphs:, frame_width:)
         lines = new(frame_width).break(glyphs)
         return lines unless cjk_run?(glyphs)
@@ -44,26 +50,26 @@ module Idml
         lines = []
         current = []
         current_width = 0
-        last_space_idx = -1
-        width_at_space = 0
+        break_idx = -1
+        width_at_break = 0
 
         glyphs.each_with_index do |glyph, _idx|
           current << glyph
           current_width += glyph.width
 
-          if glyph.is_space
-            last_space_idx = current.length - 1
-            width_at_space = current_width
+          if break_after?(glyph)
+            break_idx = current.length - 1
+            width_at_break = current_width
           end
 
           next unless current_width > @frame_width && current.length > 1
 
-          if last_space_idx >= 0
-            line_glyphs = current[0..last_space_idx]
-            lines << Line.new(line_glyphs, width_at_space, 0)
-            current = current[(last_space_idx + 1)..]
+          if break_idx >= 0
+            line_glyphs = current[0..break_idx]
+            lines << Line.new(line_glyphs, width_at_break, 0)
+            current = current[(break_idx + 1)..]
             current_width = current.sum(&:width)
-            last_space_idx = -1
+            break_idx = -1
           elsif cjk_break?(current)
             lines << Line.new(current[0..-2], current_width - glyph.width, 0)
             current = [glyph]
@@ -78,6 +84,11 @@ module Idml
         lines << Line.new(current, current_width, 0) if current.any?
         lines
       end
+
+      def break_after?(glyph)
+        glyph.is_space || HYPHEN_CODEPOINTS.include?(glyph.codepoint)
+      end
+      private :break_after?
     end
   end
 end

data/lib/idml/text_engine/pdfrb_font_metrics.rb

@@ -37,6 +37,12 @@ module Idml
         0
       end
 
+      # Cap height in font units; nil when the font tables don't
+      # report one (some pdfrb-loaded fonts).
+      def cap_height
+        metrics_data[:cap_height]
+      end
+
       # Returns raw advance width in font units (not scaled by size).
       def glyph_width(codepoint)
         cp = codepoint.is_a?(String) ? codepoint.each_codepoint.first : codepoint

data/lib/idml/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: idml
 version: !ruby/object:Gem::Version
-  version: 0.10.6
+  version: 0.10.8
 platform: ruby
 authors:
 - Ribose
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-08-26 00:00:00.000000000 Z
+date: 2026-08-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bigdecimal
@@ -201,7 +201,13 @@ files:
 - TODO.pdf/136-diagonal-cell-strokes.md
 - TODO.pdf/137-simple-render-footnote-text.md
 - TODO.pdf/138-text-wrap-sides.md
+- TODO.pdf/139-hyphen-break-opportunities.md
 - TODO.pdf/14-page-item-element-models.md
+- TODO.pdf/140-cap-xheight-first-baselines.md
+- TODO.pdf/141-perf-hundred-pages.md
+- TODO.pdf/142-vertical-latin-run-groups.md
+- TODO.pdf/143-jump-object-below.md
+- TODO.pdf/144-mojikumi-table-model.md
 - TODO.pdf/15-wire-spread-children.md
 - TODO.pdf/16-typed-model-pipeline.md
 - TODO.pdf/17-shape-rendering.md
@@ -345,6 +351,7 @@ files:
 - lib/idml/elements/master_spread_object.rb
 - lib/idml/elements/mixed_ink.rb
 - lib/idml/elements/mixed_ink_group.rb
+- lib/idml/elements/mojikumi_table.rb
 - lib/idml/elements/object_export_option.rb
 - lib/idml/elements/object_style.rb
 - lib/idml/elements/object_style_content_effects_category_settings.rb