idml 0.10.7 → 0.10.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 943028d5bf17ca306e3cce0d23c4b042ddaa9473295f2fa7f4af43009a7423a0
-  data.tar.gz: b9c3c1e5421ffa4de44396dbc94124434dda470c3f10fabd5ddd81146c3991c1
+  metadata.gz: c3ebdf83496770ecda7b37cc6f6cdc2388874785ccad23ac57aa396f76aef03b
+  data.tar.gz: d7304a209e09d4de3ee6d9f7556d18053f838ee3fef9a4f787f06693aa42ee32
 SHA512:
-  metadata.gz: 86717ea81b1ede4576d3d41e7026cd2731ec40024ea887d33a03c4ff7771384cb0ae9fd04f5948a322d48986dae2946adcebf167a7c51ae3ce7890a28726e7ee
-  data.tar.gz: 12a2089f4600a04fe5cd1d74e409c0933dc6f691156ffca4eeb87fcb25fd5d89e2a1ec58261c8a087ea00b93cf42abee0bb54d64f72032dc3b6bbe919f6cc6b4
+  metadata.gz: bd4dc75a85966131506edf7f3e01df91127fbf26525bb02edcf783f0c07580380be0d8bd38562c11a477602731e2efff8de78061580b471f1389f3bb87a07119
+  data.tar.gz: 74286965e709455a356789cc6f7e4c93f75d414a1132301ee8e347a85d114065bd1988921c180a522c646824d79f2049bdfacf7db609e9981b270d3a88b71fbb

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/145-apply-mojikumi-aki.md

@@ -0,0 +1,37 @@
+# TODO PDF 145: Apply mojikumi aki to layout
+
+## Status: COMPLETE — implemented 2026-08-28
+
+## Problem
+
+Two gaps: (a) `apply_script_spacing` (TODO 125) was implemented
+but never wired into the render pipeline — CJK/Latin auto spacing
+never actually applied; (b) the named mojikumi sets modeled in
+TODO 144 were parsed but unused.
+
+## Solution
+
+- `CjkLayout.apply_script_spacing` now takes the document's aki
+  overrides: when the designmap declares a `MojikumiTable`, each
+  adjacent glyph pair whose classes match an
+  `OverrideMojikumiAki` entry (Target/Side class ×
+  SideIsAfterTarget) gets that entry's Desired spacing (em ×
+  point size). Unlisted pairs keep the default eighth-em at
+  CJK/Latin script boundaries.
+- New `CjkLayout.mojikumi_class` classifies the seven InDesign
+  mojikumi classes (ideograph, opening bracket, closing bracket,
+  comma/period, middle dot, digit — incl. fullwidth, Latin —
+  incl. fullwidth).
+- `TextFrameRenderer#layout_run` applies the spacing between
+  shaping and line breaking, using
+  `mojikumi_aki_overrides(context)` (first named set from the
+  designmap; empty when absent).
+
+The result: documents declaring custom mojikumi now render their
+declared inter-class spacing.
+
+## Files
+
+- `lib/idml/text_engine/cjk_layout.rb`
+- `lib/idml/render/renderers/text_frame_renderer.rb`
+- `spec/idml/text_engine/cjk_layout_spec.rb`

data/TODO.pdf/146-next-column-wrap.md

@@ -0,0 +1,25 @@
+# TODO PDF 146: NextColumn wrap behavior
+
+## Status: COMPLETE (approximation) — implemented 2026-08-28
+
+## Problem
+
+NextColumnTextWrap approximated as the bounding box (text narrowed
+beside the object). InDesign moves the text to the next COLUMN.
+
+## Solution
+
+NextColumnTextWrap now joins JumpObjectTextWrap in the jump path:
+the object blocks the full frame width and the run skips below
+the object's bottom edge. In a single-column frame this matches
+InDesign's visible outcome (the "next column" is below).
+
+Remaining approximation (documented in TODO.pdf/61): in a
+MULTI-column frame, true NextColumn jumps to the next column in
+the same frame — that needs column-jump chain integration, which
+stays a future enhancement.
+
+## Files
+
+- `lib/idml/render/text_wrap_resolver.rb`
+- `spec/idml/render/text_wrap_resolver_spec.rb`

data/TODO.pdf/147-side-aware-shapes.md

