@kaydash9999/banker-plugins 0.20.5 → 0.22.0

package/skills/vertical-pptx/build_a4p.py

@@ -59,6 +59,7 @@ python-pptx 특유의 함정 셋. 전부 이 저장소에서 실측한 것이고
 import json
 import math
 import os
+import re
 import subprocess
 import sys
 
@@ -67,7 +68,7 @@ MIN_PYTHON = (3, 9)
 EMU_PER_MM = 36000
 SLIDE_W = 210 * EMU_PER_MM  # 7560000
 SLIDE_H = 297 * EMU_PER_MM  # 10692000
-GUTTER = 4 * EMU_PER_MM     #  144000
+GUTTER = 4 * EMU_PER_MM  #  144000
 COLS = 8
 ROWS = 20
 TITLE_ROWS = 2
@@ -77,11 +78,11 @@ MARGIN_MM_MAX = 40
 DEFAULT_MARGIN_MM = 10
 DEFAULT_BODY_PT = 10.5  # 동결 범위 10~11pt
 LINE_SPACING = 1.2
-BULLET_PREFIX = '\u2022 '
-COLOR_HEAD = '1A1A1A'
-COLOR_BODY = '222222'
-BLOCK_TYPES = ('head', 'body', 'bullets')
-ORIENTATIONS = ('portrait', 'landscape')
+BULLET_PREFIX = "\u2022 "
+COLOR_HEAD = "1A1A1A"
+COLOR_BODY = "222222"
+BLOCK_TYPES = ("head", "body", "bullets")
+ORIENTATIONS = ("portrait", "landscape")
 
 EXIT_OK = 0
 EXIT_VERIFY = 1
@@ -89,15 +90,29 @@ EXIT_ENV = 2
 EXIT_USAGE = 3
 
 # 폰트 체인. --font → BANKER_PPTX_FONT → meta.font → 아래 목록 → 시스템 한국어 sans.
-FONT_CHAIN = ('Noto Sans CJK KR', 'Malgun Gothic', 'Apple SD Gothic Neo', 'NanumGothic')
+# build_a4p.js 의 FONT_CHAIN, FONT_FILE_HINTS 와 같아야 한다(a4p.test.mjs U18b).
+# "Noto Sans KR" 은 "Noto Sans CJK KR" 의 별칭이 아니라 다른 패밀리다. Windows 의 NotoSansKR-VF.ttf 가 그것이다.
+# CJK 항목의 힌트로 묶으면 그 머신에 없는 이름 "Noto Sans CJK KR" 을 pptx 에 적게 된다.
+# AppleGothic 도 Apple SD Gothic Neo 와 다른 폰트다.
+FONT_CHAIN = (
+    "Noto Sans CJK KR",
+    "Noto Sans KR",
+    "Malgun Gothic",
+    "Apple SD Gothic Neo",
+    "AppleGothic",
+    "NanumGothic",
+)
 # fc-match 가 없는 환경에서 파일명으로 찾기 위한 힌트(정규화된 소문자 조각).
+# 힌트는 그 항목의 패밀리보다 느슨하면 안 된다. 파일명 탐색에는 패밀리 대조가 없다.
 FONT_FILE_HINTS = {
-    'noto sans cjk kr': ('notosanscjkkr', 'notosanscjk', 'notosanskr'),
-    'malgun gothic': ('malgun',),
-    'apple sd gothic neo': ('applesdgothicneo', 'applegothic'),
-    'nanumgothic': ('nanumgothic',),
+    "noto sans cjk kr": ("notosanscjkkr", "notosanscjk"),
+    "noto sans kr": ("notosanskr",),
+    "malgun gothic": ("malgun",),
+    "apple sd gothic neo": ("applesdgothicneo",),
+    "applegothic": ("applegothic",),
+    "nanumgothic": ("nanumgothic",),
 }
-FONT_EXT = frozenset(('.ttf', '.ttc', '.otf', '.otc'))
+FONT_EXT = frozenset((".ttf", ".ttc", ".otf", ".otc"))
 
 
 # ── 오류 타입 ───────────────────────────────────────────────────────────────
@@ -119,49 +134,49 @@ def grid_for(margin_mm):
     col_w = (182 - 2 * m) * 4500
     row_h = (221 - 2 * m) * 1800
     return {
-        'marginMm': m,
-        'margin': EMU_PER_MM * m,
-        'slideW': SLIDE_W,
-        'slideH': SLIDE_H,
-        'contentW': SLIDE_W - 2 * EMU_PER_MM * m,
-        'contentH': SLIDE_H - 2 * EMU_PER_MM * m,
-        'gutter': GUTTER,
-        'cols': COLS,
-        'rows': ROWS,
-        'colW': col_w,
-        'rowH': row_h,
-        'colPitch': col_w + GUTTER,
-        'rowPitch': row_h + GUTTER,
+        "marginMm": m,
+        "margin": EMU_PER_MM * m,
+        "slideW": SLIDE_W,
+        "slideH": SLIDE_H,
+        "contentW": SLIDE_W - 2 * EMU_PER_MM * m,
+        "contentH": SLIDE_H - 2 * EMU_PER_MM * m,
+        "gutter": GUTTER,
+        "cols": COLS,
+        "rows": ROWS,
+        "colW": col_w,
+        "rowH": row_h,
+        "colPitch": col_w + GUTTER,
+        "rowPitch": row_h + GUTTER,
     }
 
 
 def col_x(g, c):
-    return g['margin'] + g['colPitch'] * c
+    return g["margin"] + g["colPitch"] * c
 
 
 def col_cx(g, k):
-    return g['colW'] * k + GUTTER * (k - 1)
+    return g["colW"] * k + GUTTER * (k - 1)
 
 
 def row_y(g, r):
-    return g['margin'] + g['rowPitch'] * r
+    return g["margin"] + g["rowPitch"] * r
 
 
 def row_cy(g, n):
-    return g['rowH'] * n + GUTTER * (n - 1)
+    return g["rowH"] * n + GUTTER * (n - 1)
 
 
 def default_rows(block):
-    if block.get('type') == 'head':
+    if block.get("type") == "head":
         return 1
-    if block.get('type') == 'body':
+    if block.get("type") == "body":
         return 2
-    return max(1, len(block.get('items') or []))  # bullets
+    return max(1, len(block.get("items") or []))  # bullets
 
 
 def requested_rows(block):
     """클램프 이전의 요청 행 수. 클램프 발동 판정은 반드시 이 값으로 한다."""
-    rows = block.get('rows')
+    rows = block.get("rows")
     return default_rows(block) if rows is None else rows
 
 
@@ -179,7 +194,7 @@ def bullet_spans(n, count):
     for i in range(count):
         start = min(i, n - 1)
         end = n - 1 if i == count - 1 else min(i + 1, n - 1) - 1
-        spans.append({'start': start, 'rows': max(1, end - start + 1)})
+        spans.append({"start": start, "rows": max(1, end - start + 1)})
     return spans
 
 
@@ -220,81 +235,111 @@ def show(value):
 
 
 def orientation_of(deck, page):
-    meta = deck.get('meta') or {}
-    return page.get('orientation') or meta.get('orientation') or 'portrait'
+    meta = deck.get("meta") or {}
+    return page.get("orientation") or meta.get("orientation") or "portrait"
 
 
 def validate_deck(deck):
     if not is_plain_object(deck):
-        raise UsageError('deck JSON 최상위는 객체여야 한다.')
-    meta = {} if deck.get('meta') is None else deck.get('meta')
+        raise UsageError("deck JSON 최상위는 객체여야 한다.")
+    meta = {} if deck.get("meta") is None else deck.get("meta")
     if not is_plain_object(meta):
