ctrl-kd 4.7.0__tar.gz → 4.8.0__tar.gz

{ctrl_kd-4.7.0/src/ctrl_kd.egg-info → ctrl_kd-4.8.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ctrl-kd
-Version: 4.7.0
+Version: 4.8.0
 Summary: Convert WordStar 4-7 documents and print-to-disk files to text, Markdown, HTML, RTF, or PDF. ^KD: save and done.
 Author: Jon Michaels
 License: MIT

{ctrl_kd-4.7.0 → ctrl_kd-4.8.0/src/ctrl_kd.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ctrl-kd
-Version: 4.7.0
+Version: 4.8.0
 Summary: Convert WordStar 4-7 documents and print-to-disk files to text, Markdown, HTML, RTF, or PDF. ^KD: save and done.
 Author: Jon Michaels
 License: MIT

{ctrl_kd-4.7.0 → ctrl_kd-4.8.0}/src/ctrl_kd.egg-info/SOURCES.txt

@@ -38,6 +38,7 @@ tests/test_form_feed_line_marks.py
 tests/test_glyph_aspect.py
 tests/test_graphic_cell_ops.py
 tests/test_graphic_cells.py
+tests/test_head_foot_placement_m16.py
 tests/test_head_foot_timing.py
 tests/test_html_print_stylesheet.py
 tests/test_justification.py
@@ -57,10 +58,13 @@ tests/test_merge_page_number_variable.py
 tests/test_modern_blank_after_tightened_line.py
 tests/test_modern_box_regions.py
 tests/test_modern_centring_clip.py
+tests/test_modern_columns.py
 tests/test_modern_line_spacing.py
 tests/test_modern_lint.py
 tests/test_modern_page_baseline.py
+tests/test_modern_page_number.py
 tests/test_modern_rtf_structure_rows.py
+tests/test_modern_sheet_height.py
 tests/test_modern_verse_defrow.py
 tests/test_note_rulings_20260824.py
 tests/test_page_parity.py

{ctrl_kd-4.7.0 → ctrl_kd-4.8.0}/src/ctrlkd/__init__.py

@@ -8,4 +8,4 @@ from .pdf import emit_pdf                        # registers the 'pdf' format
 from .convert import convert, select_notes, DEFAULT_NOTE_KINDS, ALL_NOTE_KINDS
 from .info import document_info
 
-__version__ = '4.7.0'
+__version__ = '4.8.0'

{ctrl_kd-4.7.0 → ctrl_kd-4.8.0}/src/ctrlkd/cli.py

@@ -130,15 +130,17 @@ def main(argv=None):
                     help='omit paragraph-style pass-through (HTML classes + '
                          'generated CSS, RTF stylesheet) from the output')
     ap.add_argument('--headers', choices=('on', 'off'), default='on',
-                    help='headers, footers, and page numbers in the paged '
-                         'surfaces (Printed/Native PDF and RTF). Default: on')
+                    help="the document's own running heads and feet (.he/.fo) "
+                         'in the paged surfaces -- Printed PDF, Modern PDF and '
+                         "both RTF modes. WordStar's own automatic page number "
+                         'is --page-numbers\' business alone. Default: on')
     ap.add_argument('--page-numbers', choices=('auto', 'on', 'off'),
                     default='auto',
                     help="WordStar's own AUTOMATIC page number -- the one "
                          '.pc positions, a separate mechanism from a # the '
-                         'author placed inside a real .he/.fo (that always '
-                         'prints, unaffected by this flag). Printed PDF '
-                         'and both RTF modes. auto (DEFAULT): the '
+                         'author placed inside a real .he/.fo (that goes '
+                         'with its head, under --headers, never this flag). '
+                         'Every paged surface. auto (DEFAULT): the '
                          'document\'s own dot '
                          'commands decide -- .pn/.pg turn it on, .op turns '
                          'it off, exactly like real WordStar; a document '
@@ -149,8 +151,9 @@ def main(argv=None):
                          'silent document. off: suppress it unconditionally. '
                          'A declared footer always pre-empts it, in every '
                          'mode (WSFORMAT.WS: "active only when the footers '
-                         'are not in use"). --headers off also suppresses '
-                         'it, per --headers\' own documented scope.')
+                         'are not in use") -- a property of the document, so '
+                         '--headers off does not lift it, and does not '
+                         'suppress the number either.')
     ap.add_argument('--line-numbers', choices=('on', 'off'), default='on',
                     help="the document's own .l# line-number gutter in the "
                          'paged surfaces (Printed/Native PDF and RTF); no '

{ctrl_kd-4.7.0 → ctrl_kd-4.8.0}/src/ctrlkd/core.py

@@ -1427,6 +1427,46 @@ class Document:
     # can `|` it into a run's own styles unconditionally.
     header_style_attrs: dict = field(default_factory=dict)
     footer_style_attrs: dict = field(default_factory=dict)
+    # M16 (2026-09-15, WS7 probes B0-B5 against sawyer/REF/BOOKLET.WS): the
+    # RIGHT MARGIN the head/foot line's own style declares, in print
+    # columns at 10 CPI (`right_margin_hmi / 180`), or absent when the
+    # style declares none. `{line: cols}`.
+    #
+    # A right- or centre-aligned running head aligns against THIS, measured
+    # from `.po` -- not against the document's `.rm`, not against the
+    # column grid, and not against the sheet. Measured, five probes printed
+    # by real WS7 under DOSBox-X: turning `.co 2` off (B2) and changing it
+    # to `.co 3` with a `.rm` of 2.50" instead of 4.50" (B3) both leave
+    # BOOKLET.WS's "Header Odd 1" at exactly the x the unmodified document
+    # prints it at, while moving `.po` from 0.2in to 1.2in (B4) moves it by
+    # exactly 1.00in. Its style's own `right_margin_hmi` is 18000 = 100
+    # columns = 10.00in, and `.po` 0.2in + 10.00in = 10.20in is where the
+    # last glyph of "Header Odd 1" ends, to 0.5pt.
+    #
+    # Every other document in the corpus with a right-aligned head declares
+    # a style right margin EQUAL to its own `.rm` (a "Header at Top of
+    # Page" style at 11700 = 6.50in beside a `.rm 65`), which is why the
+    # `.rm` reading was right everywhere else and wrong here.
+    header_style_rm: dict = field(default_factory=dict)
+    footer_style_rm: dict = field(default_factory=dict)
+    # M16: the LINE HEIGHT in force where this head/foot line was DEFINED,
+    # in 48ths of an inch -- the step between successive running-head
+    # lines, and 0 when the document asked for zero. `{line: lh_48}`.
+    #
+    # Measured (probe B1): removing BOOKLET.WS's own `.lh 0` -- which sits
+    # immediately before its `.f1`/`.h1`/`.h2` and is cancelled by a
+    # `.lh12` immediately after them -- makes real WS7 print its two header
+    # lines on two rows 1/6in apart instead of both on one row, with the
+    # columns left in place. Turning the columns off instead (B2) leaves
+    # them on one row. So the collapse is the line height's doing, not the
+    # column grid's, and it is the value in force at the COMMAND (the
+    # `.lh12` that follows governs the body and not these lines).
+    #
+    # The block is anchored on its LAST line either way (probe B5: a
+    # one-line head prints on the same row the second of two occupies), so
+    # a zero step stacks every line onto that row.
+    header_leads: dict = field(default_factory=dict)
+    footer_leads: dict = field(default_factory=dict)
     # Planning #250: `.H1E`/`.H1O`/`.F1E`/`.F1O` (WSFORMAT.TXT: ".HE can
     # optionally specify even or odd numbered page headers" / the matching
     # ".FO" sentence -- confirmed the ONLY two lines that do; `.H2`-`.H5`/
@@ -3273,7 +3313,18 @@ def _parse_format_dot(cmd: bytes, state: dict) -> None:
                 resolved = _resolve_lh_arg(value, m.group(2))
                 if resolved is not None:     # junk/non-positive: state stands
                     state['lead_48'] = resolved
+                    state['hf_lead_48'] = resolved
                     state['lh_auto'] = False
+                elif value == 0:
+                    # M16 (2026-09-15): `.lh 0` leaves `lead_48` alone --
+                    # a zero body leading is not something any renderer or
+                    # the pagination arithmetic can use, and no evidence
+                    # says WordStar applies it to the body -- but it IS
+                    # what a running head's own line step becomes, proved
+                    # by probes B0/B1/B2 against real WS7 (see
+                    # `Document.header_leads`). Recorded on its own key so
+                    # the head can read it and nothing else changes.
+                    state['hf_lead_48'] = 0.0
     elif name in (b'LM', b'RM', b'PM'):     # left / right / paragraph margin
         # Print columns at 10 CPI, matching `.po`; a unit suffix converts. The
         # archive writes both (`.rm 65` and `.rm 6.5"`).
@@ -3637,7 +3688,8 @@ def _hf_within(doc, cur, cur_line):
 
 def _parse_head_foot(cmd: bytes, doc, encoding: str, anchor=None, font_idx=None,
                      tab_mark=None, align=None, style_attrs=None,
-                     pctl_marks=None, within=None):
+                     pctl_marks=None, within=None, style_rm_cols=None,
+                     lead_48=None):
     """Record `.he`/`.h1`-`.h5` and `.fo`/`.f1`-`.f5` text on the Document.
 
     `.HE` and `.FO` are line 1; the numbered forms select their own line, so a
@@ -3766,6 +3818,18 @@ def _parse_head_foot(cmd: bytes, doc, encoding: str, anchor=None, font_idx=None,
     which_style_attrs = (doc.header_style_attrs if kind == 'H'
                          else doc.footer_style_attrs)
     which_style_attrs[line] = style_attrs or frozenset()
+    # M16: see `Document.header_style_rm`/`header_leads` for the probes.
+    which_style_rm = (doc.header_style_rm if kind == 'H'
+                      else doc.footer_style_rm)
+    if style_rm_cols is not None:
+        which_style_rm[line] = style_rm_cols
+    else:
+        which_style_rm.pop(line, None)
+    which_leads = doc.header_leads if kind == 'H' else doc.footer_leads
+    if lead_48 is not None:
+        which_leads[line] = lead_48
+    else:
+        which_leads.pop(line, None)
     if parity is not None:
         which_p = doc.headers_parity if kind == 'H' else doc.footers_parity
         which_fonts_p = (doc.header_fonts_parity if kind == 'H'
@@ -6146,6 +6210,7 @@ def parse_ws(data: bytes, encoding: str = 'cp437') -> Document:
             hf_align = None
             hf_style_font_idx = None
             hf_style_attrs = None
+            hf_style_rm = None
             if hf_style_w0 is not None and (hf_style_w0 >> 8) == 0x02:
                 _hf_entry = style_slots.get(hf_style_w0 & 0xFF)
                 if _hf_entry is not None:
@@ -6153,6 +6218,11 @@ def parse_ws(data: bytes, encoding: str = 'cp437') -> Document:
                     if _hf_entry.get('font') and any(_hf_entry['font']):
                         hf_style_font_idx = _style_font(_hf_entry['font'])
                     hf_style_attrs = _hf_entry.get('attrs')
+                    # M16: the same 180-HMI-per-column conversion
+                    # `emit.py` already applies to a BODY block's own
+                    # style right margin, read here for the head.
+                    if _hf_entry.get('right_margin_hmi'):
+                        hf_style_rm = _hf_entry['right_margin_hmi'] / 180.0
             _parse_head_foot(cmd if strip_hibit else raw.rstrip(), doc,
                              encoding,
                              anchor=len(doc.blocks) + (1 if cur.lines or
@@ -6175,7 +6245,16 @@ def parse_ws(data: bytes, encoding: str = 'cp437') -> Document:
                                       else hf_style_font_idx),
                              tab_mark=hf_tab_mark,
                              align=hf_align, style_attrs=hf_style_attrs,
-                             pctl_marks=hf_pctl_marks)
+                             pctl_marks=hf_pctl_marks,
+                             style_rm_cols=hf_style_rm,
+                             # M16: the `.lh` in force RIGHT HERE, which is
+                             # what the step between running-head lines
+                             # turns out to be -- `hf_lead_48` and not
+                             # `lead_48`, because a `.lh 0` leaves the
+                             # latter standing (it is not a body leading
+                             # any renderer could use) while still being
+                             # the head's own answer.
+                             lead_48=fmt.get('hf_lead_48'))
             # The index of the block this entry POINTS AT -- the one that follows it,
             # which is the block still open (if it has content) or the next to open.
             # "This heading is in the table of contents" refers forward, not back.

{ctrl_kd-4.7.0 → ctrl_kd-4.8.0}/src/ctrlkd/emit.py

@@ -2883,6 +2883,30 @@ def hf_runs(txt):
     return runs
 
 
+def _rtf_footer_in_use(doc, slots=None):
+    """Is a FOOTER declared at all -- with text, bare, or carrying only
+    invisible characters?
+
+    The question WordStar's automatic page number turns on ("active only
+    when the footers are not in use", WSFORMAT.WS), and deliberately NOT
+    the same question as "is there footer text to draw". `_hf_slots` is
+    the drawing answer and drops an event with no text; this is the
+    declaration answer and counts it, matching `pdf._close_page`'s own
+    `footer_in_use = bool(page_ftrs)` taken before the empty slots are
+    dropped.
+
+    `slots` is `_rtf_running_heads`' own argument: None for the document
+    (section 1, which is the whole document for every file that opens no
+    later section), or a resolved `(hdr_slots, ftr_slots)` pair for a
+    later section -- in which case that section's own already-resolved
+    footer slots are the answer, because `_rtf_hf_slots_at` is what
+    decided them."""
+    if slots is not None:
+        return bool(slots[1])
+    return any(kind == 'F' for kind, _l, _t, _a
+               in getattr(doc, 'hf_events', ()))
+
+
 def _rtf_auto_page_number(doc, page_numbers='auto'):
     """Whether WordStar's own AUTOMATIC page number -- the one `.pc`
     positions, never a `#` the author typed into a real `.he`/`.fo` -- is
