@litfamily/litopencode 1.0.16 → 1.0.18

package/skills/lit-docx/scripts/convert_md_to_docx.py

@@ -17,10 +17,16 @@ Features:
   journal design discipline: title block from YAML frontmatter, curly
   quotes, en/em dashes, nbsp before units, ellipsis, heading auto-numbering,
   booktabs tables, banned-font/style stripping, CJK font pairing.
+- --tonality NAME (or frontmatter `tonality:`) builds the document in one of
+  the six design directions of templates/tonalities/ (docx_design.py), with
+  the page components written as ::: directives; --density and --variance
+  move the pack's dials. Without a tonality or a publisher the plain profile
+  runs through the same builders with neutral tokens.
 """
 
 from __future__ import annotations
 import argparse
+import copy
 import re
 import sys
 from pathlib import Path
@@ -41,6 +47,7 @@ try:
     from docx.enum.style import WD_STYLE_TYPE
     from docx.oxml.ns import qn
     from docx.oxml import OxmlElement
+    from docx.text.paragraph import Paragraph
 except ImportError:
     print("Error: 'python-docx' library not found. Install with: pip install python-docx")
     sys.exit(1)
@@ -51,6 +58,8 @@ except ImportError:
     print("Error: 'beautifulsoup4' library not found. Install with: pip install beautifulsoup4")
     sys.exit(1)
 
+import docx_design  # noqa: E402  (needs the runtime's python-docx and PyYAML)
+
 
 # ===========================================================================
 # Legacy HTML→DOCX helpers (unchanged from pre-M1 — preserved byte-for-byte)
@@ -153,10 +162,16 @@ def process_list(doc: Document, element, md_path: Path, ordered: bool = False, l
         if level > 0:
             para.paragraph_format.left_indent = Inches(0.5 * level)
 
-        # Process direct text content
-        for child in li.children:
+        # Process direct text content. Only the item's own edges are trimmed: the space after a bold lead
+        # ("**1,200개** 태그") belongs to the text.
+        children = list(li.children)
+        for ci, child in enumerate(children):
             if isinstance(child, NavigableString):
-                text = str(child).strip()
+                text = str(child).replace("\n", " ")
+                if ci == 0 or getattr(children[ci - 1], "name", None) in ('ul', 'ol', 'p'):
+                    text = text.lstrip()
+                if ci == len(children) - 1 or getattr(children[ci + 1], "name", None) in ('ul', 'ol', 'p'):
+                    text = text.rstrip()
                 if text:
                     para.add_run(text)
             elif child.name in ('ul', 'ol'):
@@ -185,52 +200,93 @@ def process_table(doc: Document, element, md_path: Path):
 
     table = doc.add_table(rows=len(rows), cols=cols)
     table.style = 'Table Grid'
-    table.autofit = False
-    section = doc.sections[-1]
-    usable_width = section.page_width - section.left_margin - section.right_margin
-    # Weight each column by its longest visible cell, with a floor so short
-    # numeric columns remain readable and a cap so prose cannot crush peers.
-    weights = []
-    for idx in range(cols):
-        lengths = [len(cells[idx].get_text(" ", strip=True)) for tr in rows
-                   if len(cells := tr.find_all(['th', 'td'])) > idx]
-        weights.append(max(8, min(48, max(lengths, default=8))))
-    headers = first_row.find_all(['th', 'td'])
-    floors = [int(Inches(min(1.5, max(0.75, sum(2 if ord(c) > 127 else 1 for c in h.get_text(strip=True)) * 0.12))))
-              for h in headers]
-    if sum(floors) > usable_width:
-        floors = [int(usable_width * value / sum(floors)) for value in floors]
-    spare = usable_width - sum(floors)
-    total = sum(weights)
-    widths = [floor + int(spare * weight / total) for floor, weight in zip(floors, weights)]
-    widths[-1] += usable_width - sum(widths)
-    for idx, width in enumerate(widths):
-        table.columns[idx].width = width
-
     for row_idx, tr in enumerate(rows):
-        row = table.rows[row_idx]
-        tr_pr = row._tr.get_or_add_trPr()
-        tr_pr.append(OxmlElement('w:cantSplit'))
-        if row_idx == 0:
-            tr_pr.append(OxmlElement('w:tblHeader'))
-        cells = tr.find_all(['th', 'td'])
-        for col_idx, cell in enumerate(cells):
+        for col_idx, cell in enumerate(tr.find_all(['th', 'td'])):
             if col_idx < cols:
-                table_cell = row.cells[col_idx]
-                table_cell.width = widths[col_idx]
+                table_cell = table.rows[row_idx].cells[col_idx]
                 # Clear default paragraph
                 table_cell.text = ''
                 para = table_cell.paragraphs[0]
                 for child in cell.children:
                     process_inline_elements(para, child, md_path)
-                if re.fullmatch(r'[-+]?\d[\d,.]*(?:%|원|억|만)?', cell.get_text(strip=True)):
-                    para.alignment = WD_ALIGN_PARAGRAPH.RIGHT
 
                 # Bold for header cells
                 if cell.name == 'th':
                     for run in para.runs:
                         run.bold = True
 
+    # Every path, publisher profiles included, sizes columns by content, sets cells single-spaced and
+    # right-aligns number columns with their header.
+    shape_table(doc, table, [[c.get_text(" ", strip=True) for c in tr.find_all(['th', 'td'])] for tr in rows])
+
+
+# A cell reads as a number when, after signs and units, only digits remain.
+NUMERIC_CELL = re.compile(r"^[+\-−±▲▼△▽]?\s*[\d.,]+\s*(?:%p?|배|x|pt|[가-힣]{1,3}|[A-Za-z]{1,3})?$")
+
+
+def shape_table(doc, table, texts: list[list[str]]) -> None:
+    """Give a table readable columns and keep it whole on the page.
+
+    Column widths follow the longest cell of each column (Hangul counted wider)
+    with a floor, so a short column never squeezes a long one into one word per
+    line. The header row repeats on a new page, a row never splits across pages,
+    and columns of numbers are right-aligned.
+    """
+    if not texts or not texts[0]:
+        return
+    cols = len(table.columns)
+    section = doc.sections[-1]
+    usable = section.page_width - section.left_margin - section.right_margin
+
+    def width_of(text: str) -> float:
+        # Hangul runs a little over twice as wide as Latin; +3 covers the cell padding.
+        return sum(2.3 if "\uac00" <= ch <= "\ud7a3" else 1.0 for ch in text) + 3.0
+
+    want = []
+    for ci in range(cols):
+        column = [row[ci] for row in texts if ci < len(row)]
+        want.append(max([width_of(t) for t in column] + [4.0]))
+    # Each column first gets its natural width (about 0.085 in per Latin character at
+    # body size, capped at 45% of the line); columns that hit the cap share what is left.
+    unit = Inches(0.085)
+    cap = usable * 0.45
+    natural = [min(w * unit, cap) for w in want]
+    capped = [ci for ci in range(cols) if want[ci] * unit > cap]
+    spare = usable - sum(natural)
+    if spare > 0 and capped:
+        for ci in capped:
+            natural[ci] += spare / len(capped)
+    elif spare > 0:
+        natural = [w + spare / cols for w in natural]
+    scale = usable / sum(natural)
+    widths = [int(w * scale) for w in natural]
+
+    table.autofit = False
+    for ci, column in enumerate(table.columns):
+        column.width = widths[ci]
+    for ri, row in enumerate(table.rows):
+        tr_pr = row._tr.get_or_add_trPr()
+        # Schema order puts cantSplit before trHeight and tblHeader after it.
+        tr_pr.insert(0, OxmlElement("w:cantSplit"))
+        if ri == 0:
+            header = OxmlElement("w:tblHeader")
+            tr_pr.append(header)
+        for ci, cell in enumerate(row.cells):
+            if ci < cols:
+                cell.width = widths[ci]
+                for paragraph in cell.paragraphs:
+                    # Body line spacing (1.6 in some profiles) makes every row a double row.
+                    paragraph.paragraph_format.line_spacing = 1.15
+                    paragraph.paragraph_format.space_after = Pt(0)
+                    paragraph.paragraph_format.first_line_indent = Cm(0)
+
+    for ci in range(cols):
+        data = [row[ci] for row in texts[1:] if ci < len(row) and row[ci].strip()]
+        if data and all(NUMERIC_CELL.match(t.strip()) for t in data):
+            for row in table.rows:
+                for paragraph in row.cells[ci].paragraphs:
+                    paragraph.alignment = WD_ALIGN_PARAGRAPH.RIGHT
+
 
 def process_code_block(doc: Document, element):
     """Process code block with monospace formatting."""
@@ -248,6 +304,26 @@ def process_code_block(doc: Document, element):
     para._p.get_or_add_pPr().append(shading)
 
 
+def add_figure_caption(doc, element, para) -> None:
+    """An image alone in its paragraph keeps its alt text as the caption under it
+    ("Figure 1." / "그림 1." bold), and the image keeps with the caption."""
+    images = element.find_all('img')
+    alt = images[0].get('alt', '').strip() if len(images) == 1 else ''
+    if not alt or element.get_text(strip=True):
+        return
+    para.paragraph_format.keep_with_next = True
+    try:
+        caption = doc.add_paragraph(style='Caption')
+    except KeyError:
+        caption = doc.add_paragraph()
+    label = docx_design.FIGURE_LABEL.match(alt)
+    if label:
+        caption.add_run(label.group(1)).bold = True
+        caption.add_run(alt[len(label.group(1)):])
+    else:
+        caption.add_run(alt)
+
+
 def html_to_docx(html: str, doc: Document, md_path: Path):
     """Convert HTML to DOCX elements."""
     soup = BeautifulSoup(html, 'html.parser')
@@ -266,7 +342,8 @@ def html_to_docx(html: str, doc: Document, md_path: Path):
                 process_inline_elements(heading, child, md_path)
 
         elif element.name == 'p':
-            add_paragraph_with_formatting(doc, element, md_path)
+            para = add_paragraph_with_formatting(doc, element, md_path)
+            add_figure_caption(doc, element, para)
 
         elif element.name == 'ul':
             process_list(doc, element, md_path, ordered=False)
@@ -639,6 +716,112 @@ def apply_table_style(doc, design: dict) -> None:
                 existing_bottom.set(qn("w:color"), "000000")
 
 
+def keep_tables_with_captions(doc) -> None:
+    """A table caption keeps with its table, and a table that fits one page keeps its rows together
+    (every row but the last keeps with the next). Pagination only: text, styles and rules are unchanged."""
+    section = doc.sections[-1]
+    frame_h = (section.page_height - section.top_margin - section.bottom_margin) / 12700
+    for table in doc.tables:
+        prev = table._tbl.getprevious()
+        if prev is not None and prev.tag == qn("w:p") and docx_design.TABLE_CAPTION.match("".join(t.text or "" for t in prev.iter(qn("w:t"))).strip()):
+            Paragraph(prev, table._parent).paragraph_format.keep_with_next = True
+        widths = [c.width / 12700 if c.width else 100 for c in table.rows[0].cells]
+        est = sum(6 + 11 * 1.3 * max(docx_design._est_lines(c.text, (widths[i] if i < len(widths) else 100) - 12, 11) for i, c in enumerate(row.cells)) for row in table.rows)
+        if est <= 0.9 * frame_h:
+            for row in table.rows[:-1]:
+                for cell in row.cells:
+                    cell.paragraphs[0].paragraph_format.keep_with_next = True
+
+
+def publisher_spacing(doc) -> None:
+    """Text never touches a table or a caption: the paragraph after a table stands three quarters of a body line
+    clear, a table caption after text 8 pt, and a figure caption keeps 8 pt under it. A paragraph after a list stands
+    6 pt clear of its last item."""
+    body = doc.element.body
+    normal = doc.styles["Normal"]
+    size = normal.font.size.pt if normal.font.size else 11
+    multiple = normal.paragraph_format.line_spacing if isinstance(normal.paragraph_format.line_spacing, float) else 1.15
+    clear = Pt(max(8, round(size * multiple * 1.2 * 0.75)))
+    for el in body.iterchildren(qn("w:tbl")):
+        nxt = el.getnext()
+        if nxt is not None and nxt.tag == qn("w:p") and "".join(t.text or "" for t in nxt.iter(qn("w:t"))).strip():
+            para = Paragraph(nxt, doc._body)
+            # A heading keeps its own (larger) space above.
+            own = para.style.paragraph_format.space_before if para.style is not None else None
+            fmt = para.paragraph_format
+            if not (own and own >= clear) and (not fmt.space_before or fmt.space_before < clear):
+                fmt.space_before = clear
+        prev = el.getprevious()
+        if prev is not None and prev.tag == qn("w:p") and docx_design.TABLE_CAPTION.match("".join(t.text or "" for t in prev.iter(qn("w:t"))).strip()):
+            fmt = Paragraph(prev, doc._body).paragraph_format
+            if not fmt.space_before or fmt.space_before < Pt(8):
+                fmt.space_before = Pt(8)
+    docx_design.space_after_lists(doc)
+    for p in doc.paragraphs:
+        prev = p._p.getprevious()
+        under_picture = prev is not None and prev.find(f".//{qn('w:drawing')}") is not None
+        if docx_design.FIGURE_LABEL.match(p.text.strip()) and (under_picture or (p.style is not None and p.style.name == "Caption")):
+            if not p.paragraph_format.space_after or p.paragraph_format.space_after < Pt(8):
+                p.paragraph_format.space_after = Pt(8)
+
+
+def plain_table_cells(doc) -> None:
+    """Table cells neither hyphenate nor justify: the body may (the profile's hyphenation), but a narrow cell
+    broke "Pro-posed" and a justified header spread "Conversion   at"."""
+    for table in doc.tables:
+        for row in table.rows:
+            for cell in row.cells:
+                for paragraph in cell.paragraphs:
+                    p_pr = paragraph._p.get_or_add_pPr()
+                    if p_pr.find(qn("w:suppressAutoHyphens")) is None:
+                        p_pr.insert_element_before(OxmlElement("w:suppressAutoHyphens"), *SUPPRESS_AFTER)
+                    if paragraph.alignment in (None, WD_ALIGN_PARAGRAPH.JUSTIFY):
+                        paragraph.alignment = WD_ALIGN_PARAGRAPH.LEFT
+
+
+SUPPRESS_AFTER = ("w:kinsoku", "w:wordWrap", "w:overflowPunct", "w:topLinePunct", "w:autoSpaceDE", "w:autoSpaceDN", "w:bidi",
+                  "w:adjustRightInd", "w:snapToGrid", "w:spacing", "w:ind", "w:contextualSpacing", "w:mirrorIndents",
+                  "w:suppressOverlap", "w:jc", "w:textDirection", "w:textAlignment", "w:textboxTightWrap",
+                  "w:outlineLvl", "w:divId", "w:cnfStyle", "w:rPr", "w:sectPr", "w:pPrChange")
+
+
+def page_numbers(doc, design: dict) -> None:
+    """The profile's page numbering (registry design.header_footer): a centred PAGE field in the footer at the
+    footer size, and none on the first page when the profile says so (its header keeps the notice tag)."""
+    hf = design.get("header_footer") or {}
+    if hf.get("page_numbering") != "bottom_center":
+        return
+    size = Pt(float(hf.get("footer_font_size_pt") or 9))
+    for index, section in enumerate(doc.sections):
+        if index and section.footer.is_linked_to_previous:
+            continue
+        if not hf.get("page_numbering_first_page", True) and not section.different_first_page_header_footer:
+            section.different_first_page_header_footer = True
+            first = section.first_page_header
+            for paragraph in section.header.paragraphs:
+                first._element.append(copy.deepcopy(paragraph._p))
+            first._element.remove(first.paragraphs[0]._p)
+        footer = section.footer
+        paragraph = footer.paragraphs[0]
+        paragraph.alignment = WD_ALIGN_PARAGRAPH.CENTER
+        run = paragraph.add_run()
+        run.font.size = size
+        for kind, text in (("begin", None), (None, " PAGE "), ("separate", None), (None, "1"), ("end", None)):
+            if kind:
+                char = OxmlElement("w:fldChar")
+                char.set(qn("w:fldCharType"), kind)
+                run._r.append(char)
+            elif text == " PAGE ":
+                instr = OxmlElement("w:instrText")
+                instr.set(qn("xml:space"), "preserve")
+                instr.text = text
+                run._r.append(instr)
+            else:
+                t = OxmlElement("w:t")
+                t.text = text
+                run._r.append(t)
+
+
 def strip_banned(doc, design: dict) -> None:
     """Remove any banned font/style from runs and paragraphs."""
     banned = design.get("banned") or {}
@@ -683,6 +866,19 @@ def _set_run_fonts(run, latin: str, cjk: str | None) -> None:
         rfonts.set(qn("w:eastAsia"), cjk)
 
 
+THEME_PAIRS = (("asciiTheme", "ascii"), ("hAnsiTheme", "hAnsi"), ("eastAsiaTheme", "eastAsia"), ("cstheme", "cs"))
+
+
+def drop_shadowed_theme_fonts(doc) -> None:
+    """A style that names its face keeps no theme font beside it: Word and LibreOffice both let the theme
+    attribute win, so the profile's heading face (Times New Roman, Arial, Pretendard) rendered as the
+    theme's Calibri. Styles only; the document body is untouched."""
+    for rfonts in doc.styles.element.iter(qn("w:rFonts")):
+        for theme, named in THEME_PAIRS:
+            if rfonts.get(qn(f"w:{named}")) and rfonts.get(qn(f"w:{theme}")) is not None:
+                del rfonts.attrib[qn(f"w:{theme}")]
+
+
 def apply_cjk_font_pairing(doc, font_cfg: dict) -> None:
     body = font_cfg.get("body") or {}
     body_cjk = font_cfg.get("body_cjk") or {}
@@ -885,6 +1081,68 @@ def detect_locale(text: str) -> str:
 # ===========================================================================
 
 
+NOTICE_INK, NOTICE_FILL = docx_design.NOTICE
+
+
+def _shade(element, fill: str) -> None:
+    shd = OxmlElement("w:shd")
+    shd.set(qn("w:val"), "clear")
+    shd.set(qn("w:color"), "auto")
+    shd.set(qn("w:fill"), fill)
+    element.append(shd)
+
+
+def add_notice(doc, text: str) -> None:
+    """The frontmatter `notice:` (e.g. "예시 데이터 — 수치는 가정입니다") as a tag in
+    every page header, so an example document cannot be mistaken for a sourced one
+    on any page it is printed from. A profile whose title page has its own, empty
+    header (korean-generic) gets a tinted band under the title block instead."""
+    if doc.sections[0].different_first_page_header_footer:
+        band = doc.add_paragraph()
+        band_run = band.add_run(str(text))
+        band_run.bold = True
+        band_run.font.size = Pt(10.5)
+        band_run.font.color.rgb = RGBColor.from_string(NOTICE_INK)
+        band.paragraph_format.space_before = Pt(4)
+        band.paragraph_format.space_after = Pt(14)
+        _shade(band._p.get_or_add_pPr(), NOTICE_FILL)
+    for index, section in enumerate(doc.sections):
+        if index and section.header.is_linked_to_previous:
+            continue
+        header = section.header
+        tag = header.paragraphs[0] if header.paragraphs and not header.paragraphs[0].text.strip() else header.add_paragraph()
+        tag_run = tag.add_run(f"\u00a0{text}\u00a0")
+        tag_run.bold = True
+        tag_run.font.size = Pt(9)
+        tag_run.font.color.rgb = RGBColor.from_string(NOTICE_INK)
+        _shade(tag_run._r.get_or_add_rPr(), NOTICE_FILL)
+
+
+MD_EXTENSIONS = ['tables', 'fenced_code', 'nl2br', 'sane_lists']
+
+
+def _md_renderer(md_path: Path):
+    """Markdown into a document or a component's cell, through the legacy HTML helpers."""
+    def render(container, text: str) -> None:
+        html_to_docx(markdown.Markdown(extensions=MD_EXTENSIONS).convert(text), container, md_path)
+    return render
+
+
+def _typography(design: dict, lang: str = "en"):
+    """The registry's micro-typography filters, for Markdown outside the directive fences; Korean text also
+    writes ISO dates the Korean way (2026. 10. 1.)."""
+    def apply(text: str) -> str:
+        # Dates first: the dash filter would read 2026-06-30 as a number range.
+        if lang != "en":
+            text = docx_design.korean_dates(text)
+        text = fix_dashes(text, design.get("micro_typography", {}).get("dashes"))
+        text = fix_quotes(text)
+        text = fix_unit_spacing(text)
+        text = fix_ellipsis(text)
+        return normalize_double_spaces(text)
+    return apply
+
+
 def convert_md_to_docx(
     md_path: Path,
     docx_path: Path,
@@ -892,33 +1150,43 @@ def convert_md_to_docx(
     publisher_name: str | None = None,
     registry_path: Path | None = None,
     locale: str = "auto",
+    tonality: str | None = None,
+    density: int | None = None,
+    variance: int | None = None,
 ):
     """Convert Markdown file to DOCX.
 
-    When publisher_name is None, behavior is byte-compatible with the pre-M1
-    script: read md, convert to HTML, html_to_docx, save. Regression-guarded.
+    With a tonality (argument or frontmatter `tonality:`), the document is built
+    by docx_design in that design direction. Without a tonality or a publisher,
+    the plain profile runs through the same builders with neutral tokens (A4,
+    Pretendard, booktabs tables, notice in every header).
 
     When publisher_name is set, apply the full journal pipeline: registry
     load, frontmatter parse, pre-MD filters, title-block injection, post-HTML
     heading numbering, booktabs tables, banned stripping, CJK font pairing.
+    A publisher run writes the same document.xml as before the tonality
+    engine unless the source holds figures (captions) or directives.
     """
     if publisher_name is None:
-        # --- Legacy code path (regression-critical: do not mutate) ---
-        md_text = md_path.read_text(encoding='utf-8')
-        md_converter = markdown.Markdown(extensions=[
-            'tables',
-            'fenced_code',
-            'nl2br',
-            'sane_lists',
-        ])
-        html = md_converter.convert(md_text)
-        if template_path and template_path.exists():
-            doc = Document(str(template_path))
-        else:
-            doc = Document()
-        html_to_docx(html, doc, md_path)
+        md_text = md_path.read_text(encoding="utf-8")
+        front, body = parse_frontmatter(md_text) if md_text.startswith("---") else ({}, md_text)
+        name = tonality or front.get("tonality")
+        lang = "en" if (detect_locale(body) if locale == "auto" else locale) == "en" else "ko"
+        dials = {k: v for k, v in (("density", density if density is not None else front.get("density")),
+                                    ("variance", variance if variance is not None else front.get("variance"))) if v is not None}
+        try:
+            if name:
+                T = docx_design.load_tonality(name, locale=lang, **{k: int(v) for k, v in dials.items()})
+                filters = _typography(T.design, lang)
+            else:
+                T, filters = docx_design.neutral_tonality(lang), None
+            doc = Document(str(template_path)) if template_path and template_path.exists() else Document()
+            docx_design.build(doc, front, body, T, _md_renderer(md_path), lang, filters)
+        except docx_design.DesignError as exc:
+            raise SystemExit(f"Error: {exc}") from exc
         doc.save(str(docx_path))
-        print(f"Successfully converted {md_path} to {docx_path}")
+        label = f"tonality={T.name}, density={T.density}, variance={T.variance}" if not T.neutral else "plain profile"
+        print(f"Successfully converted {md_path} to {docx_path} [{label}, locale={lang}]")
         return
 
     # --- Journal workflow ---
@@ -930,17 +1198,29 @@ def convert_md_to_docx(
 
     md_text = md_path.read_text(encoding="utf-8")
     frontmatter, body = parse_frontmatter(md_text)
+    if frontmatter.get("tonality"):
+        raise SystemExit(f"Error: frontmatter tonality: {frontmatter['tonality']} and --publisher {publisher_name} are mutually exclusive")
 
     # Locale detection (informational in M1; Korean rules land in M6)
     detected_locale = detect_locale(body) if locale == "auto" else locale
 
     # Pre-MD micro-typography filters
+    if detected_locale in ("ko", "mixed"):
+        # No ISO dates in Korean text on any path. Before the dash filter, which would read 2026-06-30 as a
+        # number range.
+        body = docx_design.korean_dates(body)
+        if frontmatter.get("date"):
+            frontmatter["date"] = docx_design.format_date(frontmatter["date"], "ko")
     dash_rules = design.get("micro_typography", {}).get("dashes")
-    body = fix_dashes(body, dash_rules)
-    body = fix_quotes(body)
-    body = fix_unit_spacing(body)
-    body = fix_ellipsis(body)
-    body = normalize_double_spaces(body)
+
+    def typeset(text: str) -> str:
+        return normalize_double_spaces(fix_ellipsis(fix_unit_spacing(fix_quotes(fix_dashes(text, dash_rules)))))
+
+    # Directive attributes on a ::: line (title="...") must keep straight quotes or the directive stops parsing.
+    # Only the text between those lines is typeset, one stretch at a time, so quote pairs and code fences keep
+    # their context and a source with no directive is typeset in one piece.
+    segments = re.split(r"^([ \t]*:{3,}.*)$", body, flags=re.M)
+    body = "".join(segment if n % 2 else typeset(segment) for n, segment in enumerate(segments))
 
     # Load template if available
     template_docx = script_dir.parent / "templates" / "docx" / f"{publisher_name}.docx"
@@ -965,22 +1245,46 @@ def convert_md_to_docx(
     # Title block (built from frontmatter) before main content
     if frontmatter.get("title"):
         inject_title_block(doc, frontmatter, design)
+    if frontmatter.get("notice"):
+        add_notice(doc, frontmatter["notice"])
+    page_numbers(doc, design)
 
     # Main content
-    md_converter = markdown.Markdown(extensions=[
-        'tables',
-        'fenced_code',
-        'nl2br',
-        'sane_lists',
-    ])
-    html = md_converter.convert(body)
-    html_to_docx(html, doc, md_path)
+    if docx_design.has_directives(body):
+        # Components in a journal manuscript are drawn with neutral styling (ink and line only).
+        neutral = docx_design.neutral_tonality("en" if detected_locale == "en" else "ko")
+        docx_design.setup_component_styles(doc, neutral)
+        ctx = docx_design.Build(doc, neutral, _md_renderer(md_path), "en" if detected_locale == "en" else "ko")
+        try:
+            ctx.render(doc, body)
+        except docx_design.DesignError as exc:
+            raise SystemExit(f"Error: {exc}") from exc
+        print("Note: the ::: components are drawn with publisher-neutral styling under a publisher profile")
+    else:
+        md_converter = markdown.Markdown(extensions=[
+            'tables',
+            'fenced_code',
+            'nl2br',
+            'sane_lists',
+        ])
+        html = md_converter.convert(body)
+        html_to_docx(html, doc, md_path)
 
     # Post-HTML design enforcement
     apply_heading_numbering(doc, design)
     apply_table_style(doc, design)
+    keep_tables_with_captions(doc)
+    plain_table_cells(doc)
+    publisher_spacing(doc)
+    # No column narrower than its longest word ("Cataly/st" wrapped inside a publisher table).
+    normal = doc.styles["Normal"].font.size
+    for table in doc.tables:
+        docx_design.fit_word_widths(table, normal.pt if normal else 11)
+    docx_design.restart_numbered_lists(doc)
+    docx_design.keep_short_lists(doc)
     strip_banned(doc, design)
     apply_cjk_font_pairing(doc, docx_font)
+    drop_shadowed_theme_fonts(doc)
 
     doc.save(str(docx_path))
     print(
@@ -1010,6 +1314,14 @@ def parse_args() -> argparse.Namespace:
         help="Path to templates/registry.yaml (defaults to the one in this skill)",
         default=None,
     )
+    parser.add_argument(
+        "--tonality",
+        help="Design direction from templates/tonalities/: Report, Brief, Manual, Proposal, Memo or Journal "
+             "(frontmatter tonality: works too)",
+        default=None,
+    )
+    parser.add_argument("--density", type=int, default=None, help="Density dial 1-10 (default: the pack's)")
+    parser.add_argument("--variance", type=int, default=None, help="Variance dial 1-10 (default: the pack's)")
     parser.add_argument(
         "--locale",
         choices=("auto", "en", "ko", "mixed"),
@@ -1019,6 +1331,8 @@ def parse_args() -> argparse.Namespace:
     args = parser.parse_args()
     if args.publisher and args.template:
         parser.error("--publisher and --template are mutually exclusive")
+    if args.publisher and args.tonality:
+        parser.error("--tonality and --publisher are mutually exclusive: a tonality is a design direction, a publisher a journal profile")
     return args
 
 
@@ -1039,6 +1353,9 @@ def main() -> int:
         publisher_name=args.publisher,
         registry_path=registry_path,
         locale=args.locale,
+        tonality=args.tonality,
+        density=args.density,
+        variance=args.variance,
     )
     return 0