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

{ctrl_kd-1.2.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.2.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
@@ -76,9 +76,14 @@ against surviving period printouts of the same documents. Its rules are empirica
   WordStar never printed them; `--diagnose` still reports that they exist.
   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`, so `--mode
-  printed` uses the page the author set up rather than an assumed one — and
-  `--diagnose` says whether the size came from the file or from the default.
+* **Page geometry** from the file's own `.pl`/`.po`/`.mt`/`.mb`/`.hm`/`.fm`/
+  `.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.2.0 → ctrl_kd-2.0.0}/README.md

@@ -57,9 +57,14 @@ against surviving period printouts of the same documents. Its rules are empirica
   WordStar never printed them; `--diagnose` still reports that they exist.
   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`, so `--mode
-  printed` uses the page the author set up rather than an assumed one — and
-  `--diagnose` says whether the size came from the file or from the default.
+* **Page geometry** from the file's own `.pl`/`.po`/`.mt`/`.mb`/`.hm`/`.fm`/
+  `.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.2.0 → ctrl_kd-2.0.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "ctrl-kd"
-version = "1.2.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.2.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.2.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
@@ -76,9 +76,14 @@ against surviving period printouts of the same documents. Its rules are empirica
   WordStar never printed them; `--diagnose` still reports that they exist.
   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`, so `--mode
-  printed` uses the page the author set up rather than an assumed one — and
-  `--diagnose` says whether the size came from the file or from the default.
+* **Page geometry** from the file's own `.pl`/`.po`/`.mt`/`.mb`/`.hm`/`.fm`/
+  `.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.2.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.2.0'
+__version__ = '2.0.0'

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