@@ -0,0 +1,27 @@
+# TODO PDF 147: Side-aware Contour shapes
+
+## Status: COMPLETE — implemented 2026-08-28
+
+## Problem
+
+TextWrapSide applied only to BoundingBoxTextWrap contours;
+Contour-mode shapes narrowed by polygon overlap regardless of
+side — text smeared over shapes at frame edges instead of
+flowing around the chosen side.
+
+## Solution
+
+`WrapContour::Shape` carries `side`; `wrap_adjustment`'s shape
+branch dispatches through the shared interval-based side logic
+using the polygon's bounding box: LeftSide keeps text left of the
+shape, RightSide shifts lines past its right edge, LargestArea
+picks the roomier side; BothSides (and spine variants) keep the
+exact polygon-overlap narrowing. Inverse shapes keep their
+flip-to-inside semantics. The side dispatch is now one shared
+`interval_side_adjustment` for boxes and shapes alike.
+
+## Files
+
+- `lib/idml/render/wrap_contour.rb`
+- `lib/idml/render/text_wrap_resolver.rb`
+- `spec/idml/render/text_wrap_resolver_spec.rb`

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

@@ -1,6 +1,6 @@
 # TODO PDF 61: Known limitations and future work
 
-## Status: DOCUMENTED — refreshed 2026-08-27
+## Status: DOCUMENTED — refreshed 2026-08-28
 
 Previously listed limitations (font embedding, tagged PDF, per-run
 styling, dead code) were resolved by TODOs 52/53/55/67/76 long ago;
@@ -25,17 +25,22 @@ this list reflects the current state.
 - **StartParagraph** breaks act at frame/column granularity — no
   odd/even page parity.
 - **Text wrap**: BoundingBoxTextWrap, Contour, and Inverse modes
-  render (TODOs 130-131) 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.
+  render (TODOs 130-131) with TextWrapSide side-awareness for both
+  box contours and Contour shapes (TODOs 138/147); JumpObject and
+  NextColumn move text below the object (TODOs 143/146) — NextColumn
+  in a MULTI-column frame should jump to the next column instead
+  (chain integration, future); spine variants approximate as
+  BothSides.
 
 ### 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.
+- **Mojikumi**: script spacing (TODO 125, now actually wired),
+  line-end compression (TODO 132), class-based pair compression,
+  and named-set aki overrides (TODO 145: OverrideMojikumiAki
+  Desired applies per class pair) are applied; Minimum/Maximum
+  aki bounds and CompressionPriority are parsed but unused.
+- **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
@@ -55,7 +60,7 @@ this list reflects the current state.
 ## Future enhancements
 
 - Hyphenation dictionary integration
-- Shape-mode text wrap contours (side-aware)
-- Named mojikumi sets (詳細 etc.)
+- NextColumn wrap via column-jump chaining (multi-column frames)
+- Minimum/Maximum mojikumi aki bounds + CompressionPriority
 - ToBinding / RTL binding alignment
-- Vertical-mode keep options and run-grouped Latin rotation
+- 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
@@ -881,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,
@@ -946,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
@@ -1095,6 +1145,9 @@ module Idml
           glyphs = TextEngine::Shaper.shape(
             text: run.text, font: font, size: size,
           )
+          glyphs = TextEngine::CjkLayout.apply_script_spacing(
+            glyphs, size, mojikumi_aki_overrides(context)
+          )
           lines = TextEngine::LineBreaker.break(
             glyphs: glyphs, frame_width: wrap_width,
           )
@@ -1119,6 +1172,19 @@ module Idml
         end
         private_class_method :layout_run
 
+        # Aki overrides from the document's first named mojikumi
+        # set, when the designmap declares one (TODO 145). Empty
+        # otherwise — apply_script_spacing then uses the default
+        # CJK/Latin script spacing.
+        def self.mojikumi_aki_overrides(context)
+          package = context.package
+          return [] unless package&.has_part?("designmap.xml")
+
+          table = package.designmap.mojikumi_table.first
+          table&.aki_overrides || []
+        end
+        private_class_method :mojikumi_aki_overrides
+
         # True when the paragraph should move wholly to the next
         # frame: a StartParagraph forced break, or KeepAllLines-
         # Together with insufficient remaining space (never for the

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
       )
 
@@ -63,10 +63,23 @@ module Idml
           width = WrapContour.overlap_width(contour, line_y,
                                             line_height, frame_x,
                                             frame_right)
-          next unless contour.inverse
+          if contour.inverse
+            reduction = [reduction,
+                         (frame_right - frame_x) - width].max
+            next
+          end
 
-          reduction = [reduction,
-                       (frame_right - frame_x) - width].max
+          # Side-aware shapes (TODO 147): the side dispatch uses
+          # the polygon's bounding box; narrowing itself keeps the
+          # exact polygon overlap for BothSides.
+          bbox_left, _bottom, bbox_right, = WrapContour.bounding_box(
+            contour,
+          )
+          r, s = interval_side_adjustment(contour.side, bbox_left,
+                                          bbox_right, width,
+                                          frame_x, frame_right)
+          reduction = [reduction, r].max
+          shift = [shift, s].max
         end
         [reduction, shift]
       end