-        raise UsageError('meta 는 객체여야 한다.')
+        raise UsageError("meta 는 객체여야 한다.")
 
-    if meta.get('marginMm') is not None:
-        m = as_integer(meta.get('marginMm'))
+    if meta.get("marginMm") is not None:
+        m = as_integer(meta.get("marginMm"))
         if m is None or m < MARGIN_MM_MIN or m > MARGIN_MM_MAX:
             raise UsageError(
-                'meta.marginMm 은 {0} 이상 {1} 이하의 정수여야 한다 (받은 값: {2}).'.format(
-                    MARGIN_MM_MIN, MARGIN_MM_MAX, show(meta.get('marginMm'))))
-    if meta.get('bodyPt') is not None:
-        pt = as_number(meta.get('bodyPt'))
+                "meta.marginMm 은 {0} 이상 {1} 이하의 정수여야 한다 (받은 값: {2}).".format(
+                    MARGIN_MM_MIN, MARGIN_MM_MAX, show(meta.get("marginMm"))
+                )
+            )
+    if meta.get("bodyPt") is not None:
+        pt = as_number(meta.get("bodyPt"))
         if pt is None or pt <= 0 or pt > 400:
-            raise UsageError('meta.bodyPt 는 0 초과 400 이하의 수여야 한다 (받은 값: {0}).'.format(
-                show(meta.get('bodyPt'))))
-    if meta.get('title') is not None and not isinstance(meta.get('title'), str):
-        raise UsageError('meta.title 은 문자열이어야 한다.')
-    if meta.get('font') is not None and not isinstance(meta.get('font'), str):
-        raise UsageError('meta.font 는 문자열이어야 한다.')
-    if meta.get('orientation') is not None and meta.get('orientation') not in ORIENTATIONS:
-        raise UsageError('meta.orientation 은 {0} 여야 한다.'.format(' 또는 '.join(ORIENTATIONS)))
-
-    pages = deck.get('pages')
+            raise UsageError(
+                "meta.bodyPt 는 0 초과 400 이하의 수여야 한다 (받은 값: {0}).".format(
+                    show(meta.get("bodyPt"))
+                )
+            )
+    if meta.get("title") is not None and not isinstance(meta.get("title"), str):
+        raise UsageError("meta.title 은 문자열이어야 한다.")
+    if meta.get("font") is not None and not isinstance(meta.get("font"), str):
+        raise UsageError("meta.font 는 문자열이어야 한다.")
+    if (
+        meta.get("orientation") is not None
+        and meta.get("orientation") not in ORIENTATIONS
+    ):
+        raise UsageError(
+            "meta.orientation 은 {0} 여야 한다.".format(" 또는 ".join(ORIENTATIONS))
+        )
+
+    pages = deck.get("pages")
     if not isinstance(pages, list) or not pages:
-        raise UsageError('pages 는 비어 있지 않은 배열이어야 한다.')
+        raise UsageError("pages 는 비어 있지 않은 배열이어야 한다.")
 
     for pi, page in enumerate(pages):
-        at = 'pages[{0}]'.format(pi)
+        at = "pages[{0}]".format(pi)
         if not is_plain_object(page):
-            raise UsageError('{0} 는 객체여야 한다.'.format(at))
-        if page.get('title') is not None and not isinstance(page.get('title'), str):
-            raise UsageError('{0}.title 은 문자열이어야 한다.'.format(at))
-        if page.get('orientation') is not None and page.get('orientation') not in ORIENTATIONS:
-            raise UsageError('{0}.orientation 은 {1} 여야 한다.'.format(at, ' 또는 '.join(ORIENTATIONS)))
-        blocks = [] if page.get('blocks') is None else page.get('blocks')
+            raise UsageError("{0} 는 객체여야 한다.".format(at))
+        if page.get("title") is not None and not isinstance(page.get("title"), str):
+            raise UsageError("{0}.title 은 문자열이어야 한다.".format(at))
+        if (
+            page.get("orientation") is not None
+            and page.get("orientation") not in ORIENTATIONS
+        ):
+            raise UsageError(
+                "{0}.orientation 은 {1} 여야 한다.".format(
+                    at, " 또는 ".join(ORIENTATIONS)
+                )
+            )
+        blocks = [] if page.get("blocks") is None else page.get("blocks")
         if not isinstance(blocks, list):
-            raise UsageError('{0}.blocks 는 배열이어야 한다.'.format(at))
+            raise UsageError("{0}.blocks 는 배열이어야 한다.".format(at))
         for bi, block in enumerate(blocks):
-            bat = '{0}.blocks[{1}]'.format(at, bi)
+            bat = "{0}.blocks[{1}]".format(at, bi)
             if not is_plain_object(block):
-                raise UsageError('{0} 는 객체여야 한다.'.format(bat))
-            if block.get('type') not in BLOCK_TYPES:
-                raise UsageError('{0}.type 은 {1} 중 하나여야 한다 (받은 값: {2}).'.format(
-                    bat, ' / '.join(BLOCK_TYPES), show(block.get('type'))))
-            if block.get('type') == 'bullets':
-                items = block.get('items')
+                raise UsageError("{0} 는 객체여야 한다.".format(bat))
+            if block.get("type") not in BLOCK_TYPES:
+                raise UsageError(
+                    "{0}.type 은 {1} 중 하나여야 한다 (받은 값: {2}).".format(
+                        bat, " / ".join(BLOCK_TYPES), show(block.get("type"))
+                    )
+                )
+            if block.get("type") == "bullets":
+                items = block.get("items")
                 if not isinstance(items, list) or not items:
-                    raise UsageError('{0}.items 는 비어 있지 않은 배열이어야 한다.'.format(bat))
+                    raise UsageError(
+                        "{0}.items 는 비어 있지 않은 배열이어야 한다.".format(bat)
+                    )
                 for ii, item in enumerate(items):
                     if not isinstance(item, str):
-                        raise UsageError('{0}.items[{1}] 는 문자열이어야 한다.'.format(bat, ii))
-            elif not isinstance(block.get('text'), str):
-                raise UsageError('{0}.text 는 문자열이어야 한다.'.format(bat))
-            if block.get('rows') is not None:
-                rows = as_integer(block.get('rows'))
+                        raise UsageError(
+                            "{0}.items[{1}] 는 문자열이어야 한다.".format(bat, ii)
+                        )
+            elif not isinstance(block.get("text"), str):
+                raise UsageError("{0}.text 는 문자열이어야 한다.".format(bat))
+            if block.get("rows") is not None:
+                rows = as_integer(block.get("rows"))
                 if rows is None or rows < 1:
-                    raise UsageError('{0}.rows 는 1 이상의 정수여야 한다 (받은 값: {1}).'.format(
-                        bat, show(block.get('rows'))))
+                    raise UsageError(
+                        "{0}.rows 는 1 이상의 정수여야 한다 (받은 값: {1}).".format(
+                            bat, show(block.get("rows"))
+                        )
+                    )
 
     # 방향 혼합은 파일 형식이 허용하지 않는다 — 하나의 pptx 는 하나의 sldSz 만 갖는다.
     seen = set(orientation_of(deck, p) for p in pages)
     if len(seen) > 1:
         raise UsageError(
-            '한 pptx 는 세로와 가로를 함께 담을 수 없다(슬라이드 크기가 파일당 하나다). '
-            '방향별로 파일을 나누어 각각 빌드해라 — split the deck into separate files, '
-            'one per orientation.')
-    if 'landscape' in seen:
-        raise UsageError('이 스킬은 A4 세로(210x297mm) 전용이다. 가로 덱은 대상이 아니다.')
+            "한 pptx 는 세로와 가로를 함께 담을 수 없다(슬라이드 크기가 파일당 하나다). "
+            "방향별로 파일을 나누어 각각 빌드해라 — split the deck into separate files, "
+            "one per orientation."
+        )
+    if "landscape" in seen:
+        raise UsageError(
+            "이 스킬은 A4 세로(210x297mm) 전용이다. 가로 덱은 대상이 아니다."
+        )
     return True
 
 
