ctrl-kd 1.3.0__tar.gz → 2.0.0__tar.gz

{ctrl_kd-1.3.0/src/ctrl_kd.egg-info → ctrl_kd-2.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ctrl-kd
-Version: 1.3.0
+Version: 2.0.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
@@ -77,10 +77,13 @@ against surviving period printouts of the same documents. Its rules are empirica
   Paragraph styles become headings, and 82/86 convert with zero mojibake.
   More WS5–7 corpora still welcome.
 * **Page geometry** from the file's own `.pl`/`.po`/`.mt`/`.mb`/`.hm`/`.fm`/
-  `.lh`/`.ls`, so `--mode printed` paginates with WordStar's own vertical model
-  — `.pl − .mt − .mb` at the `.lh` line height, 55 text lines for WordStar's
-  defaults, not a guessed 1-inch margin — and `--diagnose` says whether each
-  figure came from the file or from the default.
+  `.lh`/`.ls`/`.cw`, so `--mode printed` reproduces WordStar's own page: the
+  vertical model (`.pl − .mt − .mb` at the `.lh` line height — 55 text lines
+  for WordStar's defaults, not a guessed 1-inch margin), the horizontal one
+  (`.po` page offset at the `.cw` character pitch), and WordStar's own line
+  breaks — a soft return is where the line broke on paper, so printed output
+  keeps it (and reflowed Modern output still joins it). `--diagnose` says
+  whether each figure came from the file or from the default.
   In `printed` mode footnotes are laid out the way WordStar laid them out: at
   the foot of the page that references them, behind a twenty-dash separator,
   split across pages with `...Continued...` when they do not fit.

{ctrl_kd-1.3.0 → ctrl_kd-2.0.0}/README.md

@@ -58,10 +58,13 @@ against surviving period printouts of the same documents. Its rules are empirica
   Paragraph styles become headings, and 82/86 convert with zero mojibake.
   More WS5–7 corpora still welcome.
 * **Page geometry** from the file's own `.pl`/`.po`/`.mt`/`.mb`/`.hm`/`.fm`/
-  `.lh`/`.ls`, so `--mode printed` paginates with WordStar's own vertical model
-  — `.pl − .mt − .mb` at the `.lh` line height, 55 text lines for WordStar's
-  defaults, not a guessed 1-inch margin — and `--diagnose` says whether each
-  figure came from the file or from the default.
+  `.lh`/`.ls`/`.cw`, so `--mode printed` reproduces WordStar's own page: the
+  vertical model (`.pl − .mt − .mb` at the `.lh` line height — 55 text lines
+  for WordStar's defaults, not a guessed 1-inch margin), the horizontal one
+  (`.po` page offset at the `.cw` character pitch), and WordStar's own line
+  breaks — a soft return is where the line broke on paper, so printed output
+  keeps it (and reflowed Modern output still joins it). `--diagnose` says
+  whether each figure came from the file or from the default.
   In `printed` mode footnotes are laid out the way WordStar laid them out: at
   the foot of the page that references them, behind a twenty-dash separator,
   split across pages with `...Continued...` when they do not fit.

{ctrl_kd-1.3.0 → ctrl_kd-2.0.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "ctrl-kd"
-version = "1.3.0"
+version = "2.0.0"
 description = "Convert WordStar 4-7 documents and print-to-disk files to text, Markdown, HTML, RTF, or PDF. ^KD: save and done."
 readme = "README.md"
 license = {text = "MIT"}

{ctrl_kd-1.3.0 → ctrl_kd-2.0.0/src/ctrl_kd.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ctrl-kd
-Version: 1.3.0
+Version: 2.0.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
@@ -77,10 +77,13 @@ against surviving period printouts of the same documents. Its rules are empirica
   Paragraph styles become headings, and 82/86 convert with zero mojibake.
   More WS5–7 corpora still welcome.
 * **Page geometry** from the file's own `.pl`/`.po`/`.mt`/`.mb`/`.hm`/`.fm`/
-  `.lh`/`.ls`, so `--mode printed` paginates with WordStar's own vertical model
-  — `.pl − .mt − .mb` at the `.lh` line height, 55 text lines for WordStar's
-  defaults, not a guessed 1-inch margin — and `--diagnose` says whether each
-  figure came from the file or from the default.
+  `.lh`/`.ls`/`.cw`, so `--mode printed` reproduces WordStar's own page: the
+  vertical model (`.pl − .mt − .mb` at the `.lh` line height — 55 text lines
+  for WordStar's defaults, not a guessed 1-inch margin), the horizontal one
+  (`.po` page offset at the `.cw` character pitch), and WordStar's own line
+  breaks — a soft return is where the line broke on paper, so printed output
+  keeps it (and reflowed Modern output still joins it). `--diagnose` says
+  whether each figure came from the file or from the default.
   In `printed` mode footnotes are laid out the way WordStar laid them out: at
   the foot of the page that references them, behind a twenty-dash separator,
   split across pages with `...Continued...` when they do not fit.

{ctrl_kd-1.3.0 → ctrl_kd-2.0.0}/src/ctrlkd/__init__.py

@@ -1,8 +1,9 @@
 """ctrl-kd — convert WordStar-era files to modern formats. ^KD: save and done."""
-from .core import detect, parse, parse_ws, parse_printstream, Document, Block, Line, Span
+from .core import (detect, parse, parse_ws, parse_printstream, merged_lines,
+                   Document, Block, Line, Span)
 from .emit import (emit_text, emit_markdown, emit_html, emit_rtf,
                    emitter, get_emitter, formats, load_plugins)
 from .pdf import emit_pdf                        # registers the 'pdf' format
 from .convert import convert, select_notes, DEFAULT_NOTE_KINDS, ALL_NOTE_KINDS
 
-__version__ = '1.3.0'
+__version__ = '2.0.0'

{ctrl_kd-1.3.0 → ctrl_kd-2.0.0}/src/ctrlkd/core.py

@@ -30,6 +30,9 @@ class Span:
 @dataclass
 class Line:
     spans: list = field(default_factory=list)
+    soft: bool = False                   # ends in WordStar's own word wrap (8D soft
+                                          # return): ON PAPER this was a real line break;
+                                          # for reflow it joins the next line (merged_lines)
 
     def text(self):
         return ''.join(s.text for s in self.spans)
@@ -40,6 +43,36 @@ class Block:
     lines: list = field(default_factory=list)
     heading: int = 0                     # 0 = body text; 1-3 = WS5+ title/header/subheading
 
+def merged_lines(block: Block) -> list:
+    """Block.lines with soft-wrapped runs joined back into logical lines --
+    what Block.lines itself WAS before 2.0.0 stored physical lines.
+
+    Printed mode renders Block.lines directly: a soft return is where
+    WordStar broke the line on paper, so the physical line IS the printed
+    line (merging them was the bug that printed thousand-column lines).
+    Reflowing consumers (every Modern emitter) call this instead: a soft
+    break is just word wrap, so the continuation belongs to the same logical
+    line. The join rule is the one parse_ws itself used when it merged at
+    parse time -- a space in the wrapped line's trailing style, suppressed
+    after an existing space or a hyphenated break -- so Modern output is
+    byte-identical either side of the 2.0.0 split."""
+    out, cur = [], None
+    for line in block.lines:
+        if cur is None:
+            cur = Line(list(line.spans))
+        else:
+            cur.spans.extend(line.spans)
+        if line.soft:
+            t = cur.spans[-1].text if cur.spans else ''
+            if t and not t.endswith((' ', '-')):
+                cur.spans.append(Span(' ', cur.spans[-1].styles))
+            continue
+        out.append(cur)
+        cur = None
+    if cur is not None:
+        out.append(cur)
+    return out
+
 @dataclass
 class Note:
     """One footnote/endnote/annotation/comment: WordStar 7.0 symmetrical
@@ -242,7 +275,7 @@ _DOT_NUM_RE = re.compile(rb'^\s*([0-9]*\.?[0-9]+)\s*("|[A-Za-z]{1,2})?')
 _PAGE_DOT_KEYS = {b'PL': 'pl_lines', b'MT': 'mt_lines',
                   b'MB': 'mb_lines', b'PO': 'po_cols',
                   b'HM': 'hm_lines', b'FM': 'fm_lines',
-                  b'LH': 'lh_48', b'LS': 'ls'}
+                  b'LH': 'lh_48', b'LS': 'ls', b'CW': 'cw_120'}
 
 # Named page sizes at 6 LPI (WordStar 7.0 file format spec: ".PL ... assuming
 # 6 lines per inch. An eleven inch page contains 66 lines."): 66 lines/11in
@@ -260,13 +293,18 @@ PAGE_SIZE_SNAP_IN = 0.25
 DEFAULT_PL_LINES = 66.0    # WordStar's own default: 66 lines = 11in = US Letter
 DEFAULT_MT_LINES = 3.0     # spec: ".MT ... Default value is 3 lines."
 DEFAULT_MB_LINES = 8.0     # spec: ".MB ... The default value is 8 lines."
-DEFAULT_PO_COLS = 0.0      # no default is stated in the spec for .po; 0 (flush
-                           # with the paper edge) is the least presumptuous
-                           # reading rather than a remembered/guessed figure.
+DEFAULT_PO_COLS = 8.0      # WS7 manual, "Page Layout": "The default page offset
+                           # is .8 inch" -- 8 print columns at the default 10 CPI.
+                           # (Through 1.3.0 this was 0, "least presumptuous", from
+                           # the file-format spec stating none; the manual DOES
+                           # state one, and 2.0.0 actually renders the offset, so
+                           # the manual's figure governs.)
 DEFAULT_HM_LINES = 2.0     # spec: ".HM ... Default is 2." (header sits INSIDE .mt)
 DEFAULT_FM_LINES = 2.0     # spec: ".FM ... Default is 2." (footer sits INSIDE .mb)
 DEFAULT_LH_48 = 8.0        # spec: ".LH ... The default is 8/48 or 6 lines per inch."
 DEFAULT_LS = 1.0           # single spacing (WS7 manual, "Line Spacing")
+DEFAULT_CW_120 = 12.0      # spec: ".CW ... The default is 12 (12/120ths is 10
+                           # characters per inch)."
 
 def _dot_arg_inches(value: float, unit: bytes | None):
     """Convert a dot-command argument's optional unit suffix to inches.
@@ -313,8 +351,18 @@ def _resolve_ls_arg(value: float, unit: bytes | None):
         return None
     return value
 
+def _resolve_cw_arg(value: float, unit: bytes | None):
+    """.cw argument -> character width in 1/120in units. Unit-less IS 120ths
+    (spec: ".CW ... the width of the characters in 1/120 inch increments. ...
+    The default is 12 (12/120ths is 10 characters per inch)"); an explicit
+    unit suffix converts. Non-positive width is meaningless: rejected."""
+    inches = _dot_arg_inches(value, unit)
+    resolved = value if inches is None else inches * 120.0
+    return resolved if resolved > 0 else None
+
 _PAGE_DOT_RESOLVERS = {'po_cols': _resolve_cols_arg, 'lh_48': _resolve_lh_arg,
-                       'ls': _resolve_ls_arg}     # everything else: lines at 6 LPI
+                       'ls': _resolve_ls_arg,
+                       'cw_120': _resolve_cw_arg}  # everything else: lines at 6 LPI
 
 def _text_lines_per_page(pl_lines: float, mt_lines: float, mb_lines: float,
                          lh_48: float) -> int:
@@ -717,9 +765,17 @@ def parse_ws(data: bytes, encoding: str = 'cp437') -> Document:
         for s in spans:
             cur_line.spans.append(s)
         if sep == 'wrap':
-            t = cur_line.spans[-1].text if cur_line.spans else ''
-            if t and not t.endswith((' ', '-')):
-                cur_line.spans.append(Span(' ', cur_line.spans[-1].styles))
+            # A soft return: a REAL line break on paper (printed mode renders
+            # it), just word wrap for reflow (merged_lines joins it back with
+            # the space rule that used to live right here). 2.0.0: physical
+            # lines are stored; merging is the consumer's choice now.
+            if cur_line.spans:
+                cur_line.soft = True
+                close_line()
+            elif cur.lines:
+                cur.lines[-1].soft = True          # invisible (toggles-only) line:
+                                                    # its softness binds the previous
+                                                    # printed line, as the old merge did
         elif sep == 'line':
             close_line()
         else:                                      # para / eof
@@ -740,6 +796,7 @@ def parse_ws(data: bytes, encoding: str = 'cp437') -> Document:
     fm_lines = page.get('fm_lines')
     lh_48 = page.get('lh_48')
     ls = page.get('ls')
+    cw_120 = page.get('cw_120')
     # Exposed per the IR contract: a consumer must be able to distinguish
     # "Legal (from file)" from "Letter (default)" -- provenance lives
     # alongside every resolved figure, not just the page size.
@@ -762,6 +819,8 @@ def parse_ws(data: bytes, encoding: str = 'cp437') -> Document:
         'lh_source': 'file' if lh_48 is not None else 'default',
         'ls': ls if ls is not None else DEFAULT_LS,
         'ls_source': 'file' if ls is not None else 'default',
+        'cw_120': cw_120 if cw_120 is not None else DEFAULT_CW_120,
+        'cw_source': 'file' if cw_120 is not None else 'default',
     }
     # The one derived figure consumers actually need: printed text lines per
     # page, from WordStar's own vertical model (see _text_lines_per_page for

{ctrl_kd-1.3.0 → ctrl_kd-2.0.0}/src/ctrlkd/emit.py

@@ -10,6 +10,8 @@ Two rendering philosophies, chosen by the caller:
 import html as _html
 import re
 
+from .core import merged_lines
+
 # ---------------------------------------------------------------- registry
 #
 # The extension point. An emitter is any callable (doc, mode='modern', **options)
@@ -164,6 +166,7 @@ def emit_text(doc, mode='modern', notes=DEFAULT_NOTE_KINDS, **_options):
     keep = frozenset(notes)
     pairs = _annotated_notes(doc)
     refs = _ref_pairs(pairs)
+    printed = mode == 'printed' or _printed(doc)
     out = []
     for b in doc.blocks:
         if b.kind == 'softpage':                 # WordStar's own pagination:
@@ -174,7 +177,9 @@ def emit_text(doc, mode='modern', notes=DEFAULT_NOTE_KINDS, **_options):
             out.append('\f' if mode == 'printed' else '\n' + '-' * 20 + '\n')
             continue
         lines = []
-        for line in b.lines:
+        # printed: PHYSICAL lines (soft returns broke the line on paper);
+        # modern: logical lines, soft runs joined back (core.merged_lines)
+        for line in (b.lines if printed else merged_lines(b)):
             seg = []
             for s in line.spans:
                 note, label = (_resolve_ref(refs, s.text)
@@ -275,7 +280,8 @@ def emit_markdown(doc, mode='modern', notes=DEFAULT_NOTE_KINDS, **_options):
         if b.kind == 'pagebreak':
             out.append('---')
             continue
-        lines = [''.join(_md_span(s, refs, keep) for s in line.spans) for line in b.lines]
+        lines = [''.join(_md_span(s, refs, keep) for s in line.spans)
+                 for line in merged_lines(b)]          # logical lines: soft wraps joined
         para = '\\\n'.join(l for l in lines)          # hard breaks: trailing backslash
         if b.heading and para.strip():
             para = '#' * b.heading + ' ' + para.strip()
@@ -417,16 +423,19 @@ def emit_html(doc, mode='modern', title='', notes=DEFAULT_NOTE_KINDS, **_options
             parts.append('<hr class="pb">')
             continue
         if b.heading:
-            txt = ' '.join(_html_line(line, refs, keep) for line in b.lines).strip()
+            # merged either mode: a heading is a logical unit, and joining its
+            # logical lines with a space is what this always rendered
+            txt = ' '.join(_html_line(line, refs, keep) for line in merged_lines(b)).strip()
             if txt:
                 parts.append(f'<h{b.heading}>{txt}</h{b.heading}>')
             continue
         if printed:
+            # PHYSICAL lines: inside <pre>, a soft return is a real line break
             body = '\n'.join(_html_line(line, refs, keep, keep_ws=True) for line in b.lines)
             if body.strip():
                 parts.append(f'<pre>{body}</pre>')
         else:
-            lines = [_html_line(line, refs, keep) for line in b.lines]
+            lines = [_html_line(line, refs, keep) for line in merged_lines(b)]
             para = '<br>\n'.join(lines)
             if para.strip():
                 parts.append(f'<p>{para}</p>')
@@ -540,7 +549,9 @@ def emit_rtf(doc, mode='modern', notes=DEFAULT_NOTE_KINDS, **_options):
             parts.append(r'\page ')
             continue
         lines = []
-        for line in b.lines:
+        # printed: physical lines (\line at every printed break, soft or hard);
+        # modern: logical lines only
+        for line in (b.lines if printed else merged_lines(b)):
             seg = ''.join(_rtf_span(sp, refs, keep) for sp in line.spans)
             lines.append(seg)
         if b.heading:

{ctrl_kd-1.3.0 → ctrl_kd-2.0.0}/src/ctrlkd/pdf.py

@@ -13,6 +13,7 @@ Styles: bold/italic map to the Courier variants, underline is drawn, superscript
 is raised and reduced. Non-Latin-1 characters degrade to '?'.
 """
 import re as _re
+from .core import merged_lines as _merged_lines
 from .emit import emitter, _printed, _annotated_notes, _ref_pairs
 
 PAGE_W, PAGE_H = 612, 792            # US Letter, points
@@ -97,6 +98,37 @@ def _printed_lead(doc):
     lh = page.get('lh_48', 8.0)
     return lh * 1.5 if lh > 0 else LEAD
 
+def _printed_size(doc):
+    """Type size in points for printed mode, from .cw: character width in
+    1/120in units, and Courier advances 0.6em, so a pitch of cw/120in per
+    character IS a (cw*72/120)/0.6 = cw*1.0 point font. The default .cw 12
+    (10 CPI pica) IS the 12pt this emitter always used; .cw 10 is 12 CPI
+    elite at 10pt. Rounded to whole points (the Tf operator is written as
+    an integer, as it always has been), floored at 1. Print streams keep
+    the fixed SIZE."""
+    page = doc.meta.get('page')
+    if page is None:
+        return SIZE
+    cw = page.get('cw_120', 12.0)
+    return max(1, round(cw)) if cw > 0 else SIZE
+
+def _printed_left(doc, size):
+    """Left edge of text in points for printed mode, from .po: "the number
+    of print columns from the left edge of the paper to the left margin of
+    text. The current setting of character width (.CW) determines the
+    actual amount of indentation" -- so the offset is po columns at this
+    document's own advance (0.6em of `size`). The default .po 8 (the WS7
+    manual's ".8 inch" at 10 CPI) lands at 57.6pt -- NOT the old fixed 72pt
+    MARGIN, which was this emitter's guess, not WordStar's. Print streams
+    keep MARGIN: their offset spaces, where a driver emitted them, are
+    in-band. Clamped inside the page for garbage .po from misdetected
+    binaries."""
+    page = doc.meta.get('page')
+    if page is None:
+        return float(MARGIN)
+    left = page.get('po_cols', 8.0) * size * 0.6
+    return max(0.0, min(left, PAGE_W - size * 0.6))
+
 FONTS = {(False, False): 'F1', (True, False): 'F2',
          (False, True): 'F3', (True, True): 'F4'}
 FONT_NAMES = {'F1': 'Courier', 'F2': 'Courier-Bold',
@@ -384,7 +416,10 @@ def _doc_to_pagelines(doc, printed):
             continue
         if b.kind == 'softpage':
             continue
-        for line in b.lines:
+        # printed renders PHYSICAL lines (a soft return broke the line on
+        # paper); modern reflows LOGICAL lines (soft runs joined back --
+        # core.merged_lines, the 2.0.0 split)
+        for line in (b.lines if printed else _merged_lines(b)):
             # the docstring's "headings bold" promise: heading blocks render in
             # Courier-Bold (found unimplemented by the Swift port, job-011)
             spans = [(s.text, s.styles | {'b'} if b.heading else s.styles)
@@ -454,21 +489,24 @@ def _coalesce(line):
             out.append([text, styles])
     return out
 
-def _page_stream(pagelines, top, page_h=PAGE_H, lead=LEAD):
+def _page_stream(pagelines, top, page_h=PAGE_H, lead=LEAD, size=SIZE,
+                 left=float(MARGIN)):
     ops = []
-    y = page_h - top - SIZE
+    sup_size = max(1, round(size * 2 / 3))       # 8 at the default 12 -- the
+                                                  # ratio this emitter always used
+    y = page_h - top - size
     for line in pagelines:
-        x = MARGIN
+        x = left
         for text, styles in _coalesce(line):
             if not text:
                 continue
             sup = 'sup' in styles or 'sub' in styles
-            size = 8 if sup else SIZE
+            size_here = sup_size if sup else size
             rise = 3 if 'sup' in styles else (-2 if 'sub' in styles else 0)
             font = FONTS[('b' in styles, 'i' in styles)]
             ops.append(b'BT /%s %d Tf %d Ts %.1f %.1f Td (%s) Tj ET' %
-                       (font.encode(), size, rise, x, y, _esc(text)))
-            w = len(text) * size * 0.6
+                       (font.encode(), size_here, rise, x, y, _esc(text)))
+            w = len(text) * size_here * 0.6
             if 'u' in styles and text.strip():
                 ops.append(b'0.6 w %.1f %.1f m %.1f %.1f l S' % (x, y - 1.5, x + w, y - 1.5))
             if 'strike' in styles and text.strip():
@@ -486,6 +524,10 @@ def emit_pdf(doc, mode='modern', **options):
     top = _printed_top(doc) if printed else TOP_MODERN    # .mt-derived for WS docs;
                                                            # default .mt 3 IS the old 36pt
     lead = _printed_lead(doc) if printed else LEAD        # .lh-derived; .lh 8 IS 12pt
+    size = _printed_size(doc) if printed else SIZE        # .cw-derived; .cw 12 IS 12pt
+    left = _printed_left(doc, size) if printed else float(MARGIN)   # .po-derived;
+                                                           # default .po 8 = 57.6pt, the
+                                                           # manual's .8in -- see _printed_left
     page_h = _resolved_page_height(doc, printed)          # file geometry wins in
                                                            # printed mode (Task: .pl);
                                                            # modern stays fixed Letter
@@ -516,7 +558,7 @@ def emit_pdf(doc, mode='modern', **options):
                      b'<< /Type /Page /Parent 2 0 R /MediaBox [0 0 %d %d] '
                      b'/Resources << /Font << %s >> >> /Contents %d 0 R >>'
                      % (PAGE_W, page_h, font_dict, cnum)))
-        stream = _page_stream(pl, top, page_h, lead)
+        stream = _page_stream(pl, top, page_h, lead, size, left)
         objs.append((cnum, b'<< /Length %d >>\nstream\n%s\nendstream'
                      % (len(stream), stream)))
 

{ctrl_kd-1.3.0 → ctrl_kd-2.0.0}/tests/test_ctrlkd.py

@@ -718,7 +718,9 @@ def test_page_geometry_defaults_to_letter():
     assert page['size_source'] == 'default'
     assert page['mt_lines'] == 3.0 and page['mt_source'] == 'default'
     assert page['mb_lines'] == 8.0 and page['mb_source'] == 'default'
-    assert page['po_cols'] == 0.0 and page['po_source'] == 'default'
+    # 8, not 0: WS7 manual, "The default page offset is .8 inch" -- since 2.0.0
+    # renders the offset, the manual's stated default governs
+    assert page['po_cols'] == 8.0 and page['po_source'] == 'default'
 
 def test_page_geometry_pl_unitless_is_lines_not_inches():
     # THE trap: WordTsar's own @todo admits it falls back to inches when
@@ -878,6 +880,96 @@ def test_pdf_output_bytes_carry_mt_top_and_lh_lead():
     assert ys[0] - ys[1] == 24.0                   # lead from .lh, not fixed 12
     assert ys[1] - ys[2] == 24.0
 
+# ------------------------------------------- horizontal geometry (2.0.0)
+
+# WS4-shaped bytes: soft return = 8D 0A, hard = 0D 0A. ws4_text-style helper
+# fixtures exist above for style codes; plain ASCII is enough here.
+SOFT = b'\x8d\x0a'
+
+def _ws_wrapped_para():
+    # two soft-wrapped physical lines then a hard return -- classic word wrap.
+    # Lines are near the 65-col default margin so lines_pass reads the soft
+    # breaks as wrap (joining would overflow), not as deliberate breaks.
+    l1 = b'w' * 30 + b' ' + b'x' * 30
+    l2 = b'y' * 30 + b' ' + b'z' * 30
+    return l1 + SOFT + l2 + HARD
+
+def test_soft_wrapped_lines_stay_physical_in_the_ir():
+    doc = core.parse_ws(_ws_wrapped_para())
+    para = [b for b in doc.blocks if b.kind == 'para'][0]
+    assert len(para.lines) == 2                    # physical lines preserved
+    assert para.lines[0].soft is True              # ...and marked
+    assert para.lines[1].soft is False
+
+def test_merged_lines_reproduces_the_old_logical_line():
+    # the reflow view: soft runs joined with the old space rule
+    doc = core.parse_ws(_ws_wrapped_para())
+    para = [b for b in doc.blocks if b.kind == 'para'][0]
+    logical = core.merged_lines(para)
+    assert len(logical) == 1
+    text = logical[0].text()
+    assert text == 'w' * 30 + ' ' + 'x' * 30 + ' ' + 'y' * 30 + ' ' + 'z' * 30
+
+def test_merged_lines_suppresses_space_after_hyphen():
+    # l1 must be long enough that lines_pass reads the soft break as wrap
+    # (L + 1 + W >= the 65-col default margin), or the break is 'line' and
+    # never merges at all
+    l1 = b'a' * 56 + b' hyphen-'
+    data = l1 + SOFT + b'ated word plus enough text to reach the margin here.' + HARD
+    doc = core.parse_ws(data)
+    para = [b for b in doc.blocks if b.kind == 'para'][0]
+    logical = core.merged_lines(para)
+    assert 'hyphen-ated' in logical[0].text()      # no space injected
+
+def test_printed_text_renders_physical_lines_modern_renders_logical():
+    # emit_text on a parse_ws doc directly: convert()'s auto-detect would
+    # read these low-high-bit synthetic bytes as a printstream and never
+    # exercise the soft flags at all (a vacuous pass)
+    from ctrlkd.emit import emit_text
+    doc = core.parse_ws(_ws_wrapped_para())
+    printed = emit_text(doc, mode='printed')
+    modern = emit_text(doc, mode='modern')
+    assert 'w' * 30 + ' ' + 'x' * 30 + '\n' + 'y' * 30 in printed   # break kept
+    assert 'x' * 30 + ' ' + 'y' * 30 in modern                       # joined
+
+def test_page_geometry_cw_parsed_and_units():
+    doc = core.parse_ws(b'.CW 10' + HARD + b'x' + HARD)
+    assert doc.meta['page']['cw_120'] == 10.0
+    assert doc.meta['page']['cw_source'] == 'file'
+    # 0.1 inch = 12/120ths -- the default pitch, stated in inches
+    doc = core.parse_ws(b'.CW 0.1"' + HARD + b'x' + HARD)
+    assert doc.meta['page']['cw_120'] == pytest.approx(12.0)
+
+def test_page_geometry_cw_zero_rejected():
+    doc = core.parse_ws(b'.CW 0' + HARD + b'x' + HARD)
+    assert doc.meta['page']['cw_120'] == 12.0
+    assert doc.meta['page']['cw_source'] == 'default'
+
+def test_pdf_printed_size_and_left_follow_cw_po():
+    from ctrlkd.pdf import _printed_size, _printed_left
+    d_default = core.parse_ws(b'x' + HARD)
+    assert _printed_size(d_default) == 12
+    assert _printed_left(d_default, 12) == pytest.approx(8 * 12 * 0.6)   # 57.6
+    d_elite = core.parse_ws(b'.CW 10' + HARD + b'.PO 12' + HARD + b'x' + HARD)
+    assert _printed_size(d_elite) == 10
+    assert _printed_left(d_elite, 10) == pytest.approx(12 * 10 * 0.6)    # 72.0
+
+def test_pdf_output_bytes_carry_po_left_and_cw_size():
+    # end-to-end: x-coordinates and Tf size come from the file's own .po/.cw
+    import re
+    from ctrlkd.pdf import emit_pdf
+    data = (b'.PO 12' + HARD + b'.CW 10' + HARD + b'Line one.' + HARD)
+    pdf = emit_pdf(core.parse_ws(data), mode='printed')
+    m = re.search(rb'/F1 (\d+) Tf \d+ Ts ([\d.]+) [\d.]+ Td', pdf)
+    assert m and m.group(1) == b'10'               # elite type size
+    assert m.group(2) == b'72.0'                   # 12 cols x 10pt x 0.6em
+
+def test_pdf_printstream_keeps_fixed_margin_and_size():
+    from ctrlkd.pdf import _printed_size, _printed_left
+    ps = core.parse_printstream(b'line one\r\n')
+    assert _printed_size(ps) == 12
+    assert _printed_left(ps, 12) == 72.0           # streams: offset is in-band
+
 def test_pdf_printstream_capacity_is_the_full_page():
     # a print stream IS the printed page -- its margin blanks travel in-band,
     # so the page budget is the FULL 66 lines of a Letter page: anything