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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ctrl-kd
-Version: 4.8.0
+Version: 4.8.1
 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.8.0 → ctrl_kd-4.8.1/src/ctrl_kd.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ctrl-kd
-Version: 4.8.0
+Version: 4.8.1
 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.8.0 → ctrl_kd-4.8.1}/src/ctrl_kd.egg-info/SOURCES.txt

@@ -98,6 +98,8 @@ tests/test_screenplay_rendering.py
 tests/test_sentence_spacing_n9.py
 tests/test_structural_checks.py
 tests/test_style_leading.py
+tests/test_style_strikeout_runs_until_cleared.py
+tests/test_style_symbol_map_resolved_face.py
 tests/test_symbol_span_graphic_chars.py
 tests/test_trailing_pa_break.py
 tests/test_verse_quote_couplet.py

{ctrl_kd-4.8.0 → ctrl_kd-4.8.1}/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.8.0'
+__version__ = '4.8.1'

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

@@ -5226,6 +5226,26 @@ def _symmetric_blocks(data: bytes, encoding: str, raw_out=None):
             includes, driver[0], sorted(shift_runs), marks, header,
             pcl_programs)
 
+# The style attributes that KEEP RUNNING past the paragraph that turned them
+# on, until a later style's own attrs_OFF word clears them (ruling 2026-09-16,
+# WordStar-Feature-Decision-Register, "Style-library strikeout runs until a
+# style clears it").
+#
+# WSFORMAT.TXT states the inherit rule for the attribute words as a whole --
+# "if both corresponding bits are off, then the attribute is inherited from
+# the current state" -- but the only attribute the WS7 LaserJet captures can
+# actually DEMONSTRATE it for is strikeout: in every corpus document that
+# turns bold, underline or italic on in a style, the next style used sets
+# that same bit in its own attrs_off word, so an inheriting model and a
+# reset-per-paragraph model produce identical pages and the captures cannot
+# choose between them. Strikeout is the one bit no corpus style ever clears,
+# which is exactly why its run is visible (NOVEL.WS: 954 overstrike dash rows
+# across all 52 captured pages). So the rule is applied to strikeout only,
+# on measured evidence, and the wider question is left open rather than
+# guessed. Add a bit here only with a capture that shows it.
+STICKY_STYLE_ATTRS = ((0x01, 'strike'),)
+
+
 def _parse_style_library(raw: bytes, base: int, encoding: str = 'cp437'):
     """The paragraph style library at file-absolute offset `base`.
 
@@ -6501,8 +6521,34 @@ def parse_ws(data: bytes, encoding: str = 'cp437') -> Document:
                     # value forward, not reset to nothing -- style_fmt.clear()
                     # below must not lose it.
                     _prev_vmi = style_fmt.get('line_height_vmi')
+                    # Ruling 2026-09-16 ("Style-library strikeout runs until a
+                    # style clears it"): an attribute a style turns ON stays on
+                    # past that paragraph. WSFORMAT.TXT's own rule for the two
+                    # attribute words is "if both corresponding bits are off,
+                    # then the attribute is inherited from the current state" --
+                    # so only a later style that sets the bit in its attrs_OFF
+                    # word ends the run. Real WS7 agrees: NOVEL.WS's H3 sets
+                    # strikeout on the title page and nothing in that file's
+                    # library ever clears it, and the LaserJet capture prints
+                    # the overstrike dash row on all 52 pages.
+                    _prev_sticky = style_fmt.get('sticky_attrs', frozenset())
                     style_fmt.clear()
                     style_fmt['style_id'] = slot
+                    _sticky = set(_prev_sticky)
+                    if entry is not None:
+                        _on, _off = entry.get('attrs_on') or 0, entry.get('attrs_off') or 0
+                        for _bit, _tag in STICKY_STYLE_ATTRS:
+                            if _on & _bit:
+                                _sticky.add(_tag)
+                            elif _off & _bit:
+                                _sticky.discard(_tag)
+                    style_fmt['sticky_attrs'] = frozenset(_sticky)
+                    if _sticky:
+                        # Also for an UNRESOLVABLE handle (a 0x03xx editing-temp
+                        # pool entry, or a slot this file's library doesn't
+                        # carry): it declares neither word, so every attribute
+                        # inherits, including the running one.
+                        style_fmt['attrs'] = frozenset(_sticky)
                     if entry is not None:
                         style_fmt['style_name'] = entry['name']
                         style_fmt['heading'] = _style_heading_level(entry['name'])
@@ -6522,8 +6568,11 @@ def parse_ws(data: bytes, encoding: str = 'cp437') -> Document:
                                 # HMI 1/1800in -> print columns at 10 CPI,
                                 # the unit .lm/.rm already use (180 = 1 col)
                                 style_fmt[dst_k] = round(hmi / 180)
-                        if entry.get('attrs'):
-                            style_fmt['attrs'] = entry['attrs']
+                        if entry.get('attrs') or _sticky:
+                            # The style's own ON bits, plus every sticky
+                            # attribute still running from an earlier style.
+                            style_fmt['attrs'] = frozenset(
+                                entry.get('attrs') or ()) | style_fmt['sticky_attrs']
                         # Register C5: the style's own declared colour index
                         # (0-15, WSFORMAT's fixed CGA/EGA palette -- same
                         # space as an inline type-1 colour change). `is not

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

@@ -1467,6 +1467,36 @@ def _html_colour_used(doc):
     return sorted(used)
 
 
+# A style attribute a block is RUNNING UNDER without its own style record
+# declaring it -- `core.STICKY_STYLE_ATTRS`, ruling 2026-09-16 ("Style-library
+# strikeout runs until a style clears it"). HTML is the one emitter whose
+# paragraph-level attributes ride a CSS class keyed to the STYLE SLOT rather
+# than to the block, so an attribute inherited from an EARLIER style has
+# nowhere to land on this slot's own rule; it gets a class of its own instead.
+# Every other emitter merges `block.style_attrs` into its runs
+# (`core.effective_span_styles`) and picks the same attribute up for free.
+# The property text is the same table `_style_css` writes for a style's own
+# declared attributes, so the two paths cannot drift.
+_INHERITED_ATTR_CSS = {
+    'b': 'font-weight:bold',
+    'i': 'font-style:italic',
+    'u': 'text-decoration:underline',
+    'strike': 'text-decoration:line-through',
+    'sub': 'vertical-align:sub;font-size:smaller',
+    'sup': 'vertical-align:super;font-size:smaller',
+}
+
+
+def _style_own_attrs(doc):
+    """slot -> the attributes that slot's OWN record turns on."""
+    return {e['slot']: e.get('attrs') or frozenset() for e in doc.styles}
+
+
+def _inherited_attrs(b, own):
+    """The attributes on this block that its own style record does not declare."""
+    return b.style_attrs - own.get(b.style_id, frozenset())
+
+
 def _style_css(doc, printed=True, inline_styling=True):
     """CSS rules derived from the style records themselves -- a PASS-THROUGH
     of the file's own data (Jon, 2026-08-04: never hardwire a style name to
@@ -1570,6 +1600,14 @@ def _style_css(doc, printed=True, inline_styling=True):
         for n in _html_colour_used(doc):
             rules.append('.ws-colour-%d { color:#%02x%02x%02x }'
                          % ((n,) + _CGA_PALETTE[n % 16]))
+    # One rule per attribute some block actually inherited -- never a fixed
+    # six, so a document with no running attribute gets no extra CSS at all.
+    own = _style_own_attrs(doc)
+    inherited = set()
+    for b in doc.blocks:
+        inherited |= _inherited_attrs(b, own)
+    for tag in sorted(inherited & set(_INHERITED_ATTR_CSS)):
+        rules.append('.ws-inherit-%s { %s }' % (tag, _INHERITED_ATTR_CSS[tag]))
     return '\n'.join(rules)
 
 
@@ -1865,6 +1903,7 @@ def emit_html(doc, mode='printed', title='', notes=DEFAULT_NOTE_KINDS,
     pix_map = {r.index: r for r in (pix_results or [])}
     keep = frozenset(notes)
     style_class = {}
+    style_own = _style_own_attrs(doc)
     if styles:
         style_class = {s['slot']: ' class="%s"' % _style_slug(s)
                        for s in doc.styles}
@@ -1993,6 +2032,13 @@ def emit_html(doc, mode='printed', title='', notes=DEFAULT_NOTE_KINDS,
             parts.append('<hr class="pb">')
             continue
         cls = style_class.get(b.style_id, '')
+        if styles:
+            # An attribute still running from an EARLIER style (ruling
+            # 2026-09-16): the slot's own rule cannot carry it. See
+            # `_INHERITED_ATTR_CSS`.
+            for tag in sorted(_inherited_attrs(b, style_own)
+                              & set(_INHERITED_ATTR_CSS)):
+                cls = _add_html_class(cls, 'ws-inherit-' + tag)
         keep_para, keepn_para = keep_plan.get(bi, (False, False))
         if keep_para:
             cls = _add_html_class(cls, 'ws-keep')

{ctrl_kd-4.8.0 → ctrl_kd-4.8.1}/src/ctrlkd/symbolmap.py

@@ -134,19 +134,56 @@ def transliterate(text, kind):
         return ''.join(_dingbat(c) for c in text)
     return text
 
+# Typestyle numbers whose NAME announces a non-text face: the table's own
+# word for the glyph repertoire, not a typeface a sentence can be set in.
+# 82 (ZapfDingbats) and 192 (Symbol) are matched by name above and never
+# reach this set. Numbers, not substrings: 'Pica' contains 'pi' and
+# 'Presentations' contains 'ps' -- a substring test on this table is a trap.
+NON_TEXT_TYPESTYLES = frozenset({
+    33,    # Borders
+    68,    # LucidaMath
+    143,   # Math-7 (HPLJ)
+    144,   # Math-8 (HPLJ)
+    166,   # PI
+    188,   # Math
+    234,   # TD Logos
+    244,   # Greek (PS (Universal Greek))
+})
+
+
 def font_translit_kind(font_entry):
-    """The transliteration a font run needs, from the block's own symbol-map
-    bits first, typestyle name as fallback. None = ordinary text font."""
+    """The transliteration a font run needs, from the typestyle NAME first and
+    the block's own symbol-map bits only as the fallback for a face the name
+    table cannot resolve. None = ordinary text font."""
     if not font_entry:
         return None
     # NAME first: it is the specific signal. The coarse symbol-map bits can
     # say 'math' for both faces (PS.TST's Dingbats row transliterated to
-    # Greek until this ordering); bits remain the fallback for unnamed fonts.
+    # Greek until this ordering).
     name = (font_entry.get('typestyle_name') or '').lower()
     if name.startswith('symbol'):
         return 'math'
     if 'dingbat' in name:
         return 'symbols'
+    # A RESOLVED ORDINARY FACE WINS over the character-set bits (ruling
+    # 2026-09-16). WordStar's symbol_map bits say which upper-128 (0x80-0xFF)
+    # table the EXTENDED characters of a run use; they were never a
+    # "replace the alphabet" switch. NOVEL.WS's own 'MS Front Pages' /
+    # 'Font: Normal' styles carry typestyle 3 (Courier) with the math bits
+    # set, and ten pages of ordinary English prose were being redirected
+    # through Adobe Symbol's encoding, so every Latin letter came out as
+    # the Greek letter sitting at its keyboard position. Real WS7's
+    # LaserJet output prints those pages as plain readable Courier.
+    # Characters that genuinely have no home in the body face are still
+    # picked up one at a time by the per-character
+    # fallback (`char_translit_kind`, pdf.py's `_symbol_fallback_split`),
+    # which is what that mechanism was built for.
+    #
+    # The bits stay the fallback for the case the docstring always claimed:
+    # a face the 245-entry name table cannot resolve, and the handful of
+    # named faces that are themselves non-text repertoires.
+    if name and font_entry.get('typestyle_number') not in NON_TEXT_TYPESTYLES:
+        return None
     sm = font_entry.get('symbol_map')
     if sm in ('math', 'symbols'):
         return sm

ctrl_kd-4.8.1/tests/test_style_strikeout_runs_until_cleared.py

@@ -0,0 +1,297 @@
+"""A STYLE'S STRIKEOUT RUNS UNTIL A STYLE CLEARS IT (ruling 2026-09-16).
+
+A WS7 paragraph style record carries TWO attribute words: `attrs_on` at byte
+91 and `attrs_off` at byte 93. WSFORMAT.TXT states the model exactly:
+
+    Bits set in the first word indicate those attributes are explicitly set
+    to the on state.  Bits set in the second word indicate those attributes
+    are explicitly set off.  If both corresponding bits are off, then the
+    attribute is inherited from the current state.
+
+So a style that turns strikeout on (bit 0x01) starts a run that only ENDS at
+a later style whose own `attrs_off` sets the same bit. Both engines used to
+reset every attribute at each style switch, which ended the run with the
+styled paragraph itself.
+
+Real WS7 settles it. A manuscript in the Sawyer archive selects a heading
+style carrying `attrs_on = 0x41` (strikeout | bold) on its title page, and no
+other style in that file's library ever sets 0x01 in its `attrs_off` -- not
+even the style the manuscript body itself is set in. Its captured LaserJet
+print strikes through all 52 pages: WS7 renders strikeout by reprinting a row
+of hyphens over the same baseline (a daisy-wheel overstrike the LaserJet
+driver kept), and that dash row appears on every page of the capture.
+
+SCOPE, and the question deliberately left open: this is applied to strikeout
+ONLY (`core.STICKY_STYLE_ATTRS`). WSFORMAT's inherit sentence is written for
+the attribute words as a whole, but in every corpus document that turns bold,
+underline or italic on in a style, the next style used sets that same bit in
+its own `attrs_off` word -- so an inheriting model and a reset-per-paragraph
+model print identical pages and the captures cannot choose between them.
+Strikeout is the one bit no corpus style ever clears, which is exactly why
+its run is visible. The last test here pins that narrow scope so widening it
+is a deliberate act with new evidence behind it, not a drift.
+
+Synthetic fixtures only -- style libraries are built byte by byte below.
+"""
+import re
+import zlib
+
+import pytest
+
+from ctrlkd import core, emit, emit_layout, pdf
+
+HARD = b'\x0d\x0a'
+
+# WSFORMAT's own attribute bits (core.py's `entry['attrs']` decode).
+STRIKE, DOUBLE, UNDERLINE, SUB, SUPER, BOLD, ITALIC = (
+    0x01, 0x02, 0x08, 0x10, 0x20, 0x40, 0x80)
+# The real corpus shape: an `attrs_off` word that clears everything EXCEPT
+# strikeout (and the spec's own unlabelled 0x04 bit).
+CLEARS_ALL_BUT_STRIKE = 0xFA
+CLEARS_EVERYTHING = 0xFB
+
+
+def ws7_block(cmd, content=b''):
+    count = (len(content) + 4).to_bytes(2, 'little')
+    return b'\x1d' + count + bytes([cmd]) + content + count + b'\x1d'
+
+
+def style_record(attrs_on=0, attrs_off=0):
+    """A 102-byte style record with every field at its inherit sentinel except
+    the two attribute words. Same construction as test_modern_lint.py's own
+    `_style_record`, extended with `attrs_off` (bytes 93-94), which is the
+    field this behaviour turns on."""
+    rec = bytearray(102)
+    rec[0:2] = (0xFFFF).to_bytes(2, 'little')          # font word0: inherited
+    rec[10:12] = (1800).to_bytes(2, 'little')          # left margin HMI
+    rec[12:14] = (0xFFFE).to_bytes(2, 'little')        # right margin: inherited
+    rec[14:16] = (0xFFFE).to_bytes(2, 'little')        # para margin: inherited
+    rec[18] = rec[19] = 0xFF                           # tab counts: inherited
+    for k in range(32):
+        rec[20 + 2 * k:22 + 2 * k] = (0xBEEF).to_bytes(2, 'little')
+    rec[86] = 0                                        # justification: left
+    rec[87] = 1                                        # word wrap on
+    rec[88:90] = (0xFFFF).to_bytes(2, 'little')        # line height: inherited
+    rec[90] = 0xFF                                     # line spacing: inherited
+    rec[91:93] = attrs_on.to_bytes(2, 'little')
+    rec[93:95] = attrs_off.to_bytes(2, 'little')
+    rec[95] = 0xFF                                     # colour: inherited
+    return bytes(rec)
+
+
+def style_library(entries):
+    """`entries` = [(name, record_or_None)]."""
+    n = len(entries)
+    items, records = b'', b''
+    rec_base = 13 + 5 + 33 * n
+    for name, rec in entries:
+        nm = name.encode('cp437').ljust(24)
+        if rec is None:
+            items += nm + b'\x00' + bytes(4) + bytes(4)
+        else:
+            items += nm + b'\x02' + bytes(4) + (rec_base + len(records)).to_bytes(4, 'little')
+            records += rec
+    head = (b'\x1a\x55' + (1).to_bytes(2, 'little') + b'\x01'
+            + n.to_bytes(2, 'little') + (102).to_bytes(2, 'little')
+            + (13).to_bytes(4, 'little'))
+    return head + bytes([n]) + bytes(4) + items + records
+
+
+def select(slot):
+    """One 0x11 paragraph-style-select block for `slot` of this file's pool."""
+    return ws7_block(0x11, (0x0200 | slot).to_bytes(2, 'little')
+                     + (0x0201).to_bytes(2, 'little')
+                     + (0x0300).to_bytes(2, 'little')
+                     + (0x0201).to_bytes(2, 'little'))
+
+
+def build(entries, body):
+    header = ws7_block(0x00, bytes([0x70]) + bytes(11) + bytes(4))
+    doc_body = header + body
+    base = ((len(doc_body) + 127) // 128) * 128
+    data = bytearray(doc_body.ljust(base, b'\x1a')) + style_library(entries)
+    data[4 + 12:4 + 16] = base.to_bytes(4, 'little')
+    return core.parse_ws(bytes(data))
+
+
+# ------------------------------------------------------------- the fixtures
+
+PLAIN_TEXT = b'Plain paragraph before any styled one at all.'
+STRUCK_TEXT = b'The styled heading that turns strikeout on.'
+AFTER_TEXT = b'The following paragraph, whose own style never clears it.'
+CLEARED_TEXT = b'The paragraph whose style does clear it again.'
+
+LIBRARY = [
+    ('Plain', style_record(attrs_on=0, attrs_off=CLEARS_ALL_BUT_STRIKE)),
+    ('Struck', style_record(attrs_on=STRIKE | BOLD,
+                            attrs_off=CLEARS_ALL_BUT_STRIKE & ~BOLD)),
+    ('Clears', style_record(attrs_on=0, attrs_off=CLEARS_EVERYTHING)),
+]
+SLOT_PLAIN, SLOT_STRUCK, SLOT_CLEARS = 0, 1, 2
+
+
+def run_doc():
+    """Plain -> Struck -> Plain (inherits) -> Clears (ends the run)."""
+    return build(LIBRARY,
+                 select(SLOT_PLAIN) + PLAIN_TEXT + HARD + HARD +
+                 select(SLOT_STRUCK) + STRUCK_TEXT + HARD + HARD +
+                 select(SLOT_PLAIN) + AFTER_TEXT + HARD + HARD +
+                 select(SLOT_CLEARS) + CLEARED_TEXT + HARD)
+
+
+def block_for(doc, text):
+    wanted = text.decode('cp437')
+    for b in doc.blocks:
+        joined = ''.join(sp.text for ln in b.lines for sp in ln.spans)
+        if wanted[:20] in joined:
+            return b
+    raise AssertionError(f'no block carrying {wanted[:20]!r}')
+
+
+def decoded_streams(pdf_bytes):
+    out = []
+    for m in re.finditer(rb'stream\r?\n(.*?)\r?\nendstream', pdf_bytes, re.S):
+        try:
+            out.append(zlib.decompress(m[1]))
+        except zlib.error:
+            out.append(m[1])
+    return b'\n'.join(out)
+
+
+# --------------------------------------------------------------- the model
+
+def test_the_run_starts_continues_and_ends_on_the_blocks_themselves():
+    doc = run_doc()
+    assert 'strike' not in block_for(doc, PLAIN_TEXT).style_attrs, \
+        'strikeout before the style that turns it on'
+    assert 'strike' in block_for(doc, STRUCK_TEXT).style_attrs, \
+        'the style that turns strikeout on did not'
+    assert 'strike' in block_for(doc, AFTER_TEXT).style_attrs, \
+        'the run stopped at the styled paragraph instead of continuing'
+    assert 'strike' not in block_for(doc, CLEARED_TEXT).style_attrs, \
+        'a style setting 0x01 in attrs_off did not end the run'
+
+
+def test_an_unresolvable_style_handle_inherits_rather_than_resets():
+    """A 0x03xx editing-temp handle declares neither attribute word, so every
+    attribute inherits -- the same sentence of the spec, applied to the case
+    where there is no record to read."""
+    body = (select(SLOT_STRUCK) + STRUCK_TEXT + HARD + HARD +
+            ws7_block(0x11, (0x0301).to_bytes(2, 'little') * 4) +
+            AFTER_TEXT + HARD)
+    doc = build(LIBRARY, body)
+    assert 'strike' in block_for(doc, AFTER_TEXT).style_attrs
+
+
+# ------------------------------------------- one rule, every output format
+
+def fmt_outputs(doc, mode):
+    return {
+        'text': emit.emit_text(doc, mode),
+        'markdown': emit.emit_markdown(doc, mode),
+        'html': emit.emit_html(doc, mode),
+        'rtf': emit.emit_rtf(doc, mode),
+        'layout': emit_layout(doc, mode),
+    }
+
+
+def rtf_group_for(body, needle):
+    """The `{...}` character-run group that carries `needle` -- RTF's own
+    scope for a run's attributes, so the assertion reads exactly one run."""
+    end = body.index(needle)
+    start = body.rindex('{', 0, end)
+    return body[start:body.index('}', end) + 1]
+
+
+@pytest.mark.parametrize('mode', ['printed', 'modern'])
+def test_rtf_marks_the_inherited_paragraph_struck(mode):
+    out = fmt_outputs(run_doc(), mode)['rtf']
+    body = out.decode('cp1252', 'replace') if isinstance(out, bytes) else out
+    assert '\\strike' in rtf_group_for(body, 'never clears'), \
+        f'{mode}: the inherited paragraph carries no \\strike'
+    assert '\\strike' not in rtf_group_for(body, 'does clear it again'), \
+        f'{mode}: the run did not end at the clearing style'
+
+
+def html_tag_for(body, needle):
+    """The opening tag of the element carrying `needle`."""
+    end = body.index(needle)
+    start = body.rindex('<', 0, end)
+    return body[start:body.index('>', start) + 1]
+
+
+@pytest.mark.parametrize('mode', ['printed', 'modern'])
+def test_html_marks_the_inherited_paragraph_struck(mode):
+    out = fmt_outputs(run_doc(), mode)['html']
+    body = out.decode('utf-8') if isinstance(out, bytes) else out
+    # HTML's paragraph attributes ride a CSS class keyed to the STYLE SLOT, so
+    # an attribute inherited from an EARLIER style needs its own class
+    # (`emit._INHERITED_ATTR_CSS`) -- the slot's own rule cannot carry it.
+    assert '.ws-inherit-strike { text-decoration:line-through }' in body, \
+        f'{mode}: no CSS rule for the inherited run'
+    assert 'ws-inherit-strike' in html_tag_for(body, 'never clears'), \
+        f'{mode}: the inherited paragraph is not marked struck'
+    assert 'ws-inherit-strike' not in html_tag_for(body, 'does clear it again'), \
+        f'{mode}: the run did not end at the clearing style'
+
+
+@pytest.mark.parametrize('mode', ['printed', 'modern'])
+def test_layout_json_carries_the_inherited_run(mode):
+    out = fmt_outputs(run_doc(), mode)['layout']
+    body = out.decode('utf-8') if isinstance(out, bytes) else out
+    assert body.count('"strike"') >= 2, \
+        f'{mode}: fewer struck runs than the styled paragraph plus the one it runs into'
+
+
+def test_markdown_modern_marks_the_inherited_paragraph_struck():
+    """Modern Markdown carries character attributes; PRINTED Markdown is a
+    verbatim monospace page inside a fence and has no inline markers at all,
+    in either behaviour -- there is nothing for this rule to change there."""
+    out = fmt_outputs(run_doc(), 'modern')['markdown']
+    body = out.decode('utf-8') if isinstance(out, bytes) else out
+    line = next(l for l in body.splitlines() if 'never clears' in l)
+    assert line.strip().startswith('~~'), f'no strikethrough markers: {line!r}'
+
+
+@pytest.mark.parametrize('mode', ['printed', 'modern'])
+def test_pdf_draws_a_rule_over_the_inherited_paragraph(mode):
+    """Strikeout in PDF is a stroked rule over the run (`pdf.py`'s own
+    `... m ... l S`). More rules are drawn when the run continues than when
+    the very next style ends it."""
+    running = decoded_streams(pdf.emit_pdf(run_doc(), mode=mode))
+    ended = build(LIBRARY,
+                  select(SLOT_STRUCK) + STRUCK_TEXT + HARD + HARD +
+                  select(SLOT_CLEARS) + AFTER_TEXT + HARD)
+    ended_ops = decoded_streams(pdf.emit_pdf(ended, mode=mode))
+    assert running.count(b' l S') > ended_ops.count(b' l S'), \
+        f'{mode}: the continuing run drew no more rules than the cleared one'
+
+
+def test_text_output_is_unaffected_and_still_carries_the_words():
+    """Plain text has no representation for strikeout in either behaviour --
+    named here so the format is not silently missing from the list above."""
+    out = fmt_outputs(run_doc(), 'printed')['text']
+    body = out.decode('utf-8') if isinstance(out, bytes) else out
+    for sample in (PLAIN_TEXT, STRUCK_TEXT, AFTER_TEXT, CLEARED_TEXT):
+        assert sample.decode('cp437')[:20] in body
+
+
+# ------------------------------------------------------------ the scope pin
+
+def test_only_strikeout_is_sticky():
+    """The narrow scope, pinned. Bold here is turned on by one style and never
+    cleared by the next one's `attrs_off`, and it still must NOT carry: no WS7
+    capture in the corpus can show whether real WordStar would carry it, so
+    the rule is not extended to bold, underline or italic on a guess. Widening
+    `core.STICKY_STYLE_ATTRS` means finding a capture that settles it."""
+    assert core.STICKY_STYLE_ATTRS == ((0x01, 'strike'),)
+    library = [
+        ('Bold', style_record(attrs_on=BOLD, attrs_off=0)),
+        ('Next', style_record(attrs_on=0, attrs_off=0)),
+    ]
+    doc = build(library,
+                select(0) + STRUCK_TEXT + HARD + HARD +
+                select(1) + AFTER_TEXT + HARD)
+    assert 'b' in block_for(doc, STRUCK_TEXT).style_attrs
+    assert 'b' not in block_for(doc, AFTER_TEXT).style_attrs, \
+        'bold carried past its own paragraph -- the scope was widened silently'

ctrl_kd-4.8.1/tests/test_style_symbol_map_resolved_face.py

@@ -0,0 +1,173 @@
+"""A RESOLVED ORDINARY TYPEFACE BEATS THE CHARACTER-SET BITS (ruling 2026-09-16).
+
+A WS5+ font record carries a typestyle word whose low nine bits name a
+typeface out of WSFORMAT's own 245-entry table and whose bits 12-13 pick one
+of four upper-128 character sets (cp437, cp850, math, symbols). The two are
+independent fields. `font_translit_kind` used to let the character-set bits
+overrule ANY name that did not itself say "symbol" or "dingbat", so a font
+record reading "Courier, math character set" redirected its whole run through
+Adobe Symbol's encoding -- and every ordinary Latin letter came out as the
+Greek letter sitting at its keyboard position.
+
+That is a real corpus record, not a hypothetical: the front-matter paragraph
+styles of a WS7 manuscript in the Sawyer archive carry typestyle word 0x6603
+(number 3 = Courier, letter-quality, symbol_map = math) and ten pages of
+ordinary English prose rendered as Greek in PDF, RTF, Markdown and the layout
+JSON alike. Real WS7's own LaserJet output prints those pages as plain
+readable Courier.
+
+THE RULE: the character-set bits are the fallback for a face the name table
+cannot resolve (and for the handful of named faces that are themselves
+non-text repertoires -- Symbol, ZapfDingbats, Math, PI, Greek...). A resolved
+ordinary face wins. Characters that genuinely have no home in the body face
+are still rescued one at a time by the per-character fallback
+(`char_translit_kind`), which is what that mechanism was built for.
+
+Synthetic fixtures only -- the typestyle words below are transcribed into
+constructed bytes, no corpus file is read.
+"""
+import re
+import zlib
+
+import pytest
+
+from ctrlkd import core, emit, emit_layout, pdf
+from ctrlkd.symbolmap import font_translit_kind
+
+HARD = b'\x0d\x0a'
+PROSE = b'If you choose to depict the physicist on the cover'
+# Long enough that the WS5+ text body is unambiguous -- a two-word document
+# does not exercise the parse path this test is about.
+GREEKABLE = b'alpha beta gamma alpha beta gamma alpha beta gamma'
+
+# typestyle words, built field by field from core._font_entry's own bit table:
+#   bits 0-8   typeface number (WSFORMAT's name table)
+#   bits 12-13 character set: 0 cp437, 1 cp850, 2 math, 3 symbols
+#   bit 14     letter quality
+#   bit 15     proportional
+MATH_BITS = 2 << 12
+COURIER_MATH = 3 | MATH_BITS | 0x4000          # 0x6603, the real corpus word
+SYMBOL_MATH = 192 | MATH_BITS | 0x4000         # a genuine Symbol face
+DINGBATS_MATH = 82 | MATH_BITS | 0x4000        # ZapfDingbats, bits say 'math'
+UNNAMED_MATH = 300 | MATH_BITS | 0x4000        # past the 245-entry name table
+
+
+def ws7_block(cmd, content=b''):
+    count = (len(content) + 4).to_bytes(2, 'little')
+    return b'\x1d' + count + bytes([cmd]) + content + count + b'\x1d'
+
+
+def font_block(style, w=180, h=240):
+    """One type-2 Font symmetric block: width (HMI), height (VMI), typestyle,
+    then three zeroed 'previous' words."""
+    content = (w.to_bytes(2, 'little') + h.to_bytes(2, 'little') +
+               style.to_bytes(2, 'little') + b'\x00' * 6)
+    return ws7_block(0x02, content)
+
+
+def doc_in_face(style, text=PROSE):
+    return core.parse_ws(ws7_block(0x00) + font_block(style) + text + HARD)
+
+
+def decoded_streams(pdf_bytes):
+    out = []
+    for m in re.finditer(rb'stream\r?\n(.*?)\r?\nendstream', pdf_bytes, re.S):
+        try:
+            out.append(zlib.decompress(m[1]))
+        except zlib.error:
+            out.append(m[1])
+    return b'\n'.join(out)
+
+
+def symbol_resource_names(pdf_bytes):
+    obj_font = {int(m[1]): m[2] for m in
+                re.finditer(rb'(\d+) 0 obj\s*<< /Type /Font /Subtype /Type1 '
+                            rb'/BaseFont /(\S+)', pdf_bytes)}
+    return {m[1] for m in re.finditer(rb'/(F\d+) (\d+) 0 R', pdf_bytes)
+            if obj_font.get(int(m[2])) in (b'Symbol', b'ZapfDingbats')}
+
+
+# --------------------------------------------------------------- the verdict
+
+def test_resolved_ordinary_face_ignores_the_character_set_bits():
+    entry = {'typestyle_name': 'Courier', 'typestyle_number': 3,
+             'symbol_map': 'math'}
+    assert font_translit_kind(entry) is None
+
+
+def test_a_named_symbol_face_still_transliterates():
+    """The name is still the specific signal -- unchanged, and the reason the
+    name is read BEFORE the bits (a Dingbats row whose coarse bits read 'math'
+    must transliterate as Dingbats, not as Greek)."""
+    assert font_translit_kind({'typestyle_name': 'Symbol',
+                               'typestyle_number': 192,
+                               'symbol_map': 'math'}) == 'math'
+    assert font_translit_kind({'typestyle_name': 'ZapfDingbats',
+                               'typestyle_number': 82,
+                               'symbol_map': 'math'}) == 'symbols'
+
+
+def test_an_unresolved_face_still_falls_back_to_the_bits():
+    """The fallback the function's docstring always claimed: a typeface number
+    the 245-entry table does not carry has no name to prefer, so the
+    character-set bits are all there is."""
+    assert font_translit_kind({'typestyle_name': None,
+                               'typestyle_number': 300,
+                               'symbol_map': 'math'}) == 'math'
+
+
+def test_a_named_non_text_repertoire_still_falls_back_to_the_bits():
+    """'Math', 'PI' and 'Greek' are names for a glyph repertoire, not for a
+    typeface a sentence can be set in -- they are not 'ordinary faces' and do
+    not win over the bits."""
+    for number, name in ((188, 'Math'), (166, 'PI'),
+                         (244, 'Greek (PS (Universal Greek))')):
+        assert font_translit_kind({'typestyle_name': name,
+                                   'typestyle_number': number,
+                                   'symbol_map': 'math'}) == 'math', name
+
+
+# ------------------------------------------------- one rule, every emitter
+
+@pytest.mark.parametrize('mode', ['printed', 'modern'])
+def test_courier_math_prose_stays_latin_in_every_text_format(mode):
+    """Every emitter reads the SAME verdict, so one rule fixes all of them at
+    once. Before the ruling each of these carried the Greek transliteration."""
+    doc = doc_in_face(COURIER_MATH)
+    for name, out in (
+            ('text', emit.emit_text(doc, mode)),
+            ('markdown', emit.emit_markdown(doc, mode)),
+            ('html', emit.emit_html(doc, mode)),
+            ('rtf', emit.emit_rtf(doc, mode)),
+            ('layout', emit_layout(doc, mode))):
+        text = out.decode('utf-8', 'replace') if isinstance(out, bytes) else out
+        assert 'If you choose' in text, f'{name}/{mode}: prose is not Latin'
+        assert not any('\u0370' <= c <= '\u03ff' for c in text), \
+            f'{name}/{mode}: a Greek code point reached the output'
+
+
+@pytest.mark.parametrize('mode', ['printed', 'modern'])
+def test_courier_math_prose_uses_no_symbol_font_in_the_pdf(mode):
+    doc = doc_in_face(COURIER_MATH)
+    pdf_bytes = pdf.emit_pdf(doc, mode=mode)
+    assert not symbol_resource_names(pdf_bytes), \
+        f'{mode}: a Symbol/ZapfDingbats font resource was registered'
+    # Printed sets the whole physical line in one Tj, Modern one word per
+    # Tj -- the word is what both share.
+    assert b'choose' in decoded_streams(pdf_bytes)
+
+
+@pytest.mark.parametrize('mode', ['printed', 'modern'])
+def test_a_genuine_symbol_face_is_untouched_by_the_ruling(mode):
+    """The guard on the other side: a run really set in Symbol still resolves
+    to the Symbol resource and still writes that face's own byte codes."""
+    doc = doc_in_face(SYMBOL_MATH, text=GREEKABLE)
+    pdf_bytes = pdf.emit_pdf(doc, mode=mode)
+    assert symbol_resource_names(pdf_bytes), \
+        f'{mode}: a real Symbol face lost its Symbol resource'
+
+
+def test_an_unresolved_face_is_untouched_by_the_ruling():
+    doc = doc_in_face(UNNAMED_MATH, text=GREEKABLE)
+    kinds = [font_translit_kind(f) for f in doc.fonts]
+    assert 'math' in kinds, 'the bits fallback stopped working for unnamed faces'

{ctrl_kd-4.8.0 → ctrl_kd-4.8.1}/tests/test_symbol_span_graphic_chars.py

@@ -1,6 +1,16 @@
 """cp437 block/shade/box glyphs degrading to '?' in a Symbol-mapped span
 (Printed and Modern PDF alike).
 
+PARTLY SUPERSEDED, 2026-09-16: the premise below -- "a real WS7 quirk this
+project has to live with", a font block named Brush Script whose character-set
+bits read 'math' resolving to the Adobe Symbol face -- is exactly the misread
+the 2026-09-16 ruling ends ("a resolved ordinary typeface beats the
+character-set bits"; class tests in
+tests/test_style_symbol_map_resolved_face.py). That run now stays on its own
+ordinary face. The GEOMETRY guarantee this file was written for is unchanged
+and still the point of every test here: box/shade glyphs draw as vector fills
+and a middle dot stays a real byte, in every font state a span can be in.
+
 FOUND against the real corpus: sawyer/REF/-LASERJE.FNT line 9 -- twelve
 cp437 glyphs ('░▒▓│┤╡╢╖╕╣║╗') typed under a font block whose typestyle is
 Brush Script, then a real WS7 quirk this project has to live with: that
@@ -127,24 +137,32 @@ def test_no_font_ordinary_font_and_symbol_mapped_font_all_draw_vectors_not_quest
         # a decoded-Python-string comparison.
 
 
-def test_symbol_mapped_span_middle_dot_and_box_run_still_select_the_symbol_font():
-    """The fix must not stop the Symbol-mapped span's OWN font resolution:
-    its Tj text (middle dot, byte 0xB7 -- Adobe Symbol's periodcentered)
-    still runs under a /BaseFont /Symbol resource, and the box run right
-    before it still draws as geometry (no font operator needed for a fill)."""
+def test_symbol_mapped_span_no_longer_selects_the_symbol_font_at_all():
+    """SUPERSEDED BY THE 2026-09-16 RULING ("a resolved ordinary typeface beats
+    the character-set bits"). This case -- typestyle 54, 'Brush Script', with
+    the coarse symbol-map bits reading 'math' -- is the very misread that
+    ruling ends: Brush Script is a perfectly ordinary named face, so its run
+    now stays on the ordinary text font and the character-set bits govern only
+    the extended characters, as WordStar intended.
+
+    What this file's own bug fix guaranteed is unchanged and still checked
+    here: the twelve box/shade glyphs draw as vector geometry and the middle
+    dot stays a real 0xB7 text byte, never the '?' degradation. The byte is
+    the same either way -- cp1252 and Adobe Symbol both carry periodcentered
+    at 0xB7 -- so the visible page does not move; only the font resource does.
+    See tests/test_style_symbol_map_resolved_face.py for the ruling's own
+    class tests."""
     doc = _build_doc()
     pdf_bytes = pdf.emit_pdf(doc, mode='printed')
-    symbol_names = _symbol_font_names(pdf_bytes)
-    assert symbol_names, 'no /BaseFont /Symbol resource registered at all'
+    assert not _symbol_font_names(pdf_bytes), (
+        'a /BaseFont /Symbol resource was registered for a run whose typeface '
+        'name resolves to an ordinary face')
     content = _decoded_content(pdf_bytes)
     # The LAST Tj in the stream is the third span's middle dot -- one bare
-    # 0xB7 byte, under one of the Symbol resource names, never '?' (0x3f).
+    # 0xB7 byte, never '?' (0x3f).
     last_tj = list(re.finditer(rb'/(F\d+) \d+ Tf[^()]*\(([^()]*)\) Tj', content))[-1]
-    assert last_tj[1] in symbol_names, (
-        f'last Tj ({last_tj[2]!r}) is not under a Symbol font resource')
     assert last_tj[2] == b'\xb7', (
-        f'Symbol-mapped middle dot did not encode as periodcentered (0xb7): '
-        f'got {last_tj[2]!r}')
+        f'the middle dot did not survive as a real byte: got {last_tj[2]!r}')
 
 
 def test_fontless_and_ordinary_font_spans_are_unaffected_baseline():