@@ -306,197 +351,275 @@ def layout(deck):
       pageIndex·blockIndex 가 있어야 검증기가 (슬라이드, 도형) 을 (페이지, 블록) 으로 되돌릴 수 있다.
     """
     validate_deck(deck)
-    meta = deck.get('meta') or {}
-    margin_mm = DEFAULT_MARGIN_MM if meta.get('marginMm') is None else as_integer(meta.get('marginMm'))
+    meta = deck.get("meta") or {}
+    margin_mm = (
+        DEFAULT_MARGIN_MM
+        if meta.get("marginMm") is None
+        else as_integer(meta.get("marginMm"))
+    )
     grid = grid_for(margin_mm)
-    body_pt = DEFAULT_BODY_PT if meta.get('bodyPt') is None else as_number(meta.get('bodyPt'))
-    pt = {'title': body_pt + 6, 'head': body_pt + 2, 'body': body_pt, 'bullets': body_pt}
+    body_pt = (
+        DEFAULT_BODY_PT if meta.get("bodyPt") is None else as_number(meta.get("bodyPt"))
+    )
+    pt = {
+        "title": body_pt + 6,
+        "head": body_pt + 2,
+        "body": body_pt,
+        "bullets": body_pt,
+    }
     full_cx = col_cx(grid, COLS)
     slides = []
     warnings = []
 
-    for page_index, page in enumerate(deck['pages']):
-        title = '' if page.get('title') is None else page.get('title')
-        state = {'slide': None, 'used': 0, 'part': 0}
+    for page_index, page in enumerate(deck["pages"]):
+        title = "" if page.get("title") is None else page.get("title")
+        state = {"slide": None, "used": 0, "part": 0}
 
         def open_slide():
-            slide = {'index': len(slides), 'pageIndex': page_index, 'part': state['part'],
-                     'title': title, 'shapes': []}
-            state['part'] += 1
-            state['used'] = 0
-            slide['shapes'].append({
-                'role': 'title',
-                'pageIndex': page_index,
-                'blockIndex': None,
-                'itemIndex': None,
-                'rows': TITLE_ROWS,
-                'x': col_x(grid, 0),
-                'y': row_y(grid, 0),
-                'cx': full_cx,
-                'cy': row_cy(grid, TITLE_ROWS),
-                'text': title,
-                'pt': pt['title'],
-                'bold': True,
-                'color': COLOR_HEAD,
-            })
+            slide = {
+                "index": len(slides),
+                "pageIndex": page_index,
+                "part": state["part"],
+                "title": title,
+                "shapes": [],
+            }
+            state["part"] += 1
+            state["used"] = 0
+            slide["shapes"].append(
+                {
+                    "role": "title",
+                    "pageIndex": page_index,
+                    "blockIndex": None,
+                    "itemIndex": None,
+                    "rows": TITLE_ROWS,
+                    "x": col_x(grid, 0),
+                    "y": row_y(grid, 0),
+                    "cx": full_cx,
+                    "cy": row_cy(grid, TITLE_ROWS),
+                    "text": title,
+                    "pt": pt["title"],
+                    "bold": True,
+                    "color": COLOR_HEAD,
+                }
+            )
             slides.append(slide)
-            state['slide'] = slide
+            state["slide"] = slide
 
         open_slide()
 
-        blocks = [] if page.get('blocks') is None else page.get('blocks')
+        blocks = [] if page.get("blocks") is None else page.get("blocks")
         for block_index, block in enumerate(blocks):
             want = requested_rows(block)
             n = rows_of(block)
             if want > MAX_BLOCK_ROWS:
-                warnings.append({
-                    'code': 'BLOCK_TOO_TALL',
-                    'page': page_index,
-                    'block': block_index,
-                    'detail': 'rows {0} -> {1}'.format(want, n),
-                })
+                warnings.append(
+                    {
+                        "code": "BLOCK_TOO_TALL",
+                        "page": page_index,
+                        "block": block_index,
+                        "detail": "rows {0} -> {1}".format(want, n),
+                    }
+                )
             # 세는 규칙만: 넘치면 새 슬라이드로 넘긴다. 블록은 절대 쪼개지 않는다.
-            if state['used'] > 0 and state['used'] + n > MAX_BLOCK_ROWS:
+            if state["used"] > 0 and state["used"] + n > MAX_BLOCK_ROWS:
                 open_slide()
-            base = TITLE_ROWS + state['used']
-            slide = state['slide']
+            base = TITLE_ROWS + state["used"]
+            slide = state["slide"]
 
-            if block['type'] == 'bullets':
-                items = block['items']
+            if block["type"] == "bullets":
+                items = block["items"]
                 for item_index, span in enumerate(bullet_spans(n, len(items))):
-                    slide['shapes'].append({
-                        'role': 'bullet',
-                        'pageIndex': page_index,
-                        'blockIndex': block_index,
-                        'itemIndex': item_index,
-                        'rows': span['rows'],
-                        'x': col_x(grid, 0),
-                        'y': row_y(grid, base + span['start']),
-                        'cx': full_cx,
-                        'cy': row_cy(grid, span['rows']),
-                        'text': BULLET_PREFIX + items[item_index],
-                        'pt': pt['bullets'],
-                        'bold': False,
-                        'color': COLOR_BODY,
-                    })
+                    slide["shapes"].append(
+                        {
+                            "role": "bullet",
+                            "pageIndex": page_index,
+                            "blockIndex": block_index,
+                            "itemIndex": item_index,
+                            "rows": span["rows"],
+                            "x": col_x(grid, 0),
+                            "y": row_y(grid, base + span["start"]),
+                            "cx": full_cx,
+                            "cy": row_cy(grid, span["rows"]),
+                            "text": BULLET_PREFIX + items[item_index],
+                            "pt": pt["bullets"],
+                            "bold": False,
+                            "color": COLOR_BODY,
+                        }
+                    )
             else:
-                is_head = block['type'] == 'head'
-                slide['shapes'].append({
-                    'role': block['type'],
-                    'pageIndex': page_index,
-                    'blockIndex': block_index,
-                    'itemIndex': None,
-                    'rows': n,
-                    'x': col_x(grid, 0),
-                    'y': row_y(grid, base),
-                    'cx': full_cx,
-                    'cy': row_cy(grid, n),
-                    'text': block['text'],
-                    'pt': pt['head'] if is_head else pt['body'],
-                    'bold': is_head,
-                    'color': COLOR_HEAD if is_head else COLOR_BODY,
-                })
-            state['used'] += n
-
-    return {'grid': grid, 'bodyPt': body_pt, 'slides': slides, 'warnings': warnings}
+                is_head = block["type"] == "head"
+                slide["shapes"].append(
+                    {
+                        "role": block["type"],
+                        "pageIndex": page_index,
+                        "blockIndex": block_index,
+                        "itemIndex": None,
+                        "rows": n,
+                        "x": col_x(grid, 0),
+                        "y": row_y(grid, base),
+                        "cx": full_cx,
+                        "cy": row_cy(grid, n),
+                        "text": block["text"],
+                        "pt": pt["head"] if is_head else pt["body"],
+                        "bold": is_head,
+                        "color": COLOR_HEAD if is_head else COLOR_BODY,
+                    }
+                )
+            state["used"] += n
+
+    return {"grid": grid, "bodyPt": body_pt, "slides": slides, "warnings": warnings}
 
 
 def assert_inside_slide(laid):
     """기하가 실제로 여백 안에 있는지 자기 점검. 클램프가 살아 있으면 절대 발동하지 않는다."""
-    g = laid['grid']
+    g = laid["grid"]
     bad = []
-    for s in laid['slides']:
-        for j, sh in enumerate(s['shapes']):
-            if (sh['x'] < g['margin'] or sh['y'] < g['margin']
-                    or sh['x'] + sh['cx'] > SLIDE_W - g['margin']
-                    or sh['y'] + sh['cy'] > SLIDE_H - g['margin']):
-                bad.append('slide {0} shape {1} ({2}): x={3} y={4} cx={5} cy={6}'.format(
-                    s['index'], j, sh['role'], sh['x'], sh['y'], sh['cx'], sh['cy']))
+    for s in laid["slides"]:
+        for j, sh in enumerate(s["shapes"]):
+            if (
+                sh["x"] < g["margin"]
+                or sh["y"] < g["margin"]
+                or sh["x"] + sh["cx"] > SLIDE_W - g["margin"]
+                or sh["y"] + sh["cy"] > SLIDE_H - g["margin"]
+            ):
+                bad.append(
+                    "slide {0} shape {1} ({2}): x={3} y={4} cx={5} cy={6}".format(
+                        s["index"], j, sh["role"], sh["x"], sh["y"], sh["cx"], sh["cy"]
+                    )
+                )
     if bad:
-        raise VerifyError('도형이 여백 밖으로 나갔다 — 기하 버그다:\n  ' + '\n  '.join(bad))
+        raise VerifyError(
+            "도형이 여백 밖으로 나갔다 — 기하 버그다:\n  " + "\n  ".join(bad)
+        )
 
 
 # ── 폰트: 이름을 고르고 파일이 있는지만 확인한다 (바이너리 파싱 0줄) ─────────
 def norm_name(s):
-    return ''.join(ch for ch in str(s).lower() if ch.isalnum() and ch.isascii())
+    return "".join(ch for ch in str(s).lower() if ch.isalnum() and ch.isascii())
+
+
+# JavaScript String.prototype.trim() 이 지우는 문자. python 의 strip() 은 BOM 을 남기고 NEL 을 지워서 다르다.
+JS_TRIM = (
+    " \t\n\v\f\r\xa0\u1680"
+    + "".join(chr(c) for c in range(0x2000, 0x200B))
+    + "\u2028\u2029\u202f\u205f\u3000\ufeff"
+)
+
+
+def sanitize_font_name(s):
+    """build_a4p.js 의 sanitizeFontName 과 같은 정리. 두 빌더가 같은 이름을 적게 한다."""
+    if not isinstance(s, str):
+        return ""
+    return re.sub(r"[\x00-\x1f\x7f]", "", re.sub(r'["\'<>&]', "", s)).strip(JS_TRIM)
 
 
 def esc_fc(s):
     out = []
     for ch in str(s):
-        if ch in '-:,\\':
-            out.append('\\')
+        if ch in "-:,\\":
+            out.append("\\")
         out.append(ch)
-    return ''.join(out)
+    return "".join(out)
 
 
-_FC_STATE = {'available': None}
+_FC_STATE = {"available": None}
 
 
 def fc_match(pattern):
     """fc-match 로 이름 하나를 파일 + family 로 해석한다. 없으면 None (한 번 확인하면 기억한다)."""
-    if _FC_STATE['available'] is False:
+    if _FC_STATE["available"] is False:
         return None
     try:
         res = subprocess.run(
-            ['fc-match', '--format=%{file}|%{family}', pattern],
-            stdout=subprocess.PIPE, stderr=subprocess.PIPE,
-            universal_newlines=True, timeout=5)
+            ["fc-match", "--format=%{file}|%{family}", pattern],
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            universal_newlines=True,
+            timeout=5,
+        )
     except FileNotFoundError:
-        _FC_STATE['available'] = False
+        _FC_STATE["available"] = False
         return None
     except (OSError, subprocess.SubprocessError):
         return None
     if res.returncode != 0 or not res.stdout:
         return None
-    _FC_STATE['available'] = True
-    cut = res.stdout.find('|')
+    _FC_STATE["available"] = True
+    cut = res.stdout.find("|")
     if cut < 0:
         return None
     file_path = res.stdout[:cut].strip()
-    families = [f.strip() for f in res.stdout[cut + 1:].split(',') if f.strip()]
+    families = [f.strip() for f in res.stdout[cut + 1 :].split(",") if f.strip()]
     if not file_path:
         return None
-    return {'file': file_path, 'families': families}
+    return {"file": file_path, "families": families}
 
 
 def font_search_dirs():
-    home = os.path.expanduser('~')
-    if sys.platform == 'darwin':
-        return ['/System/Library/Fonts', '/Library/Fonts', os.path.join(home, 'Library', 'Fonts')]
-    if sys.platform.startswith('win'):
-        dirs = [os.path.join(os.environ.get('WINDIR') or 'C:\\Windows', 'Fonts')]
-        local = os.environ.get('LOCALAPPDATA')
+    home = os.path.expanduser("~")
+    if sys.platform == "darwin":
+        return [
+            "/System/Library/Fonts",
+            "/Library/Fonts",
+            os.path.join(home, "Library", "Fonts"),
+        ]
+    if sys.platform.startswith("win"):
+        dirs = [os.path.join(os.environ.get("WINDIR") or "C:\\Windows", "Fonts")]
+        local = os.environ.get("LOCALAPPDATA")
         if local:
-            dirs.append(os.path.join(local, 'Microsoft', 'Windows', 'Fonts'))
+            dirs.append(os.path.join(local, "Microsoft", "Windows", "Fonts"))
         return dirs
     return [
-        '/usr/share/fonts', '/usr/local/share/fonts',
-        os.path.join(home, '.local', 'share', 'fonts'), os.path.join(home, '.fonts'),
+        "/usr/share/fonts",
+        "/usr/local/share/fonts",
+        os.path.join(home, ".local", "share", "fonts"),
+        os.path.join(home, ".fonts"),
     ]
 
 
+def font_weight_rank(flat):
+    """같은 패밀리의 Bold 나 Black 이 먼저 걸리면 검증기가 다른 굵기의 메트릭으로 폭을 잰다. Regular 를 우선한다."""
+    if "regular" in flat or "normal" in flat:
+        return 0
+    if re.search(
+        r"bold|black|light|thin|medium|semi|extra|heavy|demi|italic|oblique", flat
+    ):
+        return 2
+    return 1
+
+
 def glob_font_file(name):
-    """fc-match 가 없는 환경용 파일명 탐색. 깊이·개수 예산을 둬서 병적인 트리에서도 끝난다."""
-    hints = FONT_FILE_HINTS.get(str(name).lower(), (norm_name(name),))
+    """fc-match 가 없는 환경용 파일명 탐색. 깊이·개수 예산을 둬서 병적인 트리에서도 끝난다. 순위는 결정론적이다."""
+    hints = [h for h in FONT_FILE_HINTS.get(str(name).lower(), (norm_name(name),)) if h]
+    if not hints:
+        return None
     budget = [20000]
+    found = []
 
     def walk(directory, depth):
         if depth > 6 or budget[0] <= 0:
-            return None
+            return
         try:
-            entries = list(os.scandir(directory))
+            entries = sorted(
+                os.scandir(directory), key=lambda e: e.name
+            )  # node 처럼 이름순
         except OSError:
-            return None
+            return
         subdirs = []
         for ent in entries:
             budget[0] -= 1
             if budget[0] <= 0:
-                return None
+                return
             full = os.path.join(directory, ent.name)
             try:
-                if ent.is_dir():
-                    subdirs.append(full)
+                # node 의 Dirent 처럼 링크 폴더는 따라가지 않는다. Windows junction 은 python 3.12 전까지
+                # 링크로 보지 않으므로 재분석 지점(0x400)인지 따로 본다. node 는 재분석 지점을 링크로 본다
+                if ent.is_dir(follow_symlinks=False):
+                    attrs = getattr(
+                        ent.stat(follow_symlinks=False), "st_file_attributes", 0
+                    )
+                    if not attrs & 0x400:
+                        subdirs.append(full)
                     continue
             except OSError:
                 continue
@@ -505,20 +628,19 @@ def glob_font_file(name):
                 continue
             flat = norm_name(stem)
             if any(h in flat for h in hints):
-                return full
+                found.append((font_weight_rank(flat), len(ent.name), full))
         for sub in subdirs:
-            hit = walk(sub, depth + 1)
-            if hit:
-                return hit
-        return None
+            walk(sub, depth + 1)
 
     for directory in font_search_dirs():
         if not os.path.exists(directory):
             continue
-        hit = walk(directory, 0)
-        if hit:
-            return hit
-    return None
+        walk(directory, 0)
+        if found:
+            break  # 검색 경로는 우선순위 순서다. 앞선 경로에서 찾으면 거기서 고른다
+    if not found:
+        return None
+    return sorted(found)[0][2]
 
 
 def find_font_file(name):
@@ -528,14 +650,26 @@ def find_font_file(name):
     돌려받은 family 가 요청한 이름과 실제로 맞는지 대조해야 한다. 안 그러면 이름이 거짓말이 된다.
     """
     want = norm_name(name)
