idml 0.10.8 → 0.10.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e05a75aaa533dcd8f478d6b4ab635d15cf6c64ac85bebbd42fe3b136ed0c6783
-  data.tar.gz: 3a478cdb4b23ac26ceb9914d5e3740286ef6fda60c80605a01dc6f2a38086b7a
+  metadata.gz: 69238283188d95396073ce5caacf5662573ccaa6d913e1f76d056b24284449d7
+  data.tar.gz: 20639926a31480df14b3225e04a3eb04f3042bfb105aa9377a63bcb1a0cc5850
 SHA512:
-  metadata.gz: effb89c7a3869aa7c268027e4653ecc2072fc41402d53ff2ad8ca0405862b83076bd82637cc9f64a369cd3ceb2ca23b2e6e9ca7ba300de2fd9f073801c65c199
-  data.tar.gz: 371206ab57061b8fa94733db6e489565eeb0cd588ffb6b0908a9a0c6e84fcec2d64745501dd8ec7b8147cb3044119c47d08f479e50cec26e939a35f5127ecf9e
+  metadata.gz: 474d4266f64894e0fde05e60e2791402854e20b0a4820950e165f8552fb6be7aa644eb7a5303f8f2fa0e86e6dd4df1673d6b53f6ae9a2fac304f36c4fa5cc5e0
+  data.tar.gz: 48ba09b818f5079b981cbed968a49779a69fc38c61e6500c973036f404f6ce1796d7238fea2a0532355b3d5a61130d1d741ac59b77fa823fb4b8e3a4fe0b8f5b

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/148-architecture-improvements.md

@@ -0,0 +1,45 @@
+# TODO PDF 148: Codebase architecture improvements
+
+## Status: COMPLETE — implemented 2026-08-29
+
+## Problem
+
+Architecture audit findings:
+
+1. `TextFrameRenderer` was a 1520-line god class owning four
+   unrelated concerns: the horizontal shaping engine, the vertical
+   writing path, the no-metrics fallback, and everything else
+   (chains, endnotes, footnotes, wrap, keep options).
+2. Twelve render specs each declared their own near-identical
+   `*_FONT_CANDIDATES` list (~7 lines each), with two variants
+   drifting apart (some lists lacked the CJK-capable fonts —
+   CJK-dependent specs silently skipped on platforms that had
+   them).
+
+## Solution
+
+- **VerticalEmit** (`renderers/vertical_emit.rb`, ~230 lines): the
+  whole vertical-writing family (vertical_render through
+  ruby_vertical_x), extracted as a class-methods module
+  `extend`ed into TextFrameRenderer — it shares the host's
+  constants, `layout_frame`, and `font_for_run` (MECE: the module
+  owns everything vertical; the host owns the horizontal engine).
+  Zero behavior change; all vertical/ruby specs pass untouched.
+- **SimpleText** (`renderers/simple_text.rb`, ~90 lines): the
+  no-metrics fallback (simple_render, footnote stacking,
+  collect/build rich runs), same extend pattern.
+- **Spec font candidates DRY'd**: `SPEC_FONT_CANDIDATES` +
+  `spec_font_path` in spec_helper; the twelve per-spec constants
+  deleted. Unifying on the CJK-capable superset un-skipped 20
+  previously-skipped examples on CJK-font platforms.
+
+`TextFrameRenderer` is now 1235 lines of cohesive horizontal
+engine + orchestration.
+
+## Files
+
+- `lib/idml/render/renderers/vertical_emit.rb` (new)
+- `lib/idml/render/renderers/simple_text.rb` (new)
+- `lib/idml/render/renderers/text_frame_renderer.rb`
+- `lib/idml/render.rb`
+- `spec/spec_helper.rb` + 12 render specs

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 (second refresh)
+## 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,18 +25,19 @@ 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 moves text below
-  the object (TODO 143); NextColumn approximates 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 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.
+- **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.
@@ -59,8 +60,7 @@ this list reflects the current state.
 ## Future enhancements
 
 - Hyphenation dictionary integration