@@ -16,6 +16,7 @@ WordStar background this code encodes:
   sent to the printer, captured to a file. They ARE the printed page.
 """
 from __future__ import annotations
+import math
 import re
 from dataclasses import dataclass, field
 
@@ -29,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)
@@ -39,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
@@ -239,7 +273,9 @@ _DOT_CMD_RE = re.compile(rb'^\.([A-Za-z]{1,3})\s*(.*)$')
 _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'MB': 'mb_lines', b'PO': 'po_cols',
+                  b'HM': 'hm_lines', b'FM': 'fm_lines',
+                  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
@@ -257,9 +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.
@@ -287,6 +332,67 @@ def _resolve_cols_arg(value: float, unit: bytes | None) -> float:
     inches = _dot_arg_inches(value, unit)
     return value if inches is None else inches * 10.0
 
+def _resolve_lh_arg(value: float, unit: bytes | None):
+    """.lh argument -> line height in 1/48in units. Unit-less IS 48ths (WS7
+    manual: "You can also type the dot command in 48ths of an inch. For
+    example, .lh 8 is 8/48 inch, or the standard 6 lines per inch"); an
+    explicit unit suffix converts. `.lh a` (auto-leading) never reaches here
+    -- the numeric matcher won't match it, so it stays default + verbatim.
+    A non-positive height is meaningless: rejected (None), default stands."""
+    inches = _dot_arg_inches(value, unit)
+    resolved = value if inches is None else inches * 48.0
+    return resolved if resolved > 0 else None
+
+def _resolve_ls_arg(value: float, unit: bytes | None):
+    """.ls argument -> line spacing. "A line spacing of between 1 and 9"
+    (WS7 file format spec); anything else is junk, rejected (None). Any unit
+    suffix is likewise junk -- spacing is a count, not a measure."""
+    if unit is not None or not 1 <= value <= 9:
+        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,
+                       '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:
+    """Printed text lines per page -- WordStar's own vertical model (WS7
+    manual, "Page Layout"): "The top and bottom margins define the space
+    between the text and the top and bottom of the paper. On an 8.5 x 11-inch
+    page, if the top margin is .33 inches and the bottom margin is 1.33
+    inches, the space left for text is 9.33 inches." Lines available is that
+    text height divided by the line height (.lh, 1/48in units): "Changing the
+    line height affects the number of lines that can be printed on a page."
+    WordStar's own defaults (.pl 66 .mt 3 .mb 8 .lh 8) give 55.
+
+    Deliberately NOT in the formula:
+    - .hm/.fm -- the header prints WITHIN .mt and the footer WITHIN .mb
+      (".MT ... The header is printed within this margin"; ".MB ... The
+      footer or page number is printed within this margin"), so they position
+      header/footer inside space already subtracted, never reserve more.
+    - .ls -- line-spacing blanks are literal lines in the file ("when you use
+      line spacing, the blank lines become part of the file", WS7 manual,
+      "Line Spacing"), so the body text already carries them; dividing
+      capacity by .ls would double-count.
+
+    Unit-less .mt/.mb are lines at the fixed 6 LPI baseline (the module-note
+    assumption); .lh at parse time is resolved once per document (first
+    occurrence wins), not tracked per-line."""
+    usable = pl_lines - mt_lines - mb_lines            # lines at 6 LPI
+    if not math.isfinite(usable) or not math.isfinite(lh_48) or lh_48 <= 0:
+        return 1
+    return max(1, int(usable * 8.0 / lh_48))
+
 def _resolve_page_size(pl_lines: float):
     """pl_lines -> (height_in, size_name). Snaps to a named size when close;
     otherwise reports the raw geometry under 'Custom' rather than forcing a
@@ -340,8 +446,10 @@ def _parse_page_dot(cmd: bytes, page: dict, meta_extra: dict):
             return
         value = float(num.group(1))
         unit = num.group(2)
-        resolver = _resolve_cols_arg if name == b'PO' else _resolve_lines_arg
-        page[key] = resolver(value, unit)
+        resolver = _PAGE_DOT_RESOLVERS.get(key, _resolve_lines_arg)
+        resolved = resolver(value, unit)
+        if resolved is not None:                      # junk argument: default stands
+            page[key] = resolved
     elif name in (b'PT', b'PSA', b'PSB'):
         # WordTsar's own invented dot commands (its source calls them "not a
         # Wordstar command"). A real WordStar file never contains these --
@@ -657,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
@@ -676,6 +792,11 @@ def parse_ws(data: bytes, encoding: str = 'cp437') -> Document:
     mt_lines = page.get('mt_lines')
     mb_lines = page.get('mb_lines')
     po_cols = page.get('po_cols')
+    hm_lines = page.get('hm_lines')
+    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.
@@ -690,7 +811,24 @@ def parse_ws(data: bytes, encoding: str = 'cp437') -> Document:
         'mb_source': 'file' if mb_lines is not None else 'default',
         'po_cols': po_cols if po_cols is not None else DEFAULT_PO_COLS,
         'po_source': 'file' if po_cols is not None else 'default',
+        'hm_lines': hm_lines if hm_lines is not None else DEFAULT_HM_LINES,
+        'hm_source': 'file' if hm_lines is not None else 'default',
+        'fm_lines': fm_lines if fm_lines is not None else DEFAULT_FM_LINES,
+        'fm_source': 'file' if fm_lines is not None else 'default',
+        'lh_48': lh_48 if lh_48 is not None else DEFAULT_LH_48,
+        '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
+    # the formula and the deliberate exclusions). Defaults -> 55, NOT the 60
+    # a naive 1in-margin Letter computation gives.
+    doc.meta['page']['text_lines'] = _text_lines_per_page(
+        doc.meta['page']['pl_lines'], doc.meta['page']['mt_lines'],
+        doc.meta['page']['mb_lines'], doc.meta['page']['lh_48'])
     if meta_extra:
         doc.meta.update(meta_extra)
     return doc

{ctrl_kd-1.2.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.2.0 → ctrl_kd-2.0.0}/src/ctrlkd/pdf.py

@@ -13,18 +13,21 @@ 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
 MARGIN = 72                          # 1 inch
 SIZE, LEAD = 12, 12                  # 10 CPI pica x 6 LPI — the dot-matrix standard;
                                      # a 65-col WordStar line is exactly 6.5in
-TOP_MODERN, TOP_PRINTED = 72, 36     # print streams carry their own top-margin blanks
+TOP_MODERN, TOP_PRINTED = 72, 36     # printed: default when a stream has no geometry
+                                     # meta (its margin blanks travel in-band); WS docs
+                                     # get an .mt-derived top from _printed_top()
 LINES_MODERN = (PAGE_H - 2 * 72) // LEAD                 # 54
-LINES_PRINTED = (PAGE_H - 2 * 36) // LEAD                # 60 -- the US Letter default;
-                                                          # printed mode's real per-document
-                                                          # figure comes from _printed_cap(),
-                                                          # which honours .pl-derived geometry
+# Printed capacity is per-document: _printed_cap() -- WordStar's own model
+# (.pl - .mt - .mb at the .lh line height; 55 for WordStar's defaults). The
+# old hardcoded (PAGE_H - 2*36)//LEAD = 60 was a naive Letter computation
+# that matched no WordStar the manual describes.
 MAX_COLS = int((PAGE_W - 2 * MARGIN) / (SIZE * 0.6))     # 65 — WordStar's own margin
 
 # Period-authentic footnote layout (Printed mode only -- WordStar Professional
@@ -55,9 +58,76 @@ def _resolved_page_height(doc, printed):
 def _printed_cap(doc):
     """Lines of vertical room on a printed page for THIS document -- the
     cap used both for plain pagination and as the footnote layout's page
-    budget (see _paginate_printed_notes)."""
+    budget (see _paginate_printed_notes).
+
+    WS documents carry doc.meta['page'] and get WordStar's own vertical
+    model (core._text_lines_per_page: .pl - .mt - .mb at the .lh line
+    height -- 55 for WordStar's defaults, NOT the 60 a naive 1in-margin
+    computation gives). Print streams have no 'page' meta and ARE the
+    printed page -- their margin blanks travel in-band -- so their budget
+    is the FULL page height in lines (66 on Letter): anything smaller
+    would split a physical page that the printer produced whole."""
+    page = doc.meta.get('page')
+    if page is not None:
+        return max(FOOTNOTE_FLOOR + 1, page.get('text_lines', 55))
     page_h = _resolved_page_height(doc, True)
-    return max(FOOTNOTE_FLOOR + 1, (page_h - 2 * TOP_PRINTED) // LEAD)
+    return max(FOOTNOTE_FLOOR + 1, int(page_h // LEAD))
+
+def _printed_top(doc):
+    """Top-of-text offset in points for printed mode. WS documents start
+    where .mt says (lines at 6 LPI -> 12pt each; the default .mt 3 is the
+    36pt this emitter always used). Print streams keep the fixed 36pt --
+    their own top-margin blanks are in the data (minus the machine-margin
+    strip in _doc_to_pagelines). Clamped inside the page so garbage .mt
+    from a misdetected binary degrades to an ugly page, never an absurd
+    coordinate space."""
+    page = doc.meta.get('page')
+    if page is None:
+        return TOP_PRINTED
+    page_h = _resolved_page_height(doc, True)
+    return max(0, min(round(page.get('mt_lines', 3.0) * 12), page_h - LEAD))
+
+def _printed_lead(doc):
+    """Baseline-to-baseline distance in points for printed mode: .lh is
+    1/48in units, a point is 1/72in -> lh * 1.5. Default .lh 8 IS the 12pt
+    lead this emitter always used. Print streams (no 'page' meta) keep the
+    fixed LEAD."""
+    page = doc.meta.get('page')
+    if page is None:
+        return LEAD
+    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'}
@@ -346,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)
@@ -416,27 +489,30 @@ def _coalesce(line):
             out.append([text, styles])
     return out
 
-def _page_stream(pagelines, top, page_h=PAGE_H):
+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():
                 ops.append(b'0.6 w %.1f %.1f m %.1f %.1f l S' % (x, y + 3, x + w, y + 3))
             x += w
-        y -= LEAD
+        y -= lead
     return b'\n'.join(ops)
 
 @emitter('pdf')
@@ -445,7 +521,13 @@ def emit_pdf(doc, mode='modern', **options):
     stream per page, xref. Returns bytes — PDF is a binary format."""
     printed = mode == 'printed' or _printed(doc)
     pages = _doc_to_pagelines(doc, printed)
-    top = TOP_PRINTED if printed else TOP_MODERN
+    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
@@ -476,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)
+        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.2.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
@@ -778,6 +780,205 @@ def test_page_geometry_malformed_pl_does_not_crash():
     assert doc.meta['page']['pl_lines'] == 66.0
     assert doc.meta['page']['size_source'] == 'default'
 
