@litfamily/litgrok 1.0.13 → 1.0.15

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

@@ -17,10 +17,17 @@ 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 +48,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 +59,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 +163,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,21 +201,12 @@ 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]
-    available = section.page_width - section.left_margin - section.right_margin
-    texts = [[cell.get_text(' ', strip=True) for cell in tr.find_all(['th', 'td'])[:cols]] for tr in rows]
-    weights = [max(8, min(35, max((len(row[i]) for row in texts if len(row) > i), default=8))) for i in range(cols)]
-    widths = [int(available * weight / sum(weights)) for weight in weights]
-    for column, width in zip(table.columns, widths):
-        column.width = width
 
     for row_idx, tr in enumerate(rows):
         cells = tr.find_all(['th', 'td'])
         for col_idx, cell in enumerate(cells):
             if col_idx < cols:
                 table_cell = table.rows[row_idx].cells[col_idx]
-                table_cell.width = widths[col_idx]
                 # Clear default paragraph
                 table_cell.text = ''
                 para = table_cell.paragraphs[0]
@@ -210,13 +217,76 @@ def process_table(doc: Document, element, md_path: Path):
                 if cell.name == 'th':
                     for run in para.runs:
                         run.bold = True
-        tr_pr = table.rows[row_idx]._tr.get_or_add_trPr()
-        no_split = OxmlElement('w:cantSplit')
-        tr_pr.append(no_split)
-        if row_idx == 0:
-            repeat = OxmlElement('w:tblHeader')
-            repeat.set(qn('w:val'), 'true')
-            tr_pr.append(repeat)
+
+    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):
@@ -235,6 +305,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')
@@ -253,7 +343,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)
@@ -626,6 +717,111 @@ 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 (8 pt read as half a line), 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. A heading keeps its own, larger space above."""
+    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)
+            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 {}
@@ -670,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 {}
@@ -758,6 +967,17 @@ def inject_title_block(doc, frontmatter: dict, design: dict) -> None:
     )
     _add_run(tp, str(title), tb.get("title", {}).get("size_pt", 18), bold=True)
 
+    # Report-style frontmatter: a subtitle and one author / organisation / date line
+    # when there is no journal author list.
+    if frontmatter.get("subtitle"):
+        sp = _p_center(13, space_after=6)
+        _add_run(sp, str(frontmatter["subtitle"]), 13)
+    if not frontmatter.get("authors"):
+        meta = [str(v) for v in (frontmatter.get("author"), frontmatter.get("organization"), frontmatter.get("date")) if v]
+        if meta:
+            mp = _p_center(10.5, space_after=14)
+            _add_run(mp, " · ".join(meta), 10.5)
+
     # Authors
     authors = frontmatter.get("authors") or []
     if authors:
@@ -872,6 +1092,73 @@ 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)
+
+
+def read_source(md_path: Path) -> str:
+    """The Markdown source as written; numbers in it are the author's own."""
+    return md_path.read_text(encoding="utf-8")
+
+
+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,
@@ -879,33 +1166,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 = read_source(md_path)
+        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 ---
@@ -915,19 +1212,28 @@ def convert_md_to_docx(
     design = publisher["design"]
     docx_font = publisher["docx"]["font"]
 
-    md_text = md_path.read_text(encoding="utf-8")
+    md_text = read_source(md_path)
     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"):
+        # Every path: no ISO dates in Korean text. 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)))))
+
+    # A ::: fence line carries attributes (title="…"); curly quotes there would break the directive.
+    body = "\n".join(line if re.match(r"\s*:{3,}", line) else typeset(line) for line in body.split("\n"))
 
     # Load template if available
     template_docx = script_dir.parent / "templates" / "docx" / f"{publisher_name}.docx"
@@ -952,22 +1258,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" in 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(
@@ -997,6 +1327,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"),
@@ -1006,6 +1344,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
 
 
@@ -1026,6 +1366,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