-- Shape-mode text wrap contours (side-aware)
-- Apply named mojikumi sets to CJK layout (consume TODO 144's model)
-- NextColumn wrap via column-jump chaining
+- NextColumn wrap via column-jump chaining (multi-column frames)
+- Minimum/Maximum mojikumi aki bounds + CompressionPriority
 - ToBinding / RTL binding alignment
 - Vertical-mode keep options

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

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module Idml
+  module Render
+    module Renderers
+      # The no-metrics fallback path of TextFrameRenderer: when no
+      # FontMetrics is available (no shaper → no wrap), all runs
+      # emit as one `text_rich` block per frame and footnote text
+      # stacks at the frame bottom. Chain threading is best-effort
+      # here — the simple path doesn't wrap, so the first frame's
+      # render typically emits all content and clears the chain
+      # state.
+      #
+      # A class-methods module extended into TextFrameRenderer —
+      # it shares the host's font resolution (MECE: this module
+      # owns the rough path; the host owns the shaping engine).
+      module SimpleText
+        def simple_render(canvas, state, context, box)
+          runs = collect_runs(state)
+          return if runs.empty?
+
+          runs_for = build_rich_runs(runs, context)
+          first_size = runs.first.point_size ||
+            TextFrameRenderer::DEFAULT_SIZE
+          canvas.text_rich(
+            runs_for,
+            at: [box[:x], box[:y] + box[:height] - first_size],
+          )
+          emit_simple_footnotes(canvas, runs, context, box)
+          state.paragraphs = []
+          state.current_paragraph = nil
+          state.runs_remaining = []
+        end
+
+        # Footnote text for the rough (no-metrics) path: one line
+        # per footnote paragraph, stacked upward from the frame's
+        # bottom edge below a hairline separator. Paragraphs are
+        # already marker-prefixed at extraction.
+        def emit_simple_footnotes(canvas, runs, context, box)
+          paragraphs = runs.flat_map(&:footnote_paragraphs).compact
+          return if paragraphs.empty?
+
+          size = paragraphs.first.runs.first&.point_size ||
+            TextFrameRenderer::DEFAULT_SIZE
+          block_top = box[:y] + (paragraphs.length * size)
+          canvas.line_width = 0.5
+          canvas.stroke_color([:gray, 0.0])
+          canvas.move_to(box[:x], block_top + (size * 0.3))
+          canvas.line_to(box[:x] + (box[:width] * 0.25),
+                         block_top + (size * 0.3))
+          canvas.stroke
+
+          paragraphs.reverse_each.with_index do |paragraph, index|
+            canvas.text_rich(
+              build_rich_runs(paragraph.runs, context),
+              at: [box[:x], box[:y] + ((index + 1) * size)],
+            )
+          end
+        end
+
+        def collect_runs(state)
+          runs = state.runs_remaining || []
+          if state.current_paragraph
+            runs + state.current_paragraph.runs
+          else
+            runs + state.paragraphs.flat_map(&:runs)
+          end
+        end
+
+        def build_rich_runs(runs, context)
+          runs.map do |run|
+            {
+              text: run.text,
+              font: font_for_run(run, context),
+              size: run.point_size || TextFrameRenderer::DEFAULT_SIZE,
+            }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -27,6 +27,13 @@ module Idml
         DEFAULT_SIZE = 12.0
         RUBY_SIZE_FACTOR = 0.5
 
+        # Vertical-writing wing (MECE split; shares this class's
+        # constants, layout_frame, and font resolution).
+        extend VerticalEmit
+
+        # No-metrics fallback path (MECE split; rough output).
+        extend SimpleText
+
         def self.render(canvas, context)
           frame = context.item
           return unless frame.parent_story
@@ -221,231 +228,6 @@ module Idml
 
         # True when the story's StoryPreference declares vertical
         # writing (StoryOrientation="Vertical").
-        def self.vertical_story?(story)
-          story.inner&.story_preference&.story_orientation == "Vertical"
-        end
-        private_class_method :vertical_story?
-
-        # Vertical writing path (StoryOrientation="Vertical", CJK):
-        # paragraphs flow as upright glyph columns advancing
-        # right-to-left; each run starts a fresh column (run-mixing
-        # within a column is not modeled). Runs whose columns would
-        # cross the frame's left inset overflow to the next frame in
-        # the chain. Paragraph spacing, rules, and decorations are
-        # not applied in vertical mode.
-        def self.vertical_render(canvas, state, context, box, font)
-          layout_frame = layout_frame(context.item, box)
-          left_limit = layout_frame.x + (layout_frame.inset_left || 0)
-          resume_vertical_paragraph(state)
-          next_column = state.column_offset || 0
-          pending = 0
-
-          state.paragraphs.each do |paragraph|
-            remaining_runs, next_column = vertical_paragraph(
-              canvas, paragraph, context, layout_frame, font,
-              left_limit, next_column
-            )
-            if remaining_runs.empty?
-              pending += 1
-            else
-              state.current_paragraph = paragraph
-              state.runs_remaining = remaining_runs
-              state.column_offset = next_column
-              break
-            end
-          end
-
-          state.paragraphs = state.paragraphs[pending..]
-        end
-        private_class_method :vertical_render
-
-        # Folds a chain-resumed paragraph (runs_remaining) back to
-        # the head of the paragraph list so the vertical path sees a
-        # uniform sequence. The consumed column offset persists in
-        # the state so the next frame continues right where this
-        # frame's columns ended.
-        def self.resume_vertical_paragraph(state)
-          return unless state.current_paragraph
-
-          state.current_paragraph.runs = state.runs_remaining
-          state.paragraphs.unshift(state.current_paragraph)
-          state.current_paragraph = nil
-          state.runs_remaining = []
-        end
-        private_class_method :resume_vertical_paragraph
-
-        # Renders one paragraph's runs as vertical columns starting
-        # at `start_column`. Returns [runs that did not fit (empty
-        # when all placed), the next unused column index].
-        def self.vertical_paragraph(canvas, paragraph, context,
-                                    layout_frame, font, left_limit,
-                                    start_column)
-          next_column = start_column
-          paragraph.runs.each_with_index do |run, index|
-            size = run.point_size || DEFAULT_SIZE
-            leading = TextEngine::VerticalLayout.leading_for(
-              paragraph.auto_leading, size
-            )
-            glyphs = TextEngine::Shaper.shape(text: run.text, font: font,
-                                              size: size)
-            grouped = tatechuyoko_group(run, glyphs, layout_frame,
-                                        leading, size, next_column)
-            positioned, next_column = grouped ||
-              TextEngine::VerticalTextLayout.layout(
-                glyphs: glyphs, frame: layout_frame, leading: leading,
-                size: size, start_column: next_column
-              )
-            unless vertical_fits?(layout_frame, leading, next_column,
-                                  left_limit)
-              return [paragraph.runs[index..], start_column]
-            end
-
-            emit_vertical_run(canvas, positioned, grouped, run, context,
-                              size)
-            emit_vertical_ruby(canvas, run, positioned, layout_frame,
-                               size, context)
-          end
-          [[], next_column]
-        end
-        private_class_method :vertical_paragraph
-
-        # A tate-chu-yoko group for runs that declare it (and whose
-        # glyphs fit horizontally in a column slot); nil otherwise.
-        def self.tatechuyoko_group(run, glyphs, layout_frame, leading,
-                                   size, start_column)
-          return nil unless run.tatechuyoko
-
-          TextEngine::VerticalTextLayout.tatechuyoko_group(
-            glyphs: glyphs, frame: layout_frame, leading: leading,
-            size: size, start_column: start_column
-          )
-        end
-        private_class_method :tatechuyoko_group
-
-        # Emits a vertical run's glyphs: rotated/normal vertical
-        # handling for stacked columns, plain upright emission for
-        # tate-chu-yoko groups.
-        def self.emit_vertical_run(canvas, positioned, grouped, run,
-                                   context, size)
-          if grouped
-            positioned.each do |glyph|
-              emit_upright_glyph(canvas, glyph, run, context, size)
-            end
-          else
-            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")
-          text_kwargs = CharacterStyle.text_kwargs(
-            run,
-            {
-              at: [positioned.x, positioned.y],
-              font: font_for_run(run, context),
-              size: size,
-            },
-          )
-          canvas.text(text, **text_kwargs)
-        end
-        private_class_method :emit_upright_glyph
-
-        def self.vertical_fits?(layout_frame, leading, columns, left_limit)
-          right = layout_frame.x + layout_frame.width -
-            (layout_frame.inset_right || 0)
-          (right - (columns * leading)) >= left_limit
-        end
-        private_class_method :vertical_fits?
-
-        # 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
-        # horizontal above/below convention mirrored under
-        # rotation).
-        def self.emit_vertical_ruby(canvas, run, positioned, frame,
-                                    base_size, context)
-          ruby_text = run.ruby_string
-          return if ruby_text.nil? || ruby_text.empty?
-
-          ruby_size = run.ruby_font_size ||
-            (base_size * RUBY_SIZE_FACTOR)
-          x = ruby_vertical_x(positioned.first, run, base_size)
-          y = frame.y + frame.height - (frame.inset_top || 0)
-          ruby_text.each_codepoint do |codepoint|
-            text_kwargs = CharacterStyle.text_kwargs(
-              run,
-              {
-                at: [x, y - ruby_size],
-                font: font_for_run(run, context),
-                size: ruby_size,
-              },
-            )
-            canvas.text([codepoint].pack("U"), **text_kwargs)
-            y -= ruby_size
-          end
-        end
-        private_class_method :emit_vertical_ruby
-
-        def self.ruby_vertical_x(positioned, run, base_size)
-          offset = base_size * 0.9
-          if run.ruby_position.to_s.include?("Below")
-            positioned.x - offset
-          else
-            positioned.x + offset
-          end
-        end
-        private_class_method :ruby_vertical_x
 
         def self.chain_head?(frame)
           frame.previous_text_frame.nil? || frame.previous_text_frame == "n"
@@ -1145,6 +927,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,
           )