@@ -3073,7 +3097,7 @@ def _rtf_keep_plan(doc):
     return plan
 
 
-def _rtf_section_breaks(doc, printed):
+def _rtf_section_breaks(doc):
     r"""`{block_index: (cols, gutter, hdr_slots, ftr_slots)}` -- THE SECTION
     SPINE (planning #264 R1, ruled 2026-09-14; packet section 3's
     recommendation and rows A7/A9/A13).
@@ -3087,13 +3111,16 @@ def _rtf_section_breaks(doc, printed):
 
     TWO things open one:
 
-      A7  a change of newspaper-column regime (`.co n, gutter`). PRINTED
-          ONLY. Modern PDF has no column model at all, and the 2026-08-05
-          ruling is that "Modern PDF needs to be the printed version of
-          the Modern RTF" -- so a columnar Modern RTF would be a Modern
-          RTF its own PDF could not render. Modern stays one column by
-          design. (Modern HTML's `column-count` is a separate, older
-          surface and is untouched.)
+      A7  a change of newspaper-column regime (`.co n, gutter`). BOTH
+          MODES since M17b (2026-09-15). R1 made this Printed-only on the
+          stated grounds that "Modern PDF has no column model at all, and
+          the 2026-08-05 ruling is that Modern PDF needs to be the printed
+          version of the Modern RTF -- so a columnar Modern RTF would be a
+          Modern RTF its own PDF could not render". Modern PDF has a
+          column model now (M17, `pdf._modern_column_width`), so the same
+          ruling read the same way now says the opposite: a ONE-column
+          Modern RTF is the one its own PDF cannot render. (Modern HTML's
+          `column-count` is a separate, older surface and is untouched.)
       A13 a running head or foot REDEFINED mid-document -- a second
           definition of the same slot with different text. The new section
           carries its own `\header`/`\footer` groups.
@@ -3105,18 +3132,17 @@ def _rtf_section_breaks(doc, printed):
     re-anchor (`\pgnrestart\pgnstarts`), and a mid-document `.po`/margin
     change. R1 names A7, A9 and A13; those are the three built."""
     anchors = set(_rtf_hf_redefinitions(doc))