+# ------------------------------------------- the vertical model (text_lines)
+
+def test_page_geometry_defaults_give_wordstar_55_not_60():
+    # THE fix this section exists for: WordStar's own defaults (.pl 66
+    # .mt 3 .mb 8 .lh 8) put 55 text lines on a page -- the manual's model,
+    # (pl - mt - mb) at 6 LPI -- not the 60 a naive 1in-margin Letter
+    # computation produced for every document before 1.3.0.
+    from ctrlkd.pdf import _printed_cap
+    doc = core.parse_ws(b'Body text.' + HARD)
+    assert doc.meta['page']['text_lines'] == 55
+    assert _printed_cap(doc) == 55
+
+def test_page_geometry_mt_mb_change_capacity():
+    doc = core.parse_ws(b'.MT 6' + HARD + b'.MB 6' + HARD + b'x' + HARD)
+    assert doc.meta['page']['text_lines'] == 54          # 66 - 6 - 6
+
+def test_page_geometry_lh_parsed_and_scales_capacity():
+    # .lh is 1/48in units: .lh 16 doubles the line height, halving capacity
+    # (the manual: "Changing the line height affects the number of lines
+    # that can be printed on a page"). floor(55 * 8 / 16) = 27.
+    doc = core.parse_ws(b'.LH 16' + HARD + b'x' + HARD)
+    page = doc.meta['page']
+    assert page['lh_48'] == 16.0 and page['lh_source'] == 'file'
+    assert page['text_lines'] == 27
+
+def test_page_geometry_lh_unit_suffix_converts():
+    # .lh 12p = 12/72in = 8/48in -> the standard height, stated in points
+    doc = core.parse_ws(b'.LH 12P' + HARD + b'x' + HARD)
+    assert doc.meta['page']['lh_48'] == 8.0
+    assert doc.meta['page']['text_lines'] == 55
+
+def test_page_geometry_lh_zero_and_auto_rejected():
+    # .lh 0 is meaningless and .lh a is auto-leading -- both leave the
+    # default standing (and stay preserved verbatim in dot_commands)
+    for arg in (b'.LH 0', b'.LH A'):
+        doc = core.parse_ws(arg + HARD + b'x' + HARD)
+        assert doc.meta['page']['lh_48'] == 8.0
+        assert doc.meta['page']['lh_source'] == 'default'
+        assert doc.meta['page']['text_lines'] == 55
+
+def test_page_geometry_ls_recorded_but_never_divides_capacity():
+    # the trap the manual defuses: line-spacing blanks are LITERAL lines in
+    # the file ("when you use line spacing, the blank lines become part of
+    # the file" -- WS7 manual, "Line Spacing"), so the body already carries
+    # them; dividing capacity by .ls would double-count.
+    doc = core.parse_ws(b'.LS 2' + HARD + b'x' + HARD)
+    page = doc.meta['page']
+    assert page['ls'] == 2.0 and page['ls_source'] == 'file'
+    assert page['text_lines'] == 55                       # unchanged
+
+def test_page_geometry_ls_out_of_range_rejected():
+    # spec: "a line spacing of between 1 and 9"
+    for arg in (b'.LS 0', b'.LS 12'):
+        doc = core.parse_ws(arg + HARD + b'x' + HARD)
+        assert doc.meta['page']['ls'] == 1.0
+        assert doc.meta['page']['ls_source'] == 'default'
+
+def test_page_geometry_hm_fm_parsed_but_reserve_no_space():
+    # header/footer margins position header and footer INSIDE .mt/.mb
+    # (".MT ... The header is printed within this margin") -- parsed with
+    # provenance for --diagnose, never subtracted from capacity
+    doc = core.parse_ws(b'.HM 1' + HARD + b'.FM 3' + HARD + b'x' + HARD)
+    page = doc.meta['page']
+    assert page['hm_lines'] == 1.0 and page['hm_source'] == 'file'
+    assert page['fm_lines'] == 3.0 and page['fm_source'] == 'file'
+    assert page['text_lines'] == 55                       # unchanged
+
+def test_page_geometry_absurd_margins_clamp_not_crash():
+    # margins that eat the whole page (garbage in a misdetected binary)
+    # degrade to a 1-line model, never zero/negative/crash
+    doc = core.parse_ws(b'.PL 12' + HARD + b'.MT 40' + HARD + b'.MB 40' + HARD + b'x' + HARD)
+    assert doc.meta['page']['text_lines'] == 1
+
+def test_pdf_printed_top_offset_follows_mt():
+    # the default .mt 3 IS the 36pt top this emitter always used; a bigger
+    # .mt moves the text start down in real points (1 line = 12pt at 6 LPI)
+    from ctrlkd.pdf import _printed_top
+    assert _printed_top(core.parse_ws(b'x' + HARD)) == 36
+    assert _printed_top(core.parse_ws(b'.MT 6' + HARD + b'x' + HARD)) == 72
+
+def test_pdf_printed_lead_follows_lh():
+    # .lh 8 IS the 12pt lead; .lh 16 prints double-spaced at 24pt
+    from ctrlkd.pdf import _printed_lead
+    assert _printed_lead(core.parse_ws(b'x' + HARD)) == 12.0
+    assert _printed_lead(core.parse_ws(b'.LH 16' + HARD + b'x' + HARD)) == 24.0
+
+def test_pdf_output_bytes_carry_mt_top_and_lh_lead():
+    # end-to-end: the geometry must reach the CONTENT STREAM, not just the
+    # helpers -- .mt 6 starts text at 72pt from the top, .lh 16 spaces
+    # baselines 24pt apart. Read the Td y-coordinates back out of the bytes.
+    import re
+    from ctrlkd.pdf import emit_pdf
+    data = (b'.MT 6' + HARD + b'.LH 16' + HARD +
+            b'Line one.' + HARD + b'Line two.' + HARD + b'Line three.' + HARD)
+    pdf = emit_pdf(core.parse_ws(data), mode='printed')
+    ys = [float(m) for m in re.findall(rb'[\d.]+ ([\d.]+) Td', pdf)]
+    assert ys[0] == 792 - 72 - 12                  # top from .mt, not fixed 36
+    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
+    # smaller could split a physical page the printer produced whole
+    from ctrlkd.pdf import _printed_cap, _printed_top
+    doc = core.parse_printstream(b'line one\r\nline two\r\n')
+    assert _printed_cap(doc) == 66
+    assert _printed_top(doc) == 36                        # fixed: not .mt-derived
+
 # ---------------------------------------------------------------- small parser additions
 
 def _ws7_tab(size_hmi, tab_type_byte, tenths=0):