+    if not want:
+        # ASCII 글자가 없는 이름(예: 나눔고딕)은 정리한 형태로 대조할 수 없다. 빈 문자열은 어떤 family 에나 들어 있다.
+        # fc-match 가 돌려준 family 원문과 정확히 같을 때만 찾은 것으로 본다. 파일명 탐색은 하지 않는다.
+        exact = str(name).strip().lower()
+        hit = fc_match(esc_fc(name))
+        if (
+            hit
+            and any(f.lower() == exact for f in hit["families"])
+            and os.path.exists(hit["file"])
+        ):
+            return hit["file"]
+        return None
+    # 한 방향(family 가 요청 이름을 품는가)만 본다. 반대 방향까지 허용하면
+    # "Noto Sans CJK KR" 을 요청했는데 "Noto Sans" 가 통과해 한글 없는 폰트에 그 이름이 붙는다.
     hit = fc_match(esc_fc(name))
-    if hit:
-        for fam in hit['families']:
-            n = norm_name(fam)
-            if n == want or want in n or n in want:
-                if os.path.exists(hit['file']):
-                    return hit['file']
-                break
+    if hit and any(
+        norm_name(f) == want or want in norm_name(f) for f in hit["families"]
+    ):
+        if os.path.exists(hit["file"]):
+            return hit["file"]
     globbed = glob_font_file(name)
     if globbed and os.path.exists(globbed):
         return globbed