@@ -1169,6 +954,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
@@ -1430,74 +1228,6 @@ module Idml
           line.glyphs.map { |g| [g.codepoint].pack("U") }.join
         end
         private_class_method :line_text
-
-        # Fallback when no metrics are available: emit all runs as
-        # one `text_rich` block, letting pdfrb measure advance widths.
-        # Chain threading is best-effort here — the simple path
-        # doesn't wrap, so the first frame's render typically emits
-        # all content and clears the chain state.
-        def self.simple_render(canvas, state, context, box)
-          runs = collect_runs(state)
-          return if runs.empty?
-
-          runs_for = build_rich_runs(runs, context)
-          first_size = runs.first.point_size || DEFAULT_SIZE
-          canvas.text_rich(
-            runs_for,
-            at: [box[:x], box[:y] + box[:height] - first_size],
-          )
-          emit_simple_footnotes(canvas, runs, context, box)
-          state.paragraphs = []
-          state.current_paragraph = nil
-          state.runs_remaining = []
-        end
-        private_class_method :simple_render
-
-        # Footnote text for the rough (no-metrics) path: one line
-        # per footnote paragraph, stacked upward from the frame's
-        # bottom edge below a hairline separator. Paragraphs are
-        # already marker-prefixed at extraction.
-        def self.emit_simple_footnotes(canvas, runs, context, box)
-          paragraphs = runs.flat_map(&:footnote_paragraphs).compact
-          return if paragraphs.empty?
-
-          size = paragraphs.first.runs.first&.point_size || DEFAULT_SIZE
-          block_top = box[:y] + (paragraphs.length * size)
-          canvas.line_width = 0.5
-          canvas.stroke_color([:gray, 0.0])
-          canvas.move_to(box[:x], block_top + (size * 0.3))
-          canvas.line_to(box[:x] + (box[:width] * 0.25), block_top + (size * 0.3))
-          canvas.stroke
-
-          paragraphs.reverse_each.with_index do |paragraph, index|
-            canvas.text_rich(
-              build_rich_runs(paragraph.runs, context),
-              at: [box[:x], box[:y] + ((index + 1) * size)],
-            )
-          end
-        end
-        private_class_method :emit_simple_footnotes
-
-        def self.collect_runs(state)
-          runs = state.runs_remaining || []
-          if state.current_paragraph
-            runs + state.current_paragraph.runs
-          else
-            runs + state.paragraphs.flat_map(&:runs)
-          end
-        end
-        private_class_method :collect_runs
-
-        def self.build_rich_runs(runs, context)
-          runs.map do |run|
-            {
-              text: run.text,
-              font: font_for_run(run, context),
-              size: run.point_size || DEFAULT_SIZE,
-            }
-          end
-        end
-        private_class_method :build_rich_runs
       end
     end
   end

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