-    state = _rtf_columns_state(doc) if printed else None
-    if printed:
-        for bi, b in enumerate(doc.blocks):
-            # Only a REAL block opens a column regime: a sentinel inherits
-            # the state around it and must not read as a change.
-            if b.columns is None or bi == 0:
-                continue
-            if state[bi] != state[bi - 1]:
-                anchors.add(bi)
+    state = _rtf_columns_state(doc)
+    for bi, b in enumerate(doc.blocks):
+        # Only a REAL block opens a column regime: a sentinel inherits
+        # the state around it and must not read as a change.
+        if b.columns is None or bi == 0:
+            continue
+        if state[bi] != state[bi - 1]:
+            anchors.add(bi)
     out = {}
     for bi in sorted(a for a in anchors if 0 < a < len(doc.blocks)):
-        cols, gutter = state[bi] if printed else (1, None)
+        cols, gutter = state[bi]
         out[bi] = (cols, gutter,
                    _rtf_hf_slots_at(doc, 'H', bi),
                    _rtf_hf_slots_at(doc, 'F', bi))
@@ -3233,11 +3259,17 @@ def _rtf_running_heads(doc, headers=True, auto_page_number=False,
       A4  the head's own alignment (`header_align`/`footer_align`, the
           `.h#`/`.f#` argument's embedded style-sheet reference, planning
           #255) becomes `\\qr`/`\\qc` on the group's paragraph. RTF's
-          header is ONE paragraph carrying every declared line, so the
-          alignment applied is the FIRST rendered line's -- no corpus
-          document declares two head lines with different alignments, and
-          splitting the group into a paragraph per line would change the
-          bytes of every multi-line head to buy that case.
+          header is ONE paragraph carrying every declared line, joined by
+          `\\line`, for as long as those lines AGREE on their alignment --
+          which is every head and foot in the corpus but one. This row
+          originally applied the FIRST line's alignment to the whole
+          group, on the stated grounds that no corpus document declares
+          two head lines with different alignments; `sawyer/REF/
+          BOOKLET.WS` does, and its left-aligned second head line was
+          right-aligned with its first. A group whose lines disagree is
+          written as a paragraph PER LINE instead (2026-09-15), since
+          `\\line` is a break inside a paragraph and cannot carry a second
+          alignment. Every other document's bytes are unchanged.
       A5  `\\headery`/`\\footery` -- see `_rtf_head_foot_distance`.
 
     Planning #264 item 5: the head's OWN print attributes
@@ -3273,13 +3305,28 @@ def _rtf_running_heads(doc, headers=True, auto_page_number=False,
     # and WordStar's automatic number stays off -- which is exactly what
     # `pdf._close_page` records (`footer_in_use = bool(page_ftrs)`, before
     # the empty slots are dropped).
+    #
+    # M15 FOLLOW-UP (2026-09-15): that is what the paragraph above says,
+    # and `ftr_slots` was not it. `_hf_slots` drops an event with NO text
+    # at all (`if ... not txt: continue`), so a document whose only footer
+    # command is a BARE `.fo` read as "no footer in use" and RTF printed
+    # the automatic number on it -- while both PDFs, reading
+    # `footer_in_use` off the un-dropped slots, printed none. Real WS7
+    # prints none: "That holds whether the footer has text, is bare, or
+    # contains only invisible characters" (research/2026-09-15_ws7-
+    # missing-auto-page-number.md, rule 2; the same rule the PDF's own
+    # triage cause 1 fixed on 2026-09-12). Five documents in the public
+    # archive are that shape -- MACROS/HOLYMAC/4MAC2, 4MAC3, 7MAC2, 7MAC3
+    # and LSRBOX/LSRBOX.WS, four of them named in that research as WS7
+    # printing no number on any of their 41/53/35/35 pages -- and their
+    # `rtf.printed` and `rtf.modern` both move here.
     # planning #264 R7 (ruled 2026-09-14): the two flags are SEPARATE and
     # RTF follows the PDF. `headers` governs running heads and feet -- and
     # so a `#` the author typed INSIDE one, which is that head's own text
     # -- while `--page-numbers` governs WordStar's AUTOMATIC number alone.
     # The first RTF batch made `--headers off` swallow the automatic number
     # too; that is reverted here, on both surfaces.
-    show_auto_num = auto_page_number and not ftr_slots
+    show_auto_num = auto_page_number and not _rtf_footer_in_use(doc, slots)
     if not headers:
         hdr_slots, ftr_slots = {}, {}
     headery, footery = _rtf_head_foot_distance(doc.meta.get('page') or {},
@@ -3299,7 +3346,7 @@ def _rtf_running_heads(doc, headers=True, auto_page_number=False,
     def group(name, lines, faces, aligns, attrs):
         if not lines:
             return ''
-        rendered, align_ctl = [], ''
+        rendered, line_aligns = [], []
         for n in sorted(lines):
             txt = lines[n]
             if subst is not None:
@@ -3309,8 +3356,7 @@ def _rtf_running_heads(doc, headers=True, auto_page_number=False,
             runs = hf_runs(txt)
             if not runs:
                 continue                     # control-bytes-only head
-            if not rendered:
-                align_ctl = _RTF_HF_ALIGN.get(aligns.get(n), '')
+            line_aligns.append(_RTF_HF_ALIGN.get(aligns.get(n), ''))
             # planning #264 item 5 (planning #255's `header_style_attrs`):
             # the print attributes the head's OWN style turns on. A
             # `.h#`/`.f#` argument can name a style-sheet entry, and that
@@ -3330,8 +3376,26 @@ def _rtf_running_heads(doc, headers=True, auto_page_number=False,
                 for text, styles in runs))
         if not rendered:
             return ''
-        return (r'{\%s \pard\plain %s\f0\fs22 %s\par}'
-                % (name, align_ctl, r'\line '.join(rendered)))
+        # ONE PARAGRAPH while every rendered line agrees on its alignment
+        # -- which is every head and foot in the corpus but one, so this
+        # is byte-identical to the single-paragraph group RTF has always
+        # written. Planning #264 item 4 (row A4) applied the FIRST line's
+        # alignment to the whole group on the stated grounds that "no
+        # corpus document declares two head lines with different
+        # alignments"; `sawyer/REF/BOOKLET.WS` does (a right-aligned
+        # "Header Odd" over a left-aligned "Header Even"), and the group
+        # right-aligned both. `\line` is a break INSIDE a paragraph and
+        # cannot carry a second alignment, so the lines that disagree get
+        # a paragraph each -- the only form RTF has for this -- and the
+        # reader lays them out exactly as Modern PDF now draws them
+        # (2026-08-05: Modern PDF is the printed form of the Modern RTF).
+        if len(set(line_aligns)) <= 1:
+            return (r'{\%s \pard\plain %s\f0\fs22 %s\par}'
+                    % (name, line_aligns[0], r'\line '.join(rendered)))
+        return (r'{\%s %s}'
+                % (name, ''.join(r'\pard\plain %s\f0\fs22 %s\par'
+                                % (a, r) for a, r in zip(line_aligns,
+                                                         rendered))))
 
     def sided(which, name, slots):
         """One head/foot family, as `\\headerl`/`\\headerr` when the
@@ -3950,8 +4014,8 @@ def emit_rtf(doc, mode='printed', notes=DEFAULT_NOTE_KINDS, styles=True,
     # `_rtf_section_breaks` for what opens a section and what deliberately
     # does not. A document whose geometry never changes gets an empty dict
     # here and emits exactly the bytes it always did.
-    section_breaks = _rtf_section_breaks(doc, printed)
-    columns_state = _rtf_columns_state(doc) if printed else None
+    section_breaks = _rtf_section_breaks(doc)
+    columns_state = _rtf_columns_state(doc)
     # planning #264 R2 (packet row A8): `.cp n`/`.cc n` -> `\keep`/`\keepn`
     # on the paragraphs they asked to hold together. See `_rtf_keep_plan`.
     keep_plan = _rtf_keep_plan(doc)
@@ -3983,14 +4047,12 @@ def emit_rtf(doc, mode='printed', notes=DEFAULT_NOTE_KINDS, styles=True,
             quote_fi_cols = None
         if b.kind == 'colbreak':
             # planning #264 R1 (packet row A9): `.cb` breaks to the next
-            # column -- the reader's own `\column`. PRINTED ONLY, and
-            # inside a columnar region only: Modern has no columns
-            # (`_rtf_section_breaks`) and Modern's own flow drops `.cb`
-            # entirely (`layout.semantic_flow` makes a break item for
-            # `pagebreak` alone), so a `\column` there would be a page
-            # break Modern PDF does not take. Outside a region the control
-            # would mean the same thing to a reader, which is not what
-            # WordStar did with it either -- nothing is written.
+            # column -- the reader's own `\column`. Inside a columnar
+            # region only; outside one the control would mean a break a
+            # reader could still take, which is not what WordStar did with
+            # it either, so nothing is written. BOTH MODES since M17b:
+            # Modern PDF's own column cursor takes `.cb` to the next
+            # column (`pdf._modern_streams`), so its RTF says the same.
             quote_open = False
             quote_fi_cols = None
             if columns_state is not None and columns_state[bi][0] > 1:
@@ -4007,9 +4069,8 @@ def emit_rtf(doc, mode='printed', notes=DEFAULT_NOTE_KINDS, styles=True,
             # WINGDING.CHT's own WS7 capture (its author's `.pa` markers are
             # a manual column-simulation convention that predates the real
             # `.co5` governing the same content; honouring them fragments
-            # one real column into two short pages). RTF had no columns to
-            # fragment before this commit, which is why it could keep the
-            # break; now it has, so it reads the same fact the same way.
+            # one real column into two short pages). Modern PDF absorbs it
+            # on the same evidence since M17, so Modern RTF does too.
             if columns_state is not None and columns_state[bi][0] > 1:
                 continue
             parts.append(r'\page ')
@@ -4283,10 +4344,15 @@ def emit_rtf(doc, mode='printed', notes=DEFAULT_NOTE_KINDS, styles=True,
     # derived margins are left exactly as declared (still top/bottom/left
     # relative to the text, same as WordStar's own driver-level rotation
     # never re-interpreted them either) -- only the CANVAS they sit against
-    # changes shape. Printed only: Modern's page is its own fixed Letter
-    # regardless of the document's declared orientation (same doctrine as
-    # every other Printed-only geometry item).
-    landscape = printed and doc.meta.get('formatting', {}).get('orientation') == 'landscape'
+    # changes shape. BOTH MODES since M17b (2026-09-15): this used to be
+    # Printed-only, on the reading that "Modern's page is its own fixed
+    # Letter". M17 retired that reading for Modern PDF -- a landscape
+    # document's Modern MediaBox is 792x612 now -- and Modern PDF is the
+    # printed form of THIS file (ruled 2026-08-05), so a square 8.5x8.5
+    # Modern RTF would be an RTF its own PDF does not print. It is also
+    # the paged-surface doctrine's point 2 read literally: "honor `.pr
+    # or=l` in ALL paged surfaces", and Modern RTF is one.
+    landscape = doc.meta.get('formatting', {}).get('orientation') == 'landscape'
     if landscape:
         # planning #256 (sawyer/REF/-HOW-TO.RJS + the HP-ENV.LST/HP-ENVMM.LST
         # mailing-label pair): a plain swap of `page['height_in']`/`pw_in`
@@ -4312,11 +4378,30 @@ def emit_rtf(doc, mode='printed', notes=DEFAULT_NOTE_KINDS, styles=True,
     def _twips_lines(key, default_lines):
         v = page.get(key, default_lines)
         return int(round(float(v) * 240))            # 1 line at 6 LPI = 240 twips
+
+    def _paper_twips(height_in):
+        """A declared sheet height in inches -> `\\paperh` twips, with `.pl 0`
+        falling back to Letter.
+
+        `.pl 0` IS NOT A SHEET. It is WordStar's "page breaks off" (bug
+        12284, `core._text_lines_per_page`), and this emitter's text model
+        already never breaks, so the PAGE BOX falls back to Letter -- the
+        rule Printed PDF has carried since `_resolved_page_height` was
+        written and Modern PDF adopted in M18 (`pdf._modern_sheet_h`),
+        quoted here rather than re-decided.
+
+        RTF was the surface still writing the arithmetic straight through:
+        `\\paperh0`, which LibreOffice refuses to open at all. Five
+        documents: `LSRBOX/LSRBOXES.MRG`, `LSRBOX/LSRLINES.MRG`,
+        `RTF-RJS/1-5LINES.WS`, `RTF-RJS/1-SINGLE.WS`, `RTF-RJS/2-DOUBLE.WS`.
+        A document that declares any real height is untouched."""
+        twips = int(round(float(height_in) * 1440))
+        return twips if twips > 0 else 15840
     if printed:
         margt = _twips_lines('mt_lines', 3.0)
         margb = _twips_lines('mb_lines', 8.0)
         margl = int(round(float(page.get('po_cols', 8.0)) * 144))
-        paperh = int(round(float(page.get('height_in', 11.0)) * 1440))
+        paperh = _paper_twips(page.get('height_in', 11.0))
     else:
         margt = (_twips_lines('mt_lines', 6.0)
                  if page.get('mt_source', 'default') != 'default' else 1440)
@@ -4324,8 +4409,14 @@ def emit_rtf(doc, mode='printed', notes=DEFAULT_NOTE_KINDS, styles=True,
                  if page.get('mb_source', 'default') != 'default' else 1440)
         margl = (int(round(float(page.get('po_cols', 10.0)) * 144))
                  if page.get('po_source', 'default') != 'default' else 1440)
-        paperh = (int(round(float(page.get('height_in', 11.0)) * 1440))
-                  if page.get('size_source', 'default') != 'default'
+        # A LANDSCAPE sheet is a declared sheet whatever `.pl` says, so it
+        # is never the 11in default: `page` above is already the swapped,
+        # orientation-aware pair (a `.pl 8.5"` resolves to 8.5 tall x 11
+        # wide, not to the un-landscape-aware 8.5x8.5 SQUARE the portrait
+        # resolution gives). Modern PDF composes on exactly that height
+        # (`pdf._modern_sheet_h`), which is what makes the two agree.
+        paperh = (_paper_twips(page.get('height_in', 11.0))
+                  if landscape or page.get('size_source', 'default') != 'default'
                   else 15840)
     # width joined the page model 2026-08-06: A4-tall documents get the
     # 210mm sheet; everything else (and every default) stays 12240 twips
@@ -4390,11 +4481,9 @@ def emit_rtf(doc, mode='printed', notes=DEFAULT_NOTE_KINDS, styles=True,
     # regime. `\cols` is a section property and the page setup is section
     # 1's; a document that opens outside a columnar region (all but a
     # handful) resolves to one column and writes nothing, so its bytes do
-    # not move. Printed only -- see `_rtf_section_breaks` for why Modern
-    # stays single-column.
-    if printed:
-        pagesetup += _rtf_cols_control(*(_rtf_columns_state(doc)[0]
-                                         if doc.blocks else (1, None)))
+    # not move. BOTH MODES since M17b -- see `_rtf_section_breaks`.
+    pagesetup += _rtf_cols_control(*(_rtf_columns_state(doc)[0]
+                                     if doc.blocks else (1, None)))
     # round 18 (RULINGS-LEDGER row 4): TOC/Index at the document's own end,
     # gated by `--toc` (default off, the ruled default).
     toc_index = _rtf_toc_index(doc, printed) if toc else ''