@@ -550,32 +684,54 @@ def resolve_font(font_arg, meta_font):
     """
     warnings = []
     candidates = [
-        {'name': font_arg, 'from': '--font'},
-        {'name': os.environ.get('BANKER_PPTX_FONT'), 'from': 'BANKER_PPTX_FONT'},
-        {'name': meta_font if (meta_font and meta_font != 'auto') else '', 'from': 'meta.font'},
+        {"name": sanitize_font_name(font_arg), "from": "--font"},
+        {
+            "name": sanitize_font_name(os.environ.get("BANKER_PPTX_FONT")),
+            "from": "BANKER_PPTX_FONT",
+        },
+        {
+            "name": "" if meta_font == "auto" else sanitize_font_name(meta_font),
+            "from": "meta.font",
+        },
     ]
-    explicit = [c for c in candidates if isinstance(c['name'], str) and c['name'].strip() != '']
+    explicit = [c for c in candidates if c["name"] != ""]
 
     for c in explicit:
-        name = c['name'].strip()
+        name = c["name"]
         file_path = find_font_file(name)
         if file_path:
-            return {'name': name, 'file': file_path, 'from': c['from'], 'warnings': warnings}
-        warnings.append({'code': 'FONT_NOT_FOUND', 'from': c['from'], 'detail': name})
+            return {
+                "name": name,
+                "file": file_path,
+                "from": c["from"],
+                "warnings": warnings,
+            }
+        warnings.append({"code": "FONT_NOT_FOUND", "from": c["from"], "detail": name})
 
     for name in FONT_CHAIN:
         file_path = find_font_file(name)
         if file_path:
-            return {'name': name, 'file': file_path, 'from': 'chain', 'warnings': warnings}
-
-    sys_hit = fc_match('sans-serif:lang=ko')
-    if sys_hit and sys_hit['families'] and os.path.exists(sys_hit['file']):
-        return {'name': sys_hit['families'][0], 'file': sys_hit['file'],
-                'from': 'system', 'warnings': warnings}
-
-    fallback = explicit[0]['name'].strip() if explicit else FONT_CHAIN[0]
-    warnings.append({'code': 'FONT_FILE_UNRESOLVED', 'from': 'chain', 'detail': fallback})
-    return {'name': fallback, 'file': None, 'from': 'unresolved', 'warnings': warnings}
+            return {
+                "name": name,
+                "file": file_path,
+                "from": "chain",
+                "warnings": warnings,
+            }
+
+    sys_hit = fc_match("sans-serif:lang=ko")
+    if sys_hit and sys_hit["families"] and os.path.exists(sys_hit["file"]):
+        return {
+            "name": sys_hit["families"][0],
+            "file": sys_hit["file"],
+            "from": "system",
+            "warnings": warnings,
+        }
+
+    fallback = explicit[0]["name"] if explicit else FONT_CHAIN[0]
+    warnings.append(
+        {"code": "FONT_FILE_UNRESOLVED", "from": "chain", "detail": fallback}
+    )
+    return {"name": fallback, "file": None, "from": "unresolved", "warnings": warnings}
 
 
 # ── python-pptx 해석 (설치는 하지 않는다) ───────────────────────────────────
@@ -594,31 +750,40 @@ class Pptx(object):
 
 def pptx_missing_message(reason):
     """자동 설치는 하지 않는다. 사람이 읽고 스스로 고칠 수 있는 안내만 낸다(자식 프로세스 0개)."""
-    return '\n'.join([
-        'python-pptx 를 찾지 못했다. 이 스킬은 의존성을 자동 설치하지 않는다.',
-        '',
-        '  설치:  python -m pip install python-pptx',
-        '         (전역 설치가 막힌 환경이면 --target <dir> 로 받고 PYTHONPATH 에 그 경로를 넣는다)',
-        '  안내:  docs-setup 스킬이 이 스킬의 런타임 준비 절차를 담고 있다 (/banker:docs-setup).',
-        '  대안:  node 를 쓸 수 있으면 build_a4p.js (pptxgenjs) 로 같은 deck JSON 을 빌드한다.',
-        '         검증기 verify_a4p.mjs 는 node 전용이라 검증 경로는 어느 쪽이든 node 를 요구한다.',
-        '',
-        '  인터프리터: {0} (python {1}.{2}.{3})'.format(
-            sys.executable or '(알 수 없음)', *sys.version_info[:3]),
-        '  sys.path:   {0}'.format(', '.join(p for p in sys.path if p) or '(비어 있음)'),
-        '  원인:       {0}'.format(reason),
-    ])
+    return "\n".join(
+        [
+            "python-pptx 를 찾지 못했다. 이 스킬은 의존성을 자동 설치하지 않는다.",
+            "",
+            "  설치:  python -m pip install python-pptx",
+            "         (전역 설치가 막힌 환경이면 --target <dir> 로 받고 PYTHONPATH 에 그 경로를 넣는다)",
+            "  안내:  docs-setup 스킬이 이 스킬의 런타임 준비 절차를 담고 있다 (/banker:docs-setup).",
+            "  대안:  node 를 쓸 수 있으면 build_a4p.js (pptxgenjs) 로 같은 deck JSON 을 빌드한다.",
+            "         검증기 verify_a4p.mjs 는 node 전용이라 검증 경로는 어느 쪽이든 node 를 요구한다.",
+            "",
+            "  인터프리터: {0} (python {1}.{2}.{3})".format(
+                sys.executable or "(알 수 없음)", *sys.version_info[:3]
+            ),
+            "  sys.path:   {0}".format(
+                ", ".join(p for p in sys.path if p) or "(비어 있음)"
+            ),
+            "  원인:       {0}".format(reason),
+        ]
+    )
 
 
 def load_pptx():
     if sys.version_info < MIN_PYTHON:
         raise EnvError(
-            'python {0}.{1} 이상이 필요하다 (실행 중인 인터프리터: {2} — python {3}.{4}.{5}).\n'
-            '  이 파일은 셰방에 의존하지 않는다. 쓸 인터프리터를 직접 지정해 부른다:\n'
-            '    /path/to/python{0}.{1}+ build_a4p.py --in deck.json --out out.pptx\n'
-            '  안내: docs-setup 스킬 (/banker:docs-setup).'.format(
-                MIN_PYTHON[0], MIN_PYTHON[1], sys.executable or '(알 수 없음)',
-                *sys.version_info[:3]))
+            "python {0}.{1} 이상이 필요하다 (실행 중인 인터프리터: {2} — python {3}.{4}.{5}).\n"
+            "  이 파일은 셰방에 의존하지 않는다. 쓸 인터프리터를 직접 지정해 부른다:\n"
+            "    /path/to/python{0}.{1}+ build_a4p.py --in deck.json --out out.pptx\n"
+            "  안내: docs-setup 스킬 (/banker:docs-setup).".format(
+                MIN_PYTHON[0],
+                MIN_PYTHON[1],
+                sys.executable or "(알 수 없음)",
+                *sys.version_info[:3],
+            )
+        )
     try:
         from pptx import Presentation
         from pptx.util import Emu, Pt
@@ -638,10 +803,12 @@ def strip_sldsz_type(prs, qn):
     선언 쪽을 믿는 뷰어·변환기가 있다. OOXML 에서 이 속성의 기본값이 custom 이므로
     지우는 것이 곧 custom 선언이다.
     """