@@ -0,0 +1,228 @@
+# frozen_string_literal: true
+
+module Idml
+  module Render
+    module Renderers
+      # Vertical writing path (StoryOrientation="Vertical", CJK):
+      # paragraphs flow as upright glyph columns advancing
+      # right-to-left; each run starts a fresh column (run-mixing
+      # within a column is not modeled). Runs whose columns would
+      # cross the frame's left inset overflow to the next frame in
+      # the chain. Paragraph spacing, rules, and decorations are
+      # not applied in vertical mode.
+      #
+      # A class-methods module extended into TextFrameRenderer —
+      # it shares the host's constants, font resolution, and
+      # layout_frame helper (MECE: this module owns everything
+      # vertical; the host owns the horizontal engine).
+      module VerticalEmit
+        def vertical_story?(story)
+          story.inner&.story_preference&.story_orientation == "Vertical"
+        end
+
+        def vertical_render(canvas, state, context, box, font)
+          layout_frame = layout_frame(context.item, box)
+          left_limit = layout_frame.x + (layout_frame.inset_left || 0)
+          resume_vertical_paragraph(state)
+          next_column = state.column_offset || 0
+          pending = 0
+
+          state.paragraphs.each do |paragraph|
+            remaining_runs, next_column = vertical_paragraph(
+              canvas, paragraph, context, layout_frame, font,
+              left_limit, next_column
+            )
+            if remaining_runs.empty?
+              pending += 1
+            else
+              state.current_paragraph = paragraph
+              state.runs_remaining = remaining_runs
+              state.column_offset = next_column
+              break
+            end
+          end
+
+          state.paragraphs = state.paragraphs[pending..]
+        end
+
+        # Folds a chain-resumed paragraph (runs_remaining) back to
+        # the head of the paragraph list so the vertical path sees a
+        # uniform sequence. The consumed column offset persists in
+        # the state so the next frame continues right where this
+        # frame's columns ended.
+        def resume_vertical_paragraph(state)
+          return unless state.current_paragraph
+
+          state.current_paragraph.runs = state.runs_remaining
+          state.paragraphs.unshift(state.current_paragraph)
+          state.current_paragraph = nil
+          state.runs_remaining = []
+        end
+
+        # Renders one paragraph's runs as vertical columns starting
+        # at `start_column`. Returns [runs that did not fit (empty
+        # when all placed), the next unused column index].
+        def vertical_paragraph(canvas, paragraph, context,
+                               layout_frame, font, left_limit,
+                               start_column)
+          next_column = start_column
+          paragraph.runs.each_with_index do |run, index|
+            size = run.point_size || TextFrameRenderer::DEFAULT_SIZE
+            leading = TextEngine::VerticalLayout.leading_for(
+              paragraph.auto_leading, size
+            )
+            glyphs = TextEngine::Shaper.shape(text: run.text, font: font,
+                                              size: size)
+            grouped = tatechuyoko_group(run, glyphs, layout_frame,
+                                        leading, size, next_column)
+            positioned, next_column = grouped ||
+              TextEngine::VerticalTextLayout.layout(
+                glyphs: glyphs, frame: layout_frame, leading: leading,
+                size: size, start_column: next_column
+              )
+            unless vertical_fits?(layout_frame, leading, next_column,
+                                  left_limit)
+              return [paragraph.runs[index..], start_column]
+            end
+
+            emit_vertical_run(canvas, positioned, grouped, run, context,
+                              size)
+            emit_vertical_ruby(canvas, run, positioned, layout_frame,
+                               size, context)
+          end
+          [[], next_column]
+        end
+
+        # A tate-chu-yoko group for runs that declare it (and whose
+        # glyphs fit horizontally in a column slot); nil otherwise.
+        def tatechuyoko_group(run, glyphs, layout_frame, leading,
+                              size, start_column)
+          return nil unless run.tatechuyoko
+
+          TextEngine::VerticalTextLayout.tatechuyoko_group(
+            glyphs: glyphs, frame: layout_frame, leading: leading,
+            size: size, start_column: start_column
+          )
+        end
+
+        # Emits a vertical run's glyphs: rotated/normal vertical
+        # handling for stacked columns, plain upright emission for
+        # tate-chu-yoko groups.
+        def emit_vertical_run(canvas, positioned, grouped, run,
+                              context, size)
+          if grouped
+            positioned.each do |glyph|
+              emit_upright_glyph(canvas, glyph, run, context, size)
+            end
+          else
+            emit_vertical_stack(canvas, positioned, run, context, size)
+          end
+        end
+
+        # 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 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
+
+        def 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
+
+        def emit_upright_glyph(canvas, positioned, run, context,
+                               size)
+          text = [positioned.codepoint].pack("U")
+          text_kwargs = CharacterStyle.text_kwargs(
+            run,
+            {
+              at: [positioned.x, positioned.y],
+              font: font_for_run(run, context),
+              size: size,
+            },
+          )
+          canvas.text(text, **text_kwargs)
+        end
+
+        def vertical_fits?(layout_frame, leading, columns, left_limit)
+          right = layout_frame.x + layout_frame.width -
+            (layout_frame.inset_right || 0)
+          (right - (columns * leading)) >= left_limit
+        end
+
+        # 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
+        # horizontal above/below convention mirrored under
+        # rotation).
+        def emit_vertical_ruby(canvas, run, positioned, frame,
+                               base_size, context)
+          ruby_text = run.ruby_string
+          return if ruby_text.nil? || ruby_text.empty?
+
+          ruby_size = run.ruby_font_size ||
+            (base_size * TextFrameRenderer::RUBY_SIZE_FACTOR)
+          x = ruby_vertical_x(positioned.first, run, base_size)
+          y = frame.y + frame.height - (frame.inset_top || 0)
+          ruby_text.each_codepoint do |codepoint|
+            text_kwargs = CharacterStyle.text_kwargs(
+              run,
+              {
+                at: [x, y - ruby_size],
+                font: font_for_run(run, context),
+                size: ruby_size,
+              },
+            )
+            canvas.text([codepoint].pack("U"), **text_kwargs)
+            y -= ruby_size
+          end
+        end
+
+        def ruby_vertical_x(positioned, run, base_size)
+          offset = base_size * 0.9
+          if run.ruby_position.to_s.include?("Below")
+            positioned.x - offset
+          else
+            positioned.x + offset
+          end
+        end
+      end
+    end
+  end
+end