@@ -86,34 +99,65 @@ module Idml
 
         return [0.0, 0.0] if overlap.zero?
 
-        side_adjustment(contour, overlap, frame_x, frame_right)
+        # JumpObject / NextColumn: 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
+
+        interval_side_adjustment(contour.side, contour.x,
+                                 contour.x + contour.width, overlap,
+                                 frame_x, frame_right)
       end
       private :box_adjustment
 
-      def side_adjustment(contour, overlap, frame_x, frame_right)
-        case contour.side
+      # 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?
+
+      # Side dispatch over an object's horizontal extent
+      # [obj_left, obj_right] (TODO 138/147 — shared by box
+      # contours and Contour shapes' bounding boxes): LeftSide
+      # keeps text left of the object (reduce to its left edge, no
+      # shift); RightSide moves text past its right edge (reduce +
+      # shift); LargestArea picks the roomier side; BothSides and
+      # the spine variants reduce by `overlap` only.
+      def interval_side_adjustment(side, obj_left, obj_right, overlap,
+                                   frame_x, frame_right)
+        case side
         when "LeftSide"
-          [frame_right - contour.x, 0.0]
+          [frame_right - obj_left, 0.0]
         when "RightSide"
-          shift = contour.x + contour.width - frame_x
+          shift = obj_right - frame_x
           [shift, shift]
         when "LargestArea"
-          largest_side_adjustment(contour, frame_x, frame_right)
+          left_free = obj_left - frame_x
+          right_free = frame_right - obj_right
+          if left_free >= right_free
+            [frame_right - obj_left, 0.0]
+          else
+            shift = obj_right - frame_x
+            [shift, shift]
+          end
         else
           [overlap, 0.0]
         end
       end
-      private :side_adjustment
-
-      def largest_side_adjustment(contour, frame_x, frame_right)
-        left_free = contour.x - frame_x
-        right_free = frame_right - (contour.x + contour.width)
-        return [frame_right - contour.x, 0.0] if left_free >= right_free
-
-        shift = contour.x + contour.width - frame_x
-        [shift, shift]
-      end
-      private :largest_side_adjustment
+      private :interval_side_adjustment
 
       # Returns the total horizontal overlap of all contours with a
       # text line at the given y range within the given x range.
@@ -140,10 +184,11 @@ module Idml
       # The wrap shape for an item: a bounding-box rectangle
       # (BoundingBoxTextWrap — the legacy "BoundingBox" spelling is
       # also accepted from early synthetic fixtures) or a flattened
-      # PathGeometry polygon (Contour mode). JumpObject /
-      # NextColumn modes approximate as the bounding box (the
-      # per-run width reduction already pushes text past the
-      # object).
+      # PathGeometry polygon (Contour mode). JumpObject moves text
+      # below the object; NextColumn approximates as the same
+      # jump-below in a single-column frame (true column jumping
+      # needs chain integration, documented in TODO.pdf/61).
+      JUMP_MODES = %w[JumpObjectTextWrap NextColumnTextWrap].freeze
       def self.contour_for(item, page_height)
         pref = wrap_preference(item)
         return nil unless pref
@@ -165,7 +210,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: JUMP_MODES.include?(pref&.text_wrap_mode)
         )
       end
       private_class_method :box_contour

data/lib/idml/render/wrap_contour.rb

@@ -13,8 +13,9 @@ module Idml
 
       # A wrap shape: flattened polygons (one per subpath) plus the
       # TextWrapOffset bounds. `inverse` flips the wrap region:
-      # text may only flow INSIDE the shape.
-      Shape = Struct.new(:polygons, :offset, :inverse,
+      # text may only flow INSIDE the shape. `side` carries
+      # TextWrapSide for side-aware narrowing (TODO 147).
+      Shape = Struct.new(:polygons, :offset, :inverse, :side,
                          keyword_init: true)
 
       # Builds the wrap shape for an item's PathGeometry and wrap
@@ -24,7 +25,16 @@ module Idml
         return nil if polygons.empty?
 
         Shape.new(polygons: polygons, offset: wrap_offset(pref),
-                  inverse: pref.inverse)
+                  inverse: pref.inverse, side: pref.text_wrap_side)
+      end
+
+      # The shape's bounding box: [left, bottom, right, top] in
+      # PDF coordinates, flattened across subpaths.
+      def self.bounding_box(shape)
+        points = shape.polygons.flatten(1)
+        xs = points.map(&:first)
+        ys = points.map(&:last)
+        [xs.min, ys.min, xs.max, ys.max]
       end
 
       def self.polygons_for(item, page_height)

data/lib/idml/text_engine/cjk_layout.rb

@@ -10,22 +10,95 @@ module Idml
       # Mojikumi subset: automatic inter-script spacing — an eighth
       # em is inserted between adjacent CJK and ASCII alphanumeric
       # glyphs (widenning the leading glyph of each pair), matching