-    sldsz = prs._element.find(qn('p:sldSz'))
+    sldsz = prs._element.find(qn("p:sldSz"))
     if sldsz is None:
-        raise VerifyError('p:sldSz 를 찾지 못했다 — python-pptx 기본 템플릿이 예상과 다르다.')
-    sldsz.attrib.pop('type', None)
+        raise VerifyError(
+            "p:sldSz 를 찾지 못했다 — python-pptx 기본 템플릿이 예상과 다르다."
+        )
+    sldsz.attrib.pop("type", None)
     return sldsz
 
 
@@ -654,15 +821,15 @@ def fix_body_pr(tf, mod):
     도형 크기를 바꾼다 — 저장된 a:ext 는 맞는데 화면에서 INV-G 가 깨지는 상태다.
     속성을 넣는 순서가 곧 XML 의 속성 순서다. 위 문자열과 같은 순서로 넣는다.
     """
-    tf.word_wrap = True                     # wrap="square"
+    tf.word_wrap = True  # wrap="square"
     tf.margin_left = mod.Emu(0)
     tf.margin_top = mod.Emu(0)
     tf.margin_right = mod.Emu(0)
     tf.margin_bottom = mod.Emu(0)
     body_pr = tf._txBody.bodyPr
-    body_pr.set('rtlCol', '0')
+    body_pr.set("rtlCol", "0")
     tf.vertical_anchor = mod.MSO_ANCHOR.TOP  # anchor="t"
-    for tag in ('a:spAutoFit', 'a:normAutofit', 'a:noAutofit'):
+    for tag in ("a:spAutoFit", "a:normAutofit", "a:noAutofit"):
         el = body_pr.find(mod.qn(tag))
         if el is not None:
             body_pr.remove(el)
@@ -672,12 +839,12 @@ def style_paragraph(paragraph, mod):
     """문단 속성도 node 산출물과 맞춘다: 왼쪽 정렬 · 들여쓰기 0 · 줄간 1.2 · 불릿 글리프 없음."""
     paragraph.alignment = mod.PP_ALIGN.LEFT
     p_pr = paragraph._p.get_or_add_pPr()
-    p_pr.set('indent', '0')
-    p_pr.set('marL', '0')
+    p_pr.set("indent", "0")
+    p_pr.set("marL", "0")
     paragraph.line_spacing = LINE_SPACING
     # 불릿 글리프는 항목 텍스트 앞의 '• ' 로 직접 그린다. 목록 자동 글리프가 붙으면 두 번 찍힌다.
-    if p_pr.find(mod.qn('a:buNone')) is None:
-        p_pr.append(p_pr.makeelement(mod.qn('a:buNone'), {}))
+    if p_pr.find(mod.qn("a:buNone")) is None:
+        p_pr.append(p_pr.makeelement(mod.qn("a:buNone"), {}))
 
 
 def set_run(run, text, pt, bold, color, typeface, mod):
@@ -694,12 +861,12 @@ def set_run(run, text, pt, bold, color, typeface, mod):
     font.color.rgb = mod.RGBColor.from_string(color)
     font.name = typeface
     r_pr = run._r.get_or_add_rPr()
-    for tag in ('a:latin', 'a:ea', 'a:cs'):
+    for tag in ("a:latin", "a:ea", "a:cs"):
         el = r_pr.find(mod.qn(tag))
         if el is None:
             el = r_pr.makeelement(mod.qn(tag), {})
             r_pr.append(el)
-        el.set('typeface', typeface)
+        el.set("typeface", typeface)
 
 
 # OPC core property `title` 의 길이 상한. OOXML 규격이 아니라 python-pptx 가 스스로 거는 제한인데,
@@ -721,38 +888,53 @@ def build(laid, out_path, font, deck, mod, warnings=None):
     prs.slide_height = mod.Emu(SLIDE_H)
     strip_sldsz_type(prs, mod.qn)
 
-    meta = deck.get('meta') or {}
-    if meta.get('title'):
-        value, truncated = clamp_core_title(meta['title'])
+    meta = deck.get("meta") or {}
+    if meta.get("title"):
+        value, truncated = clamp_core_title(meta["title"])
         if truncated and warnings is not None:
-            warnings.append({'code': 'TITLE_TRUNCATED', 'from': 'meta.title',
-                             'detail': '{0} -> {1}'.format(len(meta['title']), CORE_TITLE_MAX)})
+            warnings.append(
+                {
+                    "code": "TITLE_TRUNCATED",
+                    "from": "meta.title",
+                    "detail": "{0} -> {1}".format(len(meta["title"]), CORE_TITLE_MAX),
+                }
+            )
         # 클램프가 막아 주지만, 라이브러리가 거는 다른 상한이 남아 있을 수 있다.
         # 원시 트레이스백이 새면 exit code 계약(입력 문제 = 3)이 깨지므로 UsageError 로 들여보낸다.
         try:
             prs.core_properties.title = value
         except ValueError as err:
-            raise UsageError('meta.title 을 core property 로 쓸 수 없다: {0}'.format(err))
+            raise UsageError(
+                "meta.title 을 core property 로 쓸 수 없다: {0}".format(err)
+            )
 
     # 빈 레이아웃만 쓴다. 기본 템플릿의 자리표시자는 4:3 좌표를 들고 있어서
     # A4 로 바꾼 슬라이드에 얹으면 좌표가 규격 밖으로 나간다.
     blank = prs.slide_layouts[6]
 
-    for s in laid['slides']:
+    for s in laid["slides"]:
         slide = prs.slides.add_slide(blank)
-        for sh in s['shapes']:
+        for sh in s["shapes"]:
             box = slide.shapes.add_textbox(
-                mod.Emu(sh['x']), mod.Emu(sh['y']), mod.Emu(sh['cx']), mod.Emu(sh['cy']))
+                mod.Emu(sh["x"]), mod.Emu(sh["y"]), mod.Emu(sh["cx"]), mod.Emu(sh["cy"])
+            )
             tf = box.text_frame
             fix_body_pr(tf, mod)
             # 개행은 문단으로 편다 — node 쪽(pptxgenjs)이 '\n' 마다 <a:p> 를 하나씩 내고,
             # 빈 줄에는 run 을 만들지 않는다. 그 모양을 그대로 따른다.
-            for i, line in enumerate(str(sh['text']).split('\n')):
+            for i, line in enumerate(str(sh["text"]).split("\n")):
                 paragraph = tf.paragraphs[0] if i == 0 else tf.add_paragraph()
                 style_paragraph(paragraph, mod)
-                if line != '':
-                    set_run(paragraph.add_run(), line, sh['pt'], sh['bold'],
-                            sh['color'], font['name'], mod)
+                if line != "":
+                    set_run(
+                        paragraph.add_run(),
+                        line,
+                        sh["pt"],
+                        sh["bold"],
+                        sh["color"],
+                        font["name"],
+                        mod,
+                    )
 
     prs.save(out_path)
     return out_path
@@ -760,35 +942,48 @@ def build(laid, out_path, font, deck, mod, warnings=None):
 
 # ── 출력 ────────────────────────────────────────────────────────────────────
 def human_report(laid, font, out_path, warnings):
-    g = laid['grid']
-    shapes = sum(len(s['shapes']) for s in laid['slides'])
-    pages = len(set(s['pageIndex'] for s in laid['slides']))
+    g = laid["grid"]
+    shapes = sum(len(s["shapes"]) for s in laid["slides"])
+    pages = len(set(s["pageIndex"] for s in laid["slides"]))
     lines = [
-        'vertical-pptx (python 빌더)',
-        '  용지      A4 세로 210x297mm · sldSz {0} x {1} EMU'.format(SLIDE_W, SLIDE_H),
-        '  여백      {0}mm · 그리드 {1}열 x {2}행 · 거터 4mm'.format(g['marginMm'], COLS, ROWS),
-        '  칸        컬럼 {0} · 행 {1} · 피치 {2} / {3} EMU'.format(
-            g['colW'], g['rowH'], g['colPitch'], g['rowPitch']),
+        "vertical-pptx (python 빌더)",
+        "  용지      A4 세로 210x297mm · sldSz {0} x {1} EMU".format(SLIDE_W, SLIDE_H),
+        "  여백      {0}mm · 그리드 {1}열 x {2}행 · 거터 4mm".format(
+            g["marginMm"], COLS, ROWS
+        ),
+        "  칸        컬럼 {0} · 행 {1} · 피치 {2} / {3} EMU".format(
+            g["colW"], g["rowH"], g["colPitch"], g["rowPitch"]
+        ),
     ]
     if font:
-        note = '' if font['file'] else '  (파일 미해석 — 검증기 폭 판정은 estimate 로 내려간다)'
-        lines.append('  폰트      {0}{1}'.format(font['name'], note))
-        lines.append('            {0}'.format(font['file'] or '(경로 없음)'))
-    lines.append('  본문      {0}pt · 줄간 {1}'.format(fmt_num(laid['bodyPt']), LINE_SPACING))
-    lines.append('  슬라이드  {0} (deck 페이지 {1}개)'.format(len(laid['slides']), pages))
-    lines.append('  도형      {0}'.format(shapes))
-    lines.append('  경고      {0}'.format(len(warnings)))
+        note = (
+            ""
+            if font["file"]
+            else "  (파일 미해석 — 검증기 폭 판정은 estimate 로 내려간다)"
+        )
+        lines.append("  폰트      {0}{1}".format(font["name"], note))
+        lines.append("            {0}".format(font["file"] or "(경로 없음)"))
+    lines.append(
+        "  본문      {0}pt · 줄간 {1}".format(fmt_num(laid["bodyPt"]), LINE_SPACING)
+    )
+    lines.append(
+        "  슬라이드  {0} (deck 페이지 {1}개)".format(len(laid["slides"]), pages)
+    )
+    lines.append("  도형      {0}".format(shapes))
+    lines.append("  경고      {0}".format(len(warnings)))
     for w in warnings:
-        if w.get('page') is not None:
-            where = 'page {0} block {1}'.format(w['page'], w['block'])
-        elif w.get('from') is not None:
-            where = w['from']
+        if w.get("page") is not None:
+            where = "page {0} block {1}".format(w["page"], w["block"])
+        elif w.get("from") is not None:
+            where = w["from"]
         else:
-            where = ''
-        lines.append('    {0}  {1}  {2}'.format(w['code'], where, w.get('detail') or '').rstrip())
+            where = ""
+        lines.append(
+            "    {0}  {1}  {2}".format(w["code"], where, w.get("detail") or "").rstrip()
+        )
     if out_path:
-        lines.append('  출력      {0}'.format(out_path))
-    return '\n'.join(lines)
+        lines.append("  출력      {0}".format(out_path))
+    return "\n".join(lines)
 
 
 def fmt_num(value):
@@ -799,105 +994,111 @@ def fmt_num(value):
 
 
 def status_json(font, slides, warnings):
-    return json.dumps({
-        'skill': 'vertical-pptx',
-        'builder': 'python',
-        'font': font['name'] if font else None,
-        'fontFile': font['file'] if font else None,
-        'slides': slides,
-        'warnings': warnings,
-    }, ensure_ascii=False, separators=(',', ':'))
+    return json.dumps(
+        {
+            "skill": "vertical-pptx",
+            "builder": "python",
+            "font": font["name"] if font else None,
+            "fontFile": font["file"] if font else None,
+            "slides": slides,
+            "warnings": warnings,
+        },
+        ensure_ascii=False,
+        separators=(",", ":"),
+    )
 
 
 # ── CLI ─────────────────────────────────────────────────────────────────────
-USAGE = '\n'.join([
-    'vertical-pptx / build_a4p.py — A4 세로(210x297mm) PPTX python 빌더',
-    '',
-    '사용법:',
-    '  python build_a4p.py --in deck.json --out out.pptx [--font <이름>]',
-    '',
-    '옵션:',
-    '  --in <deck.json>   deck JSON 입력 (두 빌더의 유일한 계약)',
-    '  --out <경로>       .pptx 출력 경로',
-    '  --font <이름>      폰트 이름을 직접 지정. 체인: --font → BANKER_PPTX_FONT → meta.font',
-    '                     → Noto Sans CJK KR → Malgun Gothic → Apple SD Gothic Neo → NanumGothic'
-    ' → 시스템 한국어 sans',
-    '  -h, --help         이 도움말',
-    '',
-    '입력은 deck JSON 뿐이다. 마크다운 변환 플래그는 이 빌더에 없다 —',
-    '원고를 deck JSON 으로 바꾸는 일은 node 빌더(build_a4p.js)가 단독으로 맡는다.',
-    '이 프로젝트의 마크다운 파서는 그 한 벌뿐이고, 두 벌이 되는 순간 같은 원고가 두 개의 덱이 된다.',
-    '',
-    '요구 사항: python 3.9 이상 · python-pptx (자동 설치하지 않는다)',
-    '이 파일은 셰방에 의존하지 않는다. 쓸 인터프리터를 직접 지정해 부르는 것이 안전하다.',
-    '',
-    '종료 코드: 0 통과 · 1 검증 실패 · 2 환경 미비(python 버전·python-pptx) · 3 사용법 오류',
-])
+USAGE = "\n".join(
+    [
+        "vertical-pptx / build_a4p.py — A4 세로(210x297mm) PPTX python 빌더",
+        "",
+        "사용법:",
+        "  python build_a4p.py --in deck.json --out out.pptx [--font <이름>]",
+        "",
+        "옵션:",
+        "  --in <deck.json>   deck JSON 입력 (두 빌더의 유일한 계약)",
+        "  --out <경로>       .pptx 출력 경로",
+        "  --font <이름>      폰트 이름을 직접 지정. 체인: --font → BANKER_PPTX_FONT → meta.font",
+        "                     → Noto Sans CJK KR → Noto Sans KR → Malgun Gothic → Apple SD Gothic Neo"
+        " → AppleGothic → NanumGothic → 시스템 한국어 sans",
+        "  -h, --help         이 도움말",
+        "",
+        "입력은 deck JSON 뿐이다. 마크다운 변환 플래그는 이 빌더에 없다 —",
+        "원고를 deck JSON 으로 바꾸는 일은 node 빌더(build_a4p.js)가 단독으로 맡는다.",
+        "이 프로젝트의 마크다운 파서는 그 한 벌뿐이고, 두 벌이 되는 순간 같은 원고가 두 개의 덱이 된다.",
+        "",
+        "요구 사항: python 3.9 이상 · python-pptx (자동 설치하지 않는다)",
+        "이 파일은 셰방에 의존하지 않는다. 쓸 인터프리터를 직접 지정해 부르는 것이 안전하다.",
+        "",
+        "종료 코드: 0 통과 · 1 검증 실패 · 2 환경 미비(python 버전·python-pptx) · 3 사용법 오류",
+    ]
+)
 
 
 def parse_args(argv):
-    opts = {'in': '', 'out': '', 'fontArg': '', 'help': False}
+    opts = {"in": "", "out": "", "fontArg": "", "help": False}
     i = 0
     while i < len(argv):
         a = argv[i]
 
         def need(name):
-            if i + 1 >= len(argv) or argv[i + 1].startswith('--'):
-                raise UsageError('{0} 에 값이 필요하다.'.format(name))
+            if i + 1 >= len(argv) or argv[i + 1].startswith("--"):
+                raise UsageError("{0} 에 값이 필요하다.".format(name))
             return argv[i + 1]
 
-        if a == '--in':
-            opts['in'] = need('--in')
+        if a == "--in":
+            opts["in"] = need("--in")
             i += 1
-        elif a == '--out':
-            opts['out'] = need('--out')
+        elif a == "--out":
+            opts["out"] = need("--out")
             i += 1
-        elif a == '--font':
-            opts['fontArg'] = need('--font')
+        elif a == "--font":
+            opts["fontArg"] = need("--font")
             i += 1
-        elif a in ('-h', '--help'):
-            opts['help'] = True
+        elif a in ("-h", "--help"):
+            opts["help"] = True
         else:
-            raise UsageError('알 수 없는 인자: {0}\n\n{1}'.format(a, USAGE))
+            raise UsageError("알 수 없는 인자: {0}\n\n{1}".format(a, USAGE))
         i += 1
     return opts
 
 
 def read_deck_file(path):
     try:
-        with open(path, 'r', encoding='utf-8') as fh:
+        with open(path, "r", encoding="utf-8") as fh:
             text = fh.read()
     except OSError as exc:
-        raise UsageError('deck JSON 을 읽지 못했다: {0}'.format(exc))
+        raise UsageError("deck JSON 을 읽지 못했다: {0}".format(exc))
     try:
         return json.loads(text)
     except ValueError as exc:
-        raise UsageError('deck JSON 파싱 실패 ({0}): {1}'.format(path, exc))
+        raise UsageError("deck JSON 파싱 실패 ({0}): {1}".format(path, exc))
 
 
 def run_main(argv):
     opts = parse_args(argv)
-    if opts['help'] or not opts['in']:
-        sys.stdout.write(USAGE + '\n')
-        return EXIT_OK if opts['help'] else EXIT_USAGE
-    if not opts['out']:
-        raise UsageError('--out <경로> 가 필요하다.')
+    if opts["help"] or not opts["in"]:
+        sys.stdout.write(USAGE + "\n")
+        return EXIT_OK if opts["help"] else EXIT_USAGE
+    if not opts["out"]:
+        raise UsageError("--out <경로> 가 필요하다.")
 
-    deck = read_deck_file(opts['in'])
+    deck = read_deck_file(opts["in"])
     laid = layout(deck)  # validate_deck 포함 — 스키마 위반은 여기서 exit 3
-    warnings = list(laid['warnings'])
+    warnings = list(laid["warnings"])
     assert_inside_slide(laid)
 
     # ★ python-pptx 해석을 폰트 해석보다 먼저 한다.
     #   환경이 미비하면 자식 프로세스(fc-match)를 하나도 띄우지 않고 exit 2 로 나간다.
     mod = load_pptx()
-    meta = deck.get('meta') or {}
-    font = resolve_font(opts['fontArg'], meta.get('font'))
-    warnings.extend(font['warnings'])
+    meta = deck.get("meta") or {}
+    font = resolve_font(opts["fontArg"], meta.get("font"))
+    warnings.extend(font["warnings"])
 
-    out_path = build(laid, os.path.abspath(opts['out']), font, deck, mod, warnings)
-    sys.stdout.write(human_report(laid, font, out_path, warnings) + '\n')
-    sys.stdout.write(status_json(font, len(laid['slides']), warnings) + '\n')
+    out_path = build(laid, os.path.abspath(opts["out"]), font, deck, mod, warnings)
+    sys.stdout.write(human_report(laid, font, out_path, warnings) + "\n")
+    sys.stdout.write(status_json(font, len(laid["slides"]), warnings) + "\n")
     return EXIT_OK
 
 
@@ -908,9 +1109,9 @@ def main(argv):
         # 환경 미비(exit 2)는 사용자가 그대로 따라 할 수 있는 안내라서 stdout 으로 낸다.
         # 나머지 오류는 stderr.
         stream = sys.stdout if err.exit_code == EXIT_ENV else sys.stderr
-        stream.write('{0}\n'.format(err))
+        stream.write("{0}\n".format(err))
         return err.exit_code
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     sys.exit(main(sys.argv[1:]))