data/lib/idml/render/text_wrap_resolver.rb

@@ -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,12 +99,14 @@ 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.
+        # 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
 
-        side_adjustment(contour, overlap, frame_x, frame_right)
+        interval_side_adjustment(contour.side, contour.x,
+                                 contour.x + contour.width, overlap,
+                                 frame_x, frame_right)
       end
       private :box_adjustment
 
@@ -114,30 +129,35 @@ module Idml
       end
       private :box_contour?
 
-      def side_adjustment(contour, overlap, frame_x, frame_right)
-        case contour.side
+      # 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.
@@ -164,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
@@ -190,7 +211,7 @@ module Idml
           x: rect[:x], y: rect[:y],
           width: rect[:width], height: rect[:height],
           side: pref&.text_wrap_side,
-          jump: pref&.text_wrap_mode == "JumpObjectTextWrap"
+          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/render.rb

@@ -92,3 +92,11 @@ Idml::Render::Renderers.autoload(
   :TableRenderer,
   "#{__dir__}/render/renderers/table_renderer",
 )
+Idml::Render::Renderers.autoload(
+  :VerticalEmit,
+  "#{__dir__}/render/renderers/vertical_emit",
+)
+Idml::Render::Renderers.autoload(
+  :SimpleText,
+  "#{__dir__}/render/renderers/simple_text",
+)

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.8"
+  VERSION = "0.10.10"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: idml
 version: !ruby/object:Gem::Version
-  version: 0.10.8
+  version: 0.10.10
 platform: ruby
 authors:
 - Ribose
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-08-27 00:00:00.000000000 Z
+date: 2026-08-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bigdecimal
@@ -208,6 +208,10 @@ files:
 - 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/148-architecture-improvements.md
 - TODO.pdf/15-wire-spread-children.md
 - TODO.pdf/16-typed-model-pipeline.md
 - TODO.pdf/17-shape-rendering.md
@@ -504,8 +508,10 @@ files:
 - lib/idml/render/renderers/path_renderer.rb
 - lib/idml/render/renderers/polygon_renderer.rb
 - lib/idml/render/renderers/rectangle_renderer.rb
+- lib/idml/render/renderers/simple_text.rb
 - lib/idml/render/renderers/table_renderer.rb
 - lib/idml/render/renderers/text_frame_renderer.rb
+- lib/idml/render/renderers/vertical_emit.rb
 - lib/idml/render/shape_paint.rb
 - lib/idml/render/spread_renderer.rb
 - lib/idml/render/story_chain_controller.rb