-      # InDesign's default CJK/Latin auto spacing.
+      # InDesign's default CJK/Latin auto spacing. A named
+      # mojikumi set's OverrideMojikumiAki entries take precedence
+      # when given: the Desired value (em units) applies to each
+      # matching class pair (TODO 145).
       SCRIPT_SPACING_EM = 0.125
 
-      def apply_script_spacing(glyphs, size)
-        spacing = size * SCRIPT_SPACING_EM
+      # Mojikumi character classes (InDesign mojikumi table rows).
+      CLASS_IDEOGRAPH = 1
+      CLASS_OPENING = 2
+      CLASS_CLOSING = 3
+      CLASS_COMMA_PERIOD = 4
+      CLASS_MIDDLE_DOT = 5
+      CLASS_DIGIT = 6
+      CLASS_LATIN = 7
+
+      COMMA_PERIOD_CODEPOINTS = [
+        0x3001, # 、 ideographic comma
+        0x3002, # 。 ideographic full stop
+      ].freeze
+
+      CLOSING_CODEPOINTS = [
+        0x3009, # 〉
+        0x300B, # 》
+        0x300D, # 」
+        0x300F, # 』
+        0x3011, # 】
+        0x3015, # 〕
+        0xFF09, # ）fullwidth right paren
+        0xFF3D, # ］
+        0xFF5D, # ｝
+      ].freeze
+
+      def apply_script_spacing(glyphs, size, aki_overrides = [])
         (0...(glyphs.length - 1)).each do |index|
           leading = glyphs[index]
           following = glyphs[index + 1]
-          next unless script_boundary?(leading.codepoint,
-                                       following.codepoint)
+          em = aki_em(leading.codepoint, following.codepoint,
+                      aki_overrides)
+          next unless em&.positive?
 
-          leading.width += spacing
+          leading.width += em * size
         end
         glyphs
       end
 
+      # Spacing (em units) between an adjacent pair: the named
+      # set's Desired aki for a matching class-pair override, else
+      # the default eighth-em at CJK/Latin script boundaries, else
+      # none.
+      def aki_em(left, right, aki_overrides)
+        override = aki_overrides.find do |entry|
+          entry.side_is_after_target &&
+            entry.target_mojikumi_class == mojikumi_class(left) &&
+            entry.side_mojikumi_class == mojikumi_class(right)
+        end
+        return override.desired if override&.desired
+
+        return SCRIPT_SPACING_EM if script_boundary?(left, right)
+
+        nil
+      end
+
+      # The mojikumi class of a codepoint, or nil outside the
+      # CJK punctuation / script classes. Ideographs (the default
+      # CJK class) win only when no special class matches.
+      def mojikumi_class(codepoint)
+        return CLASS_OPENING if OPENING_CODEPOINTS.include?(codepoint)
+        return CLASS_COMMA_PERIOD if COMMA_PERIOD_CODEPOINTS.include?(codepoint)
+        return CLASS_CLOSING if CLOSING_CODEPOINTS.include?(codepoint)
+        return CLASS_MIDDLE_DOT if MIDDLE_CODEPOINTS.include?(codepoint)
+        return CLASS_DIGIT if digit_class?(codepoint)
+        return CLASS_LATIN if latin_class?(codepoint)
+        return CLASS_IDEOGRAPH if cjk?(codepoint)
+
+        nil
+      end
+
+      def digit_class?(codepoint)
+        (0x30..0x39).cover?(codepoint) ||
+          (0xFF10..0xFF19).cover?(codepoint)
+      end
+
+      def latin_class?(codepoint)
+        (0x41..0x5A).cover?(codepoint) ||
+          (0x61..0x7A).cover?(codepoint) ||
+          (0xFF21..0xFF3A).cover?(codepoint) ||
+          (0xFF41..0xFF5A).cover?(codepoint)
+      end
+
       # True when exactly one of the pair is CJK and the other is
       # an ASCII letter or digit.
       def script_boundary?(left, right)

data/lib/idml/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: idml
 version: !ruby/object:Gem::Version
-  version: 0.10.7
+  version: 0.10.9
 platform: ruby
 authors:
 - Ribose
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-08-27 00:00:00.000000000 Z
+date: 2026-08-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bigdecimal
@@ -205,6 +205,12 @@ files:
 - 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/145-apply-mojikumi-aki.md
+- TODO.pdf/146-next-column-wrap.md
+- TODO.pdf/147-side-aware-shapes.md
 - TODO.pdf/15-wire-spread-children.md
 - TODO.pdf/16-typed-model-pipeline.md
 - TODO.pdf/17-shape-rendering.md
@@ -348,6 +354,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