@@ -874,6 +1075,8 @@ def test_pdf_printed_footnote_splits_with_continuation_and_loses_nothing():
     from ctrlkd.pdf import _doc_to_pagelines, CONTINUATION_TEXT
     words = [f'word{i:03d}' for i in range(80)]
     data = (b'.PL 18' + HARD +                    # a small page: forces a split
+            b'.MT 3' + HARD + b'.MB 3' + HARD +   # stated so capacity is 18-3-3=12,
+                                                   # not left to the 3+8 defaults
             ws7_block(0x00) +
             b'First body line has the note' + ws7_note(0x03, ' '.join(words).encode(), number=0) +
             b' right here.' + HARD +
@@ -1041,7 +1244,9 @@ def test_pdf_printed_no_page_ever_exceeds_its_capacity():
     # once even one body line has been placed on a terminal page.
     from ctrlkd.pdf import _doc_to_pagelines, _printed_cap
     words = [f'word{i:03d}' for i in range(60)]
-    data = (b'.PL 12' + HARD + ws7_block(0x00) +
+    data = (b'.PL 12' + HARD +
+            b'.MT 3' + HARD + b'.MB 3' + HARD +   # capacity 12-3-3=6, margins stated
+            ws7_block(0x00) +
             b'Only line has a note' + ws7_note(0x03, ' '.join(words).encode(), number=0) +
             b' here.' + HARD)
     doc = core.parse_ws(data)