@lark-apaas/coding-steering 0.1.18-dev.2bb478f → 0.1.18-dev.40f9427

package/steering/design-html/skills/pptx-style-extract/scripts/draft.py

@@ -0,0 +1,1705 @@
+#!/usr/bin/env python3
+"""S15 草案生成器：把阶段一产物机械推导成「判断单草案 + 一页简报 + 候选联系表」。
+
+    python3 draft.py <stage1-outdir>
+
+产出 <stage1-outdir>/l-out/：
+    BRIEF.md          唯一必读简报：事实 + 草案依据 + 待判断清单
+    contact-sheet.png 候选图拼版（带编号，一次看完所有图）
+    manifest.yaml / frontmatter.yaml / layouts.yaml / body.md   四件草案，可直接进 package.py
+
+草案里所有数值都来自 extract.json；凡是需要「像人一样看」才能定的，写成 `TODO:` 行
+（package.py 见 TODO 即 FAIL），由 L 层改掉。
+"""
+import argparse
+import json
+import os
+import re
+import shutil
+import sys
+from collections import Counter, defaultdict
+
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+from ooxml import OFFICE_DEFAULT_FONTS              # noqa: E402
+from census import (ASSET_WARN_SINGLE, FULLSCREEN_COVERAGE, LUM_MID,   # noqa: E402
+                    REPEAT_MIN, SMALL_IMG_W_PCT, canvas_coverage)
+
+FILL_MANY = 5          # 「被大量当填充铺开」的次数下限，用于区分卡片底与偶发用色
+BG_CONTENT_CAP = 5     # 内容页背景收几张：再多消费端也挑不过来，超出的写进 TODO 交人取舍
+
+HERE = os.path.dirname(os.path.abspath(__file__))
+SKILL_ROOT = os.path.dirname(HERE)
+SYS_FALLBACK = '"PingFang SC", "Microsoft YaHei", sans-serif'
+
+
+# ---------------------------------------------------------------- 小工具
+def hex2rgb(h):
+    h = h.lstrip('#')
+    return tuple(int(h[i:i + 2], 16) for i in (0, 2, 4))
+
+
+def lum(rgb):
+    return (0.2126 * rgb[0] + 0.7152 * rgb[1] + 0.0722 * rgb[2]) / 255.0
+
+
+def satu(rgb):
+    mx, mn = max(rgb), min(rgb)
+    return 0.0 if mx == 0 else (mx - mn) / mx
+
+
+def slide_no(part):
+    m = re.search(r'slide(\d+)\.xml$', part)
+    return int(m.group(1)) if m else 9999
+
+
+def walk_sz(node, out):
+    if isinstance(node, dict):
+        if 'sz_px' in node and isinstance(node['sz_px'], (int, float)):
+            out.append(node['sz_px'])
+        for v in node.values():
+            walk_sz(v, out)
+    elif isinstance(node, list):
+        for v in node:
+            walk_sz(v, out)
+
+
+def shape_sz(s):
+    out = []
+    walk_sz(s.get('text') or {}, out)
+    walk_sz(s.get('lstStyle') or {}, out)
+    return max(out) if out else 0.0
+
+
+def shape_text(s, limit=24):
+    buf = []
+    for p in (s.get('text') or {}).get('paragraphs', []):
+        for r in p.get('runs', []):
+            t = (r.get('text') or '').strip()
+            if t:
+                buf.append(t)
+    txt = ' '.join(buf).replace('\n', ' ')
+    return txt[:limit]
+
+
+def q(v):
+    """写进 YAML 的标量：需要引号的加引号。"""
+    s = str(v)
+    if s and (s[0] in '#{[&*!|>%@`"\'' or ': ' in s or s.strip() != s):
+        return '"%s"' % s.replace('"', '\\"')
+    return s
+
+
+# ---------------------------------------------------------------- 颜色
+def bg_colors(d):
+    """页面/版式/母版的 `background` 声明里出现的底色，按声明次数排序。
+
+    「哪个色是底色」是直读事实（bgPr / bgRef），不用靠亮度猜：渐变里出现的浅色，
+    亮度可能比真底色更像底色。
+    """
+    cnt = Counter()
+    rows = (d.get('slides') or []) + (d.get('layouts') or []) \
+        + ((d.get('masters') or {}).get('masters') or [])
+    for row in rows:
+        bg = row.get('background')
+        if not isinstance(bg, dict):
+            continue
+        cols = []
+        if isinstance(bg.get('color'), dict):
+            cols.append(bg['color'])
+        for st in (bg.get('stops') or []):
+            if isinstance(st.get('color'), dict):
+                cols.append(st['color'])
+        for c in cols:
+            h = (c.get('hex') or '').upper()
+            if h:
+                cnt[h] += 1
+    return [h for h, _ in cnt.most_common()]
+
+
+def _gap_cut(vals, lo, hi):
+    """在排序后的值里找最大间隙，切点取间隙中点。
+
+    不用中位数：中位数会正好落在某个样本自己身上，它归哪边就只取决于写 >= 还是 >，
+    纯属任意。真正的分界在两族之间的空档里。夹在 [lo, hi] 内，避免整套同色的模板
+    把界推到极端。
+    """
+    v = sorted(vals)
+    if len(v) < 2:
+        return (lo + hi) / 2.0
+    _, mid = max((v[i + 1] - v[i], (v[i + 1] + v[i]) / 2.0) for i in range(len(v) - 1))
+    return min(max(mid, lo), hi)
+
+
+def palette_cuts(rows):
+    """「有彩 vs 中性」「深 vs 浅」的分界，按本模板自己的色分布切。
+
+    固定分界必然错一边：低饱和的莫兰迪配色整套都在低位，高饱和的品牌配色整套都在高位。
+    """
+    sat_cut = _gap_cut([r['sat'] for r in rows], 0.12, 0.45)
+    lums = sorted(r['lum'] for r in rows) or [0.0]
+    return sat_cut, lums[len(lums) // 2]
+
+
+def draft_colors(d, cusage=None):
+    """色板 token：名字按**实际用法**定，不只看亮度饱和度。
+
+    只看 lum/sat 会把「主要用来填色的纯黑」命名成 ink（文字色）、把「只出现在渐变里的
+    浅蓝」命名成 surface-alt。这里先看它在形状上主要干什么，再结合
+    亮度定名；用量太少的直接不进色板。
+    """
+    cusage = cusage or {}
+    pool = [c for c in d['color_freq']
+            if c.get('class') == 'design' and abs((c.get('alpha') or 100) - 100) < 0.1]
+    seen, rows = set(), []
+    for c in pool:
+        h = c['hex'].upper()
+        if h in seen:
+            continue
+        seen.add(h)
+        rgb = hex2rgb(h)
+        u = cusage.get(h) or Counter()
+        tot = sum(u.values())
+        main = u.most_common(1)[0][0] if tot else None
+        rows.append({'hex': h, 'n': c['n'], 'lum': lum(rgb), 'sat': satu(rgb),
+                     'use': u, 'use_n': tot, 'main': main})
+    # 用量只用来**命名**，不作准入门槛——color_usage 只数形状级的填充/描边/文字，
+    # 背景 p:bg 与主题色不在其中，拿它筛会把色板砍到只剩极少数几个。
+    strong = sorted(rows, key=lambda r: -r['n'])
+
+    SAT_CUT, LUM_CUT = palette_cuts(rows)
+
+    tokens, used = [], set()
+
+    def take(pred, names):
+        for name in names:
+            for r in strong:
+                if r['hex'] in used or not pred(r):
+                    continue
+                used.add(r['hex'])
+                tokens.append((name, r))
+                break
+
+    def kind(r):
+        if r['main'] == '文字':
+            return 'text'
+        if r['main'] in ('填充', '渐变', '描边'):
+            return 'paint'
+        return 'unknown'        # 形状层看不到用法，退回亮度/饱和度判断
+
+    # 墨色：主要用来写字（或看不出用法但本身是深中性色），且不是彩色
+    take(lambda r: r['sat'] < SAT_CUT and r['lum'] < min(LUM_CUT, LUM_MID)
+         and (kind(r) == 'text' or kind(r) == 'unknown'), ['ink', 'ink-muted'])
+    # 底色：直接取页面 background 声明里的色，按声明次数排
+    grounds = bg_colors(d)
+    for name in ('surface', 'surface-alt'):
+        for h in grounds:
+            r = next((x for x in strong if x['hex'] == h and x['hex'] not in used), None)
+            if r:
+                used.add(r['hex'])
+                tokens.append((name, r))
+                break
+
+    # 卡片/面板底：页面底色之外，真被大量当填充铺开的浅色（≥5 处才算）
+    take(lambda r: r['lum'] > max(LUM_CUT, 0.85) and r['sat'] < SAT_CUT
+         and (r['use'].get('填充') or 0) >= FILL_MANY, ['surface-raised'])
+    # 表达色：有彩度的按频次排
+    take(lambda r: r['sat'] >= SAT_CUT, ['primary', 'accent', 'accent-2', 'accent-3'])
+    # 其余低饱和色一律 neutral-N——它到底是卡片底、分隔线还是描边，数据分不出来，
+    # 就不要用名字去替消费方下结论；真实用法写在 Colors 表的用途列里。
+    take(lambda r: r['sat'] < SAT_CUT, ['neutral', 'neutral-2', 'neutral-3'])
+    rest = [r for r in rows if r['hex'] not in used][:6]
+    return tokens, rest, rows
+
+
+
+# ---------------------------------------------------------------- 字体
+def parse_fallback_table():
+    path = os.path.join(SKILL_ROOT, 'font-fallback.yaml')
+    if not os.path.exists(path):
+        return []
+    fams, cur = [], None
+    for line in open(path, encoding='utf-8'):
+        m = re.match(r'\s*-\s*family:\s*(.+)', line)
+        if m:
+            cur = {'family': m.group(1).strip(), 'match': [], 'fallback': [], 'category': ''}
+            fams.append(cur)
+            continue
+        if cur is None:
+            continue
+        m = re.match(r'\s*(match|fallback):\s*\[(.*)\]', line)
+        if m:
+            cur[m.group(1)] = [x.strip().strip('"\'') for x in m.group(2).split(',') if x.strip()]
+        m = re.match(r'\s*category:\s*(.+)', line)
+        if m:
+            cur['category'] = m.group(1).strip()
+    return fams
+
+
+def norm(s):
+    return re.sub(r'[\s\-_]', '', s or '').lower()
+
+
+OFFICE_DEFAULT_FONTS_NORM = {norm(x) for x in OFFICE_DEFAULT_FONTS}
+
+
+def cover_slot_colors(tokens, archetypes, rows, cusage):
+    """slot 里出现的每个色值都必须在色板里有名字。
+
+    Hard Rules 写「颜色只用 colors 里的 token」，而 slot 的 color 是从模板直读的，
+    两者不对齐就等于产物自己违反自己的规则——slot 的色值直读自模板，未必都已进
+    色板。这里把缺的补进色板，按用法归族命名。
+    """
+    have = {r['hex'].upper() for _, r in tokens}
+    by_hex = {r['hex'].upper(): r for r in rows}
+    sat_cut, lum_cut = palette_cuts(rows)      # 与 draft_colors 同一套切点，别各切各的
+    used = [n for n, _ in tokens]
+
+    def nxt(fam):
+        if fam not in used:
+            return fam
+        i = 2
+        while '%s-%d' % (fam, i) in used:
+            i += 1
+        return '%s-%d' % (fam, i)
+
+    added = []
+    for a in archetypes:
+        for s in a['slots']:
+            h = (s.get('color') or '').upper()
+            if not h.startswith('#') or h in have:
+                continue
+            have.add(h)
+            r = by_hex.get(h)
+            if r is None:            # 普查里没有这个色（理论上不该发生），跳过不编造
+                continue
+            fam = ('ink' if r['sat'] < sat_cut and r['lum'] < min(lum_cut, LUM_MID)
+                   else 'accent' if r['sat'] >= sat_cut else 'neutral')
+            name = nxt(fam)
+            used.append(name)
+            tokens.append((name, r))
+            added.append((name, h))
+    return added
+
+
+def draft_fonts(d):
+    table = parse_fallback_table()
+    groups = defaultdict(lambda: {'rendered': 0, 'weights': set(), 'names': set(), 'bold': 0})
+    for f in d['font_families']:
+        if not f.get('rendered_n'):
+            continue
+        key = f.get('alias_group') or f['family']
+        g = groups[key]
+        g['rendered'] += f['rendered_n']
+        g['names'].add(f['family'])
+        g['bold'] += f.get('bold_runs') or 0
+        for v in f.get('variants', []):
+            if v.get('weight'):
+                g['weights'].add(v['weight'])
+    ranked = sorted(groups.items(), key=lambda kv: -kv[1]['rendered'])
+
+    def resolve(names):
+        for n in names:
+            for fam in table:
+                for m in fam['match']:
+                    if norm(m) == norm(n) or norm(m) in norm(n) or norm(n) in norm(m):
+                        return fam
+        return None
+
+    out = []
+    for key, g in ranked[:4]:
+        fam = resolve(sorted(g['names'], key=len))
+        stack = [sorted(g['names'], key=len)[0]]
+        if fam:
+            stack += [x for x in fam['fallback'] if x not in stack]
+        out.append({
+            'key': key, 'rendered': g['rendered'], 'names': sorted(g['names']),
+            'weights': sorted(g['weights']) or ([600] if g['bold'] else [400]),
+            'stack': stack, 'mapped': fam['family'] if fam else None,
+            'category': fam['category'] if fam else '',
+        })
+    return out
+
+
+def font_css(stack):
+    return ', '.join('"%s"' % s for s in stack) + ', ' + SYS_FALLBACK
+
+
+MIRROR = 'https://miaoda.feishu.cn/fonts/css2'
+
+
+def import_line(fonts):
+    """降级链里用到的镜像字体拼成一行 @import（check_v1 硬要求）。"""
+    webs = []
+    for f in fonts[:2]:
+        for name in f['stack'][1:]:
+            if name not in webs:
+                webs.append(name)
+    if not webs:
+        webs = ['Noto Sans SC']
+    fam = '&'.join('family=%s:wght@400' % w.replace(' ', '+') for w in webs)
+    return "@import url('%s?%s&display=swap');" % (MIRROR, fam), webs
+
+
+def quant(hit, total):
+    """覆盖率决定量词——不到一半就不许说「一律/每页」。"""
+    if not total:
+        return None
+    r = hit / float(total)
+    if r >= 0.9:
+        return '一律'
+    if r >= 0.5:
+        return '多数'
+    return None
+
+
+def color_usage(shapes, d=None):
+    """每个色值在形状上的真实用法计数：填充 / 渐变 / 描边 / 文字。
+
+    用途列不能靠预设字典猜——同一个色在不同模板里的主用途完全不同。这里从 shapes
+    直接数，数不到就如实说数不到。
+    """
+    def hx(c):
+        return (c.get('hex') or '').upper() if isinstance(c, dict) else ''
+
+    def walk_text_colors(node, out):
+        """文本样式可能嵌在 lstStyle.lvlNpPr / defRPr / rPr 任一层——通用遍历，
+        别逐层枚举（枚举漏过 lvl2pPr，导致主色被写成「用途待确认」）。"""
+        if isinstance(node, dict):
+            if isinstance(node.get('color'), dict) and hx(node['color']):
+                out.append(hx(node['color']))
+            for v in node.values():
+                walk_text_colors(v, out)
+        elif isinstance(node, list):
+            for v in node:
+                walk_text_colors(v, out)
+
+    use = defaultdict(Counter)
+    for s in shapes:
+        f = s.get('fill') or {}
+        if f.get('type') == 'solid' and hx(f.get('color')):
+            use[hx(f['color'])]['填充'] += 1
+        for st in (f.get('stops') or []):
+            if hx(st.get('color')):
+                use[hx(st['color'])]['渐变'] += 1
+        ln = s.get('line') or {}
+        if hx(ln.get('color')):
+            use[hx(ln['color'])]['描边'] += 1
+        cols = []
+        walk_text_colors(s.get('text') or {}, cols)
+        for h in cols:
+            use[h]['文字'] += 1
+    for h in bg_colors(d or {}):
+        use[h]['页面背景'] += 1
+    # 主题 clrScheme：这类色常常只在主题里声明、页面上由 schemeClr 间接引用，
+    # 不记上就会在用途列写「未落在形状上」，看着像没人用。
+    for th in ((d or {}).get('themes') or []):
+        if not th.get('picked'):
+            continue
+        for slot, hexv in (th.get('clrScheme') or {}).items():
+            if isinstance(hexv, str) and hexv.startswith('#'):
+                use[hexv.upper()]['主题 ' + slot] += 1
+    return use
+
+
+def usage_phrase(counter):
+    """把用法计数写成一句话；主用法占六成以上就直接点名，否则并列前三。"""
+    if not counter:
+        return '普查里有声明，但未落在形状/背景/主题色上——用途待确认'
+    items = counter.most_common()
+    tot = sum(counter.values())
+    if items[0][1] >= tot * 0.6:
+        return '主要作%s（%d/%d 处）' % (items[0][0], items[0][1], tot)
+    return '、'.join('%s %d 处' % (k, v) for k, v in items[:3])
+
+
+def draft_anchors(d, tokens, fonts, roles, assets, archetypes):
+    """anchors 逐条由统计覆盖率产出；证据不足就不生成这一条，不用形容词补。"""
+    A = []
+    n_arch = len(archetypes) or 1
+
+    # 1. 表达色：未取用的高频彩色要如实带上，不能说「其余全是中性」
+    names = [x[0] for x in tokens]
+    chroma = [n for n in names if n.startswith(('primary', 'accent'))]
+    if chroma:
+        A.append((chroma[0] + '-led-palette', 'token',
+                  '表达色集中在 %s；其余 token 为底色与文字色' % '、'.join(chroma[:3])))
+
+    # 2. 圆角：按普查占比
+    radii = d.get('radii_census') or []
+    zero = next((r for r in radii if r['px'] == 0), None)
+    tot_r = sum(r['n'] for r in radii) or 1
+    if zero:
+        q0 = quant(zero['n'], tot_r)
+        if q0:
+            A.append(('zero-radius', 'token',
+                      '卡片、按钮、面板%s直角，圆角量为零的形状占 %d%%'
+                      % (q0, round(100.0 * zero['n'] / tot_r))))
+
+    # 3. 满屏底图：按有背景的页型占比
+    with_bg = sum(1 for a in archetypes if a.get('bg'))
+    qb = quant(with_bg, n_arch)
+    if qb:
+        A.append(('full-bleed-ground', 'pattern',
+                  '页型%s由整幅铺满的底图打底（%d/%d），元素浮在图上而不是浮在纯色块上'
+                  % (qb, with_bg, n_arch)))
+
+    # 4. 标识：位置是不是真的固定，看有几个不同的 box
+    logo_slots = [s for a in archetypes for s in a['slots']
+                  if str(s.get('asset') or '').startswith(('logo', 'slogan'))]
+    logo_arch = sum(1 for a in archetypes
+                    if any(str(s.get('asset') or '').startswith(('logo', 'slogan'))
+                           for s in a['slots']))
+    boxes = {tuple(s['box']) for s in logo_slots}
+    if logo_arch and len(boxes) == 1:
+        A.append(('corner-locked-logo', 'component',
+                  '品牌标识在 %d/%d 个页型上出现，位置尺寸完全一致，跨页不动'
+                  % (logo_arch, n_arch)))
+    elif len(boxes) > 1:
+        A.append(('logo-moves-by-archetype', 'component',
+                  '品牌标识按页型换位换尺寸（共 %d 种摆法），必须按 layouts 里该页型的 box 放，'
+                  '不能沿用上一页' % len(boxes)))
+
+    # 5. 渐变：按普查计数
+    if (d.get('geom_census') or {}).get('gradient_fills'):
+        A.append(('gradient-accent', 'pattern',
+                  '强调元素用线性渐变承载，全档共 %d 处渐变填充'
+                  % (d['geom_census']['gradient_fills'])))
+
+    # 6. 层级：字号跨度 + 字重是否单一（字重真单一才敢说「不靠字重」）
+    disp, body = roles.get('display'), roles.get('body')
+    if disp and body and disp['sz_px'] > body['sz_px']:
+        ws = {s.get('weight') for a in archetypes for s in a['slots'] if s.get('weight')}
+        tail = ('，字重只用 %s 一档' % list(ws)[0]) if len(ws) == 1 else ''
+        A.append(('size-driven-hierarchy', 'pattern',
+                  '层级靠字号跨度拉开，展示档与正文档差 %.1f 倍，见 typography%s'
+                  % (disp['sz_px'] / body['sz_px'], tail)))
+
+    # 7. 阴影：只在描边极少时才敢说「不用描边分隔」
+    eff = d.get('effects_census') or {}
+    if eff.get('outerShdw'):
+        A.append(('soft-shadow-card', 'component',
+                  '容器用外阴影托起，全档 %d 处 outerShdw' % eff['outerShdw']))
+
+    # 8. 双字族：只陈述分工存在，不断言「同一行混排」（普查没采集混排）
+    tot_r_font = sum(f['rendered'] for f in fonts) or 1
+    if len(fonts) >= 2 and fonts[1]['rendered']:
+        A.append(('dual-family-typesetting', 'token',
+                  '正文与展示分属两套字族：%s 与 %s，各自渲染 %d / %d 处'
+                  % (fonts[0]['names'][0], fonts[1]['names'][0],
+                     fonts[0]['rendered'], fonts[1]['rendered'])))
+
+    # 9. 安全区：只在各页型正文左边界真的收敛时才写
+    # 「多宽算正文槽」按本包自己的槽宽分布定：固定 px 门槛在窄版心模板上会一个都不剩
+    widths = sorted(s['box'][2] for a in archetypes for s in a['slots'] if not s.get('asset'))
+    w_cut = widths[len(widths) // 2] if widths else 0
+    lefts = [s['box'][0] for a in archetypes for s in a['slots']
+             if not s.get('asset') and s['box'][2] >= w_cut]
+    if len(lefts) >= 4:
+        common = Counter(lefts).most_common(1)[0]
+        qs = quant(common[1], len(lefts))
+        if qs:
+            A.append(('shared-left-margin', 'token',
+                      '正文%s对齐同一条左边界（%d/%d 个正文槽共用，坐标见 layouts）'
+                      % (qs, common[1], len(lefts))))
+
+    # 10. 双主题：直读事实
+    themes = (d.get('theme_topology') or {}).get('themes') or []
+    if len(themes) > 1:
+        A.append(('dual-theme-masters', 'token',
+                  '模板带 %s 两套主题母版，同一页型有深浅两版，配色随主题整体反转'
+                  % ' / '.join(themes)))
+
+    # 11. 画布：直读事实（兜底凑数也只用真事实）
+    cv = d['canvas']['px']
+    A.append(('fixed-canvas', 'token',
+              '画布固定 %d×%d，所有坐标是这张画布上的绝对像素，不做响应式重排'
+              % (cv[0], cv[1])))
+    if len(archetypes) >= 3:
+        A.append(('archetype-catalog', 'pattern',
+                  '模板给出 %d 种页型，搭页从中挑，不要自创版式' % len(archetypes)))
+
+    seen, out = set(), []
+    for a in A:
+        if a[0] in seen:
+            continue
+        seen.add(a[0])
+        out.append(a)
+    return out[:8]
+
+def draft_scale(d, archetypes=()):
+    ts = [t for t in d['text_scale'] if t['sz_px'] >= 10]
+    ts.sort(key=lambda t: -t['sz_px'])
+    if not ts:
+        return {}
+    by_px = {t['sz_px']: t for t in ts}
+    # display 优先取「真的当标题用过」的字号（archetype 首槽），而不是全局最大值
+    title_sz = Counter(s['sz'] for a in archetypes for s in a['slots'] if s['type'] == 'title')
+    display = by_px.get(max(title_sz)) if title_sz else None
+    big = [t for t in ts if t['n'] >= 2] or ts
+    display = display or big[0]
+    # 正文档 = 渲染次数最多的那一档。不设「多大算正文」的上限：大字号排版的模板
+    # 正文本来就可能比别的模板的标题还大，预设上限会把它整档判错。
+    body = max([t for t in ts if t is not display] or ts, key=lambda t: t['n'])
+    heading_pool = [t for t in ts if body['sz_px'] * 1.3 <= t['sz_px'] < display['sz_px']]
+    heading = max(heading_pool, key=lambda t: t['n']) if heading_pool else None
+    small_pool = [t for t in ts if t['sz_px'] < body['sz_px']]
+    caption = max(small_pool, key=lambda t: t['n']) if small_pool else None
+    roles = {'display': display, 'body': body}
+    if heading:
+        roles['heading'] = heading
+    if caption:
+        roles['caption'] = caption
+    return roles
+
+
+def lh_of(t):
+    lhm = t.get('line_height_mult') or {}
+    if not lhm:
+        return None
+    best = max(lhm.items(), key=lambda kv: kv[1])[0]
+    try:
+        v = float(best)
+    except ValueError:
+        return None
+    return v if 0.9 <= v <= 2.2 else None
+
+
+# ---------------------------------------------------------------- 资产
+def probe_image(path):
+    info = {'w': None, 'h': None, 'alpha_mean': None, 'near_blank': False}
+    try:
+        from PIL import Image
+    except Exception:
+        return info
+    try:
+        im = Image.open(path)
+        info['w'], info['h'] = im.size
+        if im.mode in ('RGBA', 'LA') or 'transparency' in im.info:
+            px = im.convert('RGBA').getchannel('A').resize((64, 64)).tobytes()
+            info['alpha_mean'] = sum(px) / len(px)
+            info['near_blank'] = info['alpha_mean'] < 13  # <5% 不透明度
+    except Exception:
+        pass
+    return info
+
+
+def copy_logo_candidates(outdir, logo_pool):
+    if not logo_pool:
+        return []
+    dst_dir = os.path.join(outdir, 'ref', 'logo-candidates')
+    os.makedirs(dst_dir, exist_ok=True)
+    rows = []
+    for rank, (score, c) in enumerate(sorted(logo_pool, key=lambda kv: (-kv[0], -kv[1]['n'])), 1):
+        src = os.path.join(outdir, c.get('out') or '')
+        if not os.path.exists(src):
+            continue
+        name = '%02d-score%s-%s' % (rank, score, c['file'])
+        dst = os.path.join(dst_dir, name)
+        shutil.copy2(src, dst)
+        b = c.get('box') or {}
+        rows.append({
+            'rank': rank,
+            'score': score,
+            'file': c['file'],
+            'copy': os.path.relpath(dst, outdir),
+            'slides': c.get('slides') or [],
+            'box': [round(b.get(k, 0)) for k in ('x', 'y', 'w', 'h')],
+            'used_n': c.get('n', 0),
+        })
+    if rows:
+        with open(os.path.join(dst_dir, 'index.json'), 'w', encoding='utf-8') as f:
+            json.dump(rows, f, ensure_ascii=False, indent=2)
+            f.write('\n')
+    return rows
+
+
+def draft_assets(d, outdir, bg_needed=(), cover_media=None, bg_under=None):
+    imgs = {i['media']: i for i in d['images']}
+    cluster_of = {}
+    for c in d.get('media_clusters', []):
+        for m in c['members']:
+            cluster_of[m] = c['content_id']
+
+    cands = []
+    for m in d['media']:
+        if not m.get('exported'):
+            continue
+        img = imgs.get(m['media'], {})
+        out_rel = m.get('out') or ''
+        probe = probe_image(os.path.join(outdir, out_rel)) if out_rel else {}
+        boxes = img.get('boxes') or []
+        top = max(boxes, key=lambda b: b.get('count', 0)) if boxes else {}
+        parts = top.get('parts') or []
+        slides = sorted({slide_no(p) for p in parts if '/slides/' in p})
+        cands.append({
+            'media': m['media'], 'file': os.path.basename(out_rel), 'out': out_rel,
+            'bytes': m.get('bytes'), 'n': img.get('n', m.get('used_n', 0)),
+            'has_compressed': bool(m.get('compressed_out')),
+            'fullscreen': bool(img.get('fullscreen')), 'w_pct': img.get('max_w_pct', 0),
+            'box': top.get('box') or {}, 'slides': slides,
+            'layer_only': bool(parts) and not slides,
+            'repeat': bool(img.get('repeat_fixed')),
+            'cluster': cluster_of.get(m['media']),
+            'probe': probe, 'reasons': m.get('reasons', []),
+        })
+
+    # 同素材簇去重：留 n 最大的一张
+    best_of = {}
+    for c in cands:
+        k = c['cluster'] or c['media']
+        if k not in best_of or c['n'] > best_of[k]['n']:
+            best_of[k] = c
+    kept = sorted(best_of.values(), key=lambda c: (-c['n'], -(c['bytes'] or 0)))
+    # 被同簇兄弟淘汰的 media 仍要能指到胜出者——封面底图常常是簇里 n 最小的那张
+    alias = {}
+    for c in cands:
+        w = best_of.get(c['cluster'] or c['media'])
+        if w and w['media'] != c['media']:
+            alias[c['media']] = w['media']
+    cover_media = alias.get(cover_media, cover_media)
+    bg_needed = {alias.get(m, m) for m in (bg_needed or ())}
+
+    assets, rejected, todos = [], [], []
+    over_cap_bgs = []
+    logo_pool = []
+    bg_under = bg_under or {}
+    bg_i = 0
+    canvas_w, canvas_h = d['canvas']['px']
+    for c in kept:
+        if c['probe'].get('near_blank'):
+            rejected.append((c, '近全透明（alpha 均值 %.0f/255），PPT 里看不见' % c['probe']['alpha_mean']))
+            continue
+        if c['fullscreen']:
+            if c['media'] == cover_media:
+                assets.append({'id': 'bg-cover', 'kind': 'background', 'role': 'cover',
+                               'src': c,
+                               # 只有真出了压缩版才能带原图；否则 path/full 指向同一
+                               # 文件，package.py 必 FAIL（封面不需要转码时就会踩到）
+                               'use_full': c['has_compressed']})
+            elif c['media'] in bg_needed and bg_i < BG_CONTENT_CAP:
+                bg_i += 1
+                assets.append({'id': 'bg-content-%d' % bg_i, 'kind': 'background',
+                               'role': 'content', 'src': c, 'use_full': False})
+            elif c['media'] in bg_needed:
+                over_cap_bgs.append(c)
+                rejected.append((c, '有页型以它为主底，但内容页背景已收满 %d 张' % BG_CONTENT_CAP))
+            else:
+                rejected.append((c, '满屏图但没有页面以它为主底（只在版式层备用）'))
+        elif c['w_pct'] < SMALL_IMG_W_PCT and c['n'] >= REPEAT_MIN:
+            # 品牌标识的共性是「小、重复出现、贴角」。这里只按贴角程度排序给出首选，
+            # 不设及格线——「多少分算 logo」没有客观依据，判断交 L 层，分项证据随 TODO 给出。
+            b = c['box']
+            edge_x = min(b.get('x', 0), max(canvas_w - (b.get('x', 0) + (b.get('w') or 0)), 0))
+            edge_y = min(b.get('y', 0), max(canvas_h - (b.get('y', 0) + (b.get('h') or 0)), 0))
+            corner = (edge_x / canvas_w) + (edge_y / canvas_h)   # 越小越贴角
+            logo_pool.append((corner, c))
+        else:
+            rejected.append((c, '内容区图片（占宽 %.0f%%，出现 %d 次）' % (c['w_pct'], c['n'])))
+
+    def on_bg_of(c):
+        """logo 压在浅底还是深底：直接采底图上它那块区域的亮度，不用人判。"""
+        bg = bg_under.get(c['slides'][0]) if c['slides'] else None
+        row = next((m for m in d['media'] if m['media'] == bg and m.get('out')), None)
+        if not row:
+            return None
+        try:
+            from PIL import Image
+            im = Image.open(os.path.join(outdir, row['out'])).convert('RGB')
+            b = c['box']
+            sx, sy = im.width / float(canvas_w), im.height / float(canvas_h)
+            crop = im.crop((int(b.get('x', 0) * sx), int(b.get('y', 0) * sy),
+                            max(int((b.get('x', 0) + b.get('w', 1)) * sx), 1),
+                            max(int((b.get('y', 0) + b.get('h', 1)) * sy), 1))).resize((16, 16))
+            raw = crop.tobytes()
+            px = [raw[i:i + 3] for i in range(0, len(raw), 3)]
+            return 'light' if sum(lum(p) for p in px) / len(px) > LUM_MID else 'dark'
+        except Exception:
+            return None
+
+    # 贴角是品牌标识的定义性特征：离两边都超过画布 1/4 的重复小图，更可能是页内装饰。
+    # 这不是「多少分算 logo」那种凑出来的分数线——它直接来自「贴角」这个判据本身。
+    LOGO_CORNER_MAX = 0.5      # edge_x/W + edge_y/H，两边各 25% 即到上限
+    logo_pool.sort(key=lambda kv: (kv[0], -kv[1]['n']))
+    if logo_pool and logo_pool[0][0] > LOGO_CORNER_MAX:
+        todos.append('没有贴角的重复小图（最接近的一张离画布边 %.0f%%），本模板可能没有 logo；'
+                     '确认后要么从联系表挑一张补进 manifest，要么在 gaps 写明模板无品牌标识'
+                     % (logo_pool[0][0] * 50))
+        logo_pool = []
+    for i, (corner, c) in enumerate(logo_pool):
+        b = c['box']
+        if i == 0:
+            assets.append({'id': 'logo-primary', 'kind': 'logo', 'role': None, 'src': c,
+                           'use_full': False, 'on_bg': on_bg_of(c)})
+            todos.append('看联系表确认 `%s` 真是品牌 logo（%.0fx%.0f @ %.0f,%.0f，出现 %d 次，'
+                         '离画布边 %.0f%%，是所有小图里最贴角的一张）；'
+                         '不是就把 manifest 的 logo-primary 换成别的候选或整条删掉'
+                         % (c['file'], b.get('w', 0), b.get('h', 0), b.get('x', 0), b.get('y', 0),
+                            c['n'], corner * 50))
+        else:
+            rejected.append((c, '重复小图（%.0fx%.0f @ %.0f,%.0f），贴角程度 %.0f%% 不如首选'
+                             % (b.get('w', 0), b.get('h', 0), b.get('x', 0), b.get('y', 0),
+                                corner * 50)))
+
+    # 体量预算：包内资产总量超 20MB 直接 FAIL（V2-6）。`use_full` 的原图是唯一可能
+    # 单张爆预算的东西（未压缩的封面级大图可以单张达到数十 MB），所以在草案期就先丢 full，
+    # 不要留给 L 层去撞门禁再回修。
+    PACK_BUDGET = 20 * 1024 * 1024
+    est = sum(min(a['src'].get('bytes') or 0, ASSET_WARN_SINGLE) for a in assets)
+    for a in sorted([x for x in assets if x['use_full']],
+                    key=lambda x: -(x['src'].get('bytes') or 0)):
+        orig = a['src'].get('bytes') or 0
+        if est + orig > PACK_BUDGET * 0.9:
+            a['use_full'] = False
+            todos.append('`%s` 的原图 %.1fMB 会把包撑过 20MB 上限，草案已只保留压缩版；'
+                         '确实需要原图就改走 url 承载' % (a['id'], orig / 1024.0 / 1024))
+        else:
+            est += orig
+
+    if over_cap_bgs:
+        todos.append('模板有 %d 张内容页背景超出 %d 张上限（%s）；用到它们的页型在 layouts.md 里'
+                     '不会有 background，需要就手工补进 manifest 并删掉不重要的那几张'
+                     % (len(over_cap_bgs), BG_CONTENT_CAP,
+                        '、'.join(c['file'] for c in over_cap_bgs[:5])))
+    if not any(a['role'] == 'cover' for a in assets):
+        todos.append('没定出封面底图——从联系表挑一张补进 manifest（role: cover），或在 gaps 写明模板无封面主视觉')
+    copy_logo_candidates(outdir, logo_pool)
+    return assets, rejected, todos, alias, {c['media']: c for c in kept}
+
+
+# ---------------------------------------------------------------- 版式聚类
+DECOR_MIN = 40.0
+
+# 版式名 → role（模板自己按页型命名时直接用它，别再猜）。
+# 英文词按整词匹配：裸子串会让短词吃掉长词——`end` 一度把 `agenda`、`Appendix`、
+# `Trends Section` 全判成 closing，表里 `agenda -> section` 那条永远轮不到。
+ROLE_BY_WORD = [('封面', 'cover'), ('cover', 'cover'), ('首页', 'cover'),
+                ('title slide', 'cover'), ('标题幻灯片', 'cover'),
+                ('封底', 'closing'), ('尾页', 'closing'), ('结束', 'closing'),
+                ('致谢', 'closing'), ('谢谢', 'closing'), ('end', 'closing'),
+                ('thank you', 'closing'), ('closing', 'closing'),
+                ('章节', 'section'), ('目录', 'section'), ('过渡', 'section'),
+                ('section', 'section'), ('agenda', 'section'),
+                ('section header', 'section'), ('节标题', 'section'),
+                ('金句', 'quote'), ('问句', 'quote'), ('引言', 'quote'), ('quote', 'quote'),
+                ('空白', 'blank'), ('blank', 'blank')]
+PH_TO_TYPE = {'title': 'title', 'ctrTitle': 'title', 'subTitle': 'subtitle',
+              'body': 'body', 'pic': 'pic', 'clipArt': 'pic', 'tbl': 'table',
+              'chart': 'chart', 'media': 'media', 'dgm': 'pic',
+              'sldNum': 'slide-number', 'ftr': 'footer', 'dt': 'footer'}
+
+
+def role_of_name(name):
+    """版式名 → role。认不出返回 None，由调用方降置信度并留 TODO——不要静默当 content。
+
+    词表只覆盖中英文；换一种语言命名的模板会整份认不出。那时全落 content 且机检照过，
+    消费端拿到的是「每一页都是内容页」，封面/章节/结束页的语义整个丢掉且无处可查。
+    """
+    low = (name or '').lower()
+    for word, role in ROLE_BY_WORD:
+        if word.isascii():
+            if re.search(r'(?<![a-z])%s(?![a-z])' % re.escape(word), low):
+                return role
+        elif word in low:
+            return role
+    return None
+
+
+def clean_layout_name(name):
+    """`1_内容-左右排版（无副标题）` → `内容-左右排版（无副标题）`。"""
+    return re.sub(r'^\d+[_\-\s]*', '', (name or '').strip()) or '未命名版式'
+
+
+def slot_style(s):
+    """占位符自带的排版样式——字号/色值/对齐/字重都是直读，不给消费端留编的空间。
+
+    样式可能在三层：lstStyle.lvl1pPr（版式占位符常用）、段落 defRPr（Mac Office
+    导出把大量属性写在这一层）、段落 pPr（对齐）。逐层兜底，缺一层就往下取。
+    """
+    txt = s.get('text') or {}
+    ls = dict((txt.get('lstStyle') or {}).get('lvl1pPr') or {})
+    # 四层逐级兜底，按 OOXML 的就近原则：run rPr → 段落 defRPr → 段落 pPr → lstStyle。
+    # 只枚举前几层会整份漏掉——有的导出器把字号全写在 run rPr 上，lstStyle 一个都没有。
+    for para in (txt.get('paragraphs') or []):
+        srcs = [r.get('rPr') or {} for r in (para.get('runs') or [])]
+        srcs.append(para.get('defRPr') or {})
+        srcs.append({k: v for k, v in para.items() if k not in ('runs', 'defRPr')})
+        for src in srcs:
+            for k, v in (src or {}).items():
+                if v is not None:
+                    ls.setdefault(k, v)
+        if ls.get('sz_px'):
+            break
+    if not ls.get('sz_px'):
+        # 仍无声明：退到整形状里出现过的最大字号（generic walk），仍是文件里的值
+        anysz = shape_sz(s)
+        if anysz:
+            ls['sz_px'] = anysz
+    out = {}
+    if ls.get('sz_px'):
+        out['size'] = round(ls['sz_px'])
+    col = (ls.get('color') or {}).get('resolved')
+    if col:
+        out['color'] = col
+    if ls.get('weight'):
+        out['weight'] = ls['weight']
+    elif ls.get('bold'):
+        out['weight'] = 700
+    if ls.get('algn') and ls['algn'] not in ('l', 'just'):
+        out['align'] = {'ctr': 'center', 'r': 'right'}.get(ls['algn'], ls['algn'])
+    anchor = ((s.get('text') or {}).get('bodyPr') or {}).get('anchor')
+    if anchor in ('ctr', 'b'):
+        out['valign'] = {'ctr': 'middle', 'b': 'bottom'}[anchor]
+    return out
+
+
+def instance_override(shapes, slide_part, slots, bgm, cW, cH):
+    """实例页覆盖版式：版式是骨架，实例页才是设计师最终摆定的样子。
+
+    版式底图常是多个版式共用的通用底纹，实例页可能另铺主视觉大图；标题占位符的框高
+    也常被实例页放大以容纳多行。只读版式的包会让消费端拿到错的底图和装不下字的框，
+    只能自己缩字号。
+    """
+    ins = [s for s in shapes if s.get('part') == slide_part]
+    if not ins:
+        return slots, bgm
+    for s in ins:                             # 实例页自己铺的满屏图优先
+        if (s.get('kind') == 'pic' and s.get('media')
+                and s.get('w_pct', 0) >= 95 and s.get('h_pct', 0) >= 95):
+            bgm = s['media']
+            break
+    texts = []
+    for s in ins:
+        b = s.get('box') or {}
+        if not (b.get('w') and b.get('h')) or not shape_text(s):
+            continue
+        texts.append({'sz': shape_sz(s), 'box': b, 'style': slot_style(s)})
+    texts.sort(key=lambda x: -x['sz'])
+    # 按字号大小依次顶替版式的文字槽（版式槽已按 y 排过，字号序更贴合语义层级）
+    tslots = [s for s in slots if s['type'] != 'pic']
+    for slot, ins_t in zip(sorted(tslots, key=lambda s: -(s.get('sz') or 0)), texts):
+        b = ins_t['box']
+        slot['box'] = [round(b.get('x', 0)), round(b.get('y', 0)),
+                       round(b.get('w', 0)), round(b.get('h', 0))]
+        slot['sz'] = ins_t['sz']
+        slot.update(ins_t['style'] or {})
+    return slots, bgm
+
+
+def layouts_from_template(d, shapes, cW, cH):
+    """form=3：模板自己用 slideLayout 声明了页型，直接读版式层。
+
+    拿样张聚类只能得到「样张数」个 archetype——模板往往只放 1-2 张样张，
+    真正的页型全在版式里。模板常见只放个位数样张却声明几十个语义版式，按样张聚类
+    只能得到「样张数」个 archetype，消费端搭页时大半无版式可抄，只能自己编。
+    """
+    by_part = defaultdict(list)
+    for s in shapes:
+        if s.get('layer') == 'layout' and s.get('ph'):
+            by_part[s['part']].append(s)
+    bg_of_layout = {}
+    for s in shapes:
+        if (s.get('layer') == 'layout' and s.get('kind') == 'pic'
+                and s.get('w_pct', 0) >= 95 and s.get('h_pct', 0) >= 95):
+            bg_of_layout.setdefault(s['part'], s.get('media'))
+    topo = d.get('theme_topology') or {}
+    theme_of_master = {m['master']: m.get('theme_label')
+                       for m in (topo.get('per_master') or [])}
+    master_of = (d.get('reference_graph') or {}).get('master_of_layout') or {}
+    # 只在版式恰好被 1 张实例页使用时才拿实例覆盖：多张实例共用一个版式时，
+    # 谁都不代表版式本身，硬挑一张会把别页的构图当成页型
+    lay_of_slide = (d.get('reference_graph') or {}).get('layout_of_slide') or {}
+    used_n = Counter(lay_of_slide.values())
+    slide_of_layout = {lp: sp for sp, lp in lay_of_slide.items() if used_n[lp] == 1}
+    default_theme = topo.get('default')
+    multi = len(topo.get('themes') or []) > 1
+
+    rows = []
+    for l in d.get('layouts') or []:
+        phs = [s for s in by_part.get(l['part'], []) if (s.get('box') or {}).get('w')]
+        if not phs:
+            continue
+        theme = theme_of_master.get(master_of.get(l['part']))
+        phs.sort(key=lambda s: ((s['box'].get('y') or 0), (s['box'].get('x') or 0)))
+        slots, seen_kind = [], set()
+        for s in phs:
+            t = PH_TO_TYPE.get((s['ph'] or {}).get('type'), 'body')
+            if t in ('slide-number', 'footer'):
+                continue                      # 页码/页脚属 chrome，不是内容槽
+            b = s['box']
+            role = t if t in ('title', 'subtitle') else 'body'
+            if t == 'title' and 'title' in seen_kind:
+                role, t = 'subtitle', 'subtitle'
+            seen_kind.add(t)
+            row = {'role': role, 'type': t, 'sz': shape_sz(s),
+                   'box': [round(b.get('x', 0)), round(b.get('y', 0)),
+                           round(b.get('w', 0)), round(b.get('h', 0))],
+                   'txt': shape_text(s) or (s.get('name') or '')[:24]}
+            row.update(slot_style(s))
+            slots.append(row)
+        # 非满屏的图片元素（logo / 联名标 / 装饰）——它们逐版式换位置换尺寸，
+        # 必须按版式落进 slots，压成一条全局「固定位」规则就会撞标题。
+        bgm = bg_of_layout.get(l['part'])
+        for s in shapes:
+            if s['part'] != l['part'] or s.get('kind') != 'pic' or not s.get('media'):
+                continue
+            if s['media'] == bgm or (s.get('w_pct', 0) >= 95 and s.get('h_pct', 0) >= 95):
+                continue
+            b = s.get('box') or {}
+            if not b.get('w'):
+                continue
+            slots.append({'role': 'logo', 'type': 'pic', 'sz': 0, 'txt': '',
+                          'media': s['media'],
+                          'box': [round(b.get('x', 0)), round(b.get('y', 0)),
+                                  round(b.get('w', 0)), round(b.get('h', 0))]})
+        if not slots:
+            continue
+        inst = slide_of_layout.get(l['part'])
+        if inst:
+            slots, bgm = instance_override(shapes, inst, slots, bgm, cW, cH)
+        taken = {tuple(s['box']) for s in slots}
+        decor = collect_decor(shapes, inst or l['part'], taken, (cW, cH))
+        named_role = role_of_name(l.get('name'))
+        rows.append({'zh': clean_layout_name(l.get('name')),
+                     'role': named_role or 'content', 'role_guessed': named_role is None,
+                     'slots': slots, 'decor': decor, 'bg_raw': bgm,
+                     'theme': theme, 'part': l['part'],
+                     'used': l.get('used_by_slides') or 0})
+
+    # 同名版式在 dark/light 两套 master 下各有一份——按名字归一，优先默认主题那份
+    best = {}
+    for r in rows:
+        k = r['zh']
+        cur = best.get(k)
+        if cur is None or (r['theme'] == default_theme and cur['theme'] != default_theme) \
+                or (r['used'] > cur['used']):
+            best[k] = r
+    picked = sorted(best.values(), key=lambda r: (
+        ['cover', 'section', 'quote', 'content', 'closing', 'blank'].index(r['role'])
+        if r['role'] in ('cover', 'section', 'quote', 'content', 'closing', 'blank') else 9,
+        -r['used'], r['part']))
+
+    used_key = Counter()
+    arch = []
+    for r in picked:
+        used_key[r['role']] += 1
+        n = used_key[r['role']]
+        key = r['role'] if n == 1 else '%s-%d' % (r['role'], n)
+        m_no = re.search(r'slideLayout(\d+)\.xml$', r['part'])
+        arch.append({'name': key, 'zh': r['zh'], 'role': r['role'], 'bg': None,
+                     'role_guessed': r.get('role_guessed'),
+                     'bg_raw': r['bg_raw'], 'slots': r['slots'],
+                     'decor': r.get('decor') or [], 'pages': [],
+                     'rep': None, 'rep_layout': int(m_no.group(1)) if m_no else None,
+                     # 版式名认不出 role 时不装作有把握：置信度降到 low，让 L 层看图定
+                     'pic_n': 0, 'confidence': 'low' if r.get('role_guessed') else 'high',
+                     'theme': r['theme'] if multi else None,
+                     'source': 'layout:' + r['part'].split('/')[-1]})
+    return arch
+
+
+_QUERY = []
+
+
+def _load_query():
+    """复用 query.py 的 OOXML→CSS 渲染，不再写第二份。"""
+    if not _QUERY:
+        import importlib.util
+        spec = importlib.util.spec_from_file_location('_q', os.path.join(HERE, 'query.py'))
+        mod = importlib.util.module_from_spec(spec)
+        spec.loader.exec_module(mod)
+        _QUERY.append(mod)
+    return _QUERY[0]
+
+
+def collect_decor(shapes, part, taken_boxes, canvas, limit=10):
+    """页面上撑起版式骨架、但不含文字的形状（圆形图标托、卡片、分隔线）。
+
+    只给文字框的坐标，消费端看到的是「一段说明悬在半空、上方一片空白」，只能自己编
+    容器，编出来的形状与模板无关。这些形状必须进包。
+    """
+    q = _load_query()
+    cW, cH = canvas
+    out = []
+    for s in shapes:
+        if s.get('part') != part or s.get('kind') != 'sp':
+            continue
+        if any(r.get('text', '').strip()
+               for para in ((s.get('text') or {}).get('paragraphs') or [])
+               for r in (para.get('runs') or [])):
+            continue                       # 有文字的已经作为 slot 出过
+        b = s.get('box') or {}
+        w, h = b.get('w') or 0, b.get('h') or 0
+        if not (w or h):
+            continue                       # 零尺寸形状渲染不出任何东西
+        if canvas_coverage(b, cW, cH) >= FULLSCREEN_COVERAGE:
+            continue                       # 满屏底，属 background
+        box = [round(b.get('x', 0)), round(b.get('y', 0)), round(w), round(h)]
+        if tuple(box) in taken_boxes:
+            continue
+        css = q._recipe_css(s.get('fill'), s.get('line'),
+                            [s.get('radius_px')] if s.get('radius_px') else [], s.get('effects'))
+        # 声明要落成单行：含换行的声明会被下游的行式解析器从换行处截断，
+        # 且只记 PARSE-WARN 不 FAIL，整包照常出厂——带着半条渲染不出来的 CSS
+        css = [re.sub(r'\s*\n\s*', ' ', c.split('\x00')[0]).strip() for c in css if c]
+        if not css:
+            continue                       # 无填充无描边无阴影 = 看不见，不占篇幅
+        out.append({'box': box, 'geom': (s.get('geom') or {}).get('prst') or 'rect',
+                    'css': '; '.join(css), 'area': max(w * h, w, h)})
+    # 按面积降序取前 limit 条：撑起版式的结构性形状总在最前，零星噪点自然落在截断线外，
+    # 不需要再设一个「多小算噪点」的尺寸门槛（那种门槛会误杀 1px 分隔线）。
+    out.sort(key=lambda d: -d['area'])
+    return out[:limit]                      # 同款不同位置都要留，位置本身是版式信息
+
+
+def draft_layouts(d, outdir):
+    shapes = json.load(open(os.path.join(outdir, 'ref', 'shapes.json'), encoding='utf-8'))['shapes']
+    cW, cH = d['canvas']['px']
+    if (d.get('form_hint') or {}).get('form') == 3:
+        arch = layouts_from_template(d, shapes, cW, cH)
+        if len(arch) >= 3:
+            return arch, [], []
+    by_slide = defaultdict(list)
+    for s in shapes:
+        if s.get('layer') == 'slide':
+            by_slide[s['part']].append(s)
+
+    bg_of_slide, layout_of_slide = {}, {}
+    for s in d.get('slides', []):
+        bg = s.get('background')
+        bg_of_slide[s['part']] = json.dumps(bg, sort_keys=True) if isinstance(bg, dict) else bg
+        layout_of_slide[s['part']] = s.get('layout')
+    # 版式层的满屏底图（form=2 常态：底图挂在 layout 上）
+    bg_of_layout = {}
+    for s in shapes:
+        if (s.get('layer') == 'layout' and s.get('kind') == 'pic'
+                and s.get('w_pct', 0) >= 95 and s.get('h_pct', 0) >= 95):
+            bg_of_layout.setdefault(s['part'], s.get('media'))
+
+    pages = []
+    for part, sh in sorted(by_slide.items(), key=lambda kv: slide_no(kv[0])):
+        bg_media = None
+        for s in sh:
+            if s.get('kind') == 'pic' and s.get('w_pct', 0) >= 95 and s.get('h_pct', 0) >= 95:
+                bg_media = s.get('media')
+                break
+        if bg_media is None:
+            bg_media = bg_of_layout.get(layout_of_slide.get(part))
+        texts = []
+        for s in sh:
+            if s.get('kind') != 'sp':
+                continue
+            txt = shape_text(s)
+            if not txt:
+                continue
+            b = s.get('box') or {}
+            if b.get('w', 0) < DECOR_MIN or b.get('h', 0) < 16:
+                continue
+            texts.append({'sz': shape_sz(s), 'box': b, 'txt': txt, 'style': slot_style(s)})
+        texts.sort(key=lambda t: (-t['sz'], t['box'].get('y', 0)))
+        pics = [s for s in sh if s.get('kind') == 'pic' and s.get('w_pct', 0) < 95]
+        # 小图元素（logo / 角标 / 装饰）逐页记位置，供 archetype 落 slots
+        marks = [{'media': s['media'], 'box': s['box']} for s in pics
+                 if s.get('media') and (s.get('box') or {}).get('w') and s.get('w_pct', 0) < 30]
+        pages.append({'part': part, 'no': slide_no(part), 'bg_media': bg_media,
+                      'bg_color': bg_of_slide.get(part), 'texts': texts, 'pic_n': len(pics),
+                      'marks': marks, 'shape_n': len(sh)})
+
+    # 页型的**角色**（封面 / 章节页 / 内容页……）不在这里判：那是看图才能下的结论，
+    # 交给读得到重建图的模型。脚本只做客观归并——同一张底图 + 文字块数量相近的页
+    # 归成一组，档位按本 deck 自己的分布切，不用「字号 ≥60 就是章节页」这类固定数。
+    ns = sorted(len(p['texts']) for p in pages) or [0]
+    q1, q2 = ns[len(ns) // 3], ns[len(ns) * 2 // 3]
+
+    def density_band(p):
+        n = len(p['texts'])
+        return 0 if n <= q1 else (1 if n <= q2 else 2)
+
+    groups = defaultdict(list)
+    for p in pages:
+        if p['no'] == 1:
+            # 首页单独成组：它是 deck 唯一的入口页，版面通常和后面任何一页都不同，
+            # 并进别的组就会被代表页顶掉、坐标全丢。这只是不合并，不代表它是封面。
+            groups[('__first__', -1)] = [p]
+            continue
+        groups[(p['bg_media'] or p['bg_color'] or 'none', density_band(p))].append(p)
+
+    ranked = sorted(groups.items(), key=lambda kv: (-len(kv[1]), kv[1][0]['no']))
+    # 首页所在的组一定收——deck 的第一页是模板的门面，孤例也不能被名额挤掉。
+    # 这只保证它进包，它是不是封面由看图的人定。
+    first = [g for g in ranked if g[0][0] == '__first__']
+    kept = first + [g for g in ranked if g not in first and len(g[1]) >= 2][:8 - len(first)]
+    for g in ranked:                      # 名额没用满就把最大的孤例页也收进来
+        if len(kept) >= 8:
+            break
+        if g not in kept:
+            kept.append(g)
+    leftover = sorted(p['no'] for g in ranked if g not in kept for p in g[1])
+
+    archetypes = []
+    for gi, ((bg_raw, _band), ps) in enumerate(kept, 1):
+        rep = max(ps, key=lambda p: len(p['texts']))
+        if bg_raw == '__first__':
+            bg_raw = rep['bg_media'] or rep['bg_color'] or 'none'
+        name = 'layout-%d' % gi
+        # 标题按「位置 + 跨度」认，不按字号——big-number 类的巨号数值常比标题还大
+        # 标题 = 该页最靠上的那批文本里最宽的一块。不按「画布前 28%」这类固定比例切：
+        # 版心靠下的模板会整页认不出标题。以该页自身的文本框分布定「靠上」。
+        ys = sorted(t['box'].get('y', 0) for t in rep['texts'])
+        y_cut = ys[max(len(ys) // 4, 0)] if ys else 0
+        band = [t for t in rep['texts'] if t['box'].get('y', 1e9) <= y_cut]
+        title = max(band, key=lambda t: (t['box'].get('w', 0), t['sz'])) if band else (
+            max(rep['texts'], key=lambda t: t['sz']) if rep['texts'] else None)
+        rest = [t for t in rep['texts'] if t is not title]
+        rest.sort(key=lambda t: (t['box'].get('y', 0), t['box'].get('x', 0)))
+        ordered = ([title] if title else []) + rest
+        slots = []
+        for i, t in enumerate(ordered[:6]):
+            b = t['box']
+            if t is title:
+                role = typ = 'title'
+            elif (title and i == 1
+                  # 副标题 = 紧跟在标题下方、与标题左对齐的那一块。三个量都相对标题
+                  # 自身：绝对 px 门槛在大字号排版的模板上会整片认不出来。
+                  and abs(b.get('x', 0) - title['box'].get('x', 0)) <= title['box'].get('h', 0)
+                  and 0 <= b.get('y', 0) - (title['box'].get('y', 0)
+                                            + title['box'].get('h', 0))
+                  <= title['box'].get('h', 0) * 2):
+                role = typ = 'subtitle'
+            else:
+                role = typ = 'body'
+            row = {'role': role, 'box': [round(b.get('x', 0)), round(b.get('y', 0)),
+                                        round(b.get('w', 0)), round(b.get('h', 0))],
+                   'type': typ, 'sz': t['sz'], 'txt': t['txt']}
+            row.update(t.get('style') or {})
+            slots.append(row)
+        # 代表页上的小图元素按位置去重后落 slots（同一 logo 在不同页型位置不同）
+        seen_mark = set()
+        for mk in rep.get('marks') or []:
+            b = mk['box']
+            key = (mk['media'], round(b.get('x', 0)), round(b.get('y', 0)))
+            if key in seen_mark:
+                continue
+            seen_mark.add(key)
+            slots.append({'role': 'logo', 'type': 'pic', 'sz': 0, 'txt': '',
+                          'media': mk['media'],
+                          'box': [round(b.get('x', 0)), round(b.get('y', 0)),
+                                  round(b.get('w', 0)), round(b.get('h', 0))]})
+        decor = collect_decor(shapes, rep['part'], {tuple(s['box']) for s in slots}, (cW, cH))
+        archetypes.append({'name': name, 'bg': None, 'bg_raw': bg_raw, 'slots': slots,
+                           'decor': decor,
+                           'pages': sorted(p['no'] for p in ps), 'rep': rep['no'],
+                           'pic_n': rep['pic_n'],
+                           'confidence': 'high' if len(ps) >= 3 else
+                                         ('medium' if len(ps) == 2 else 'low')})
+    return archetypes, pages, leftover
+
+
+# ---------------------------------------------------------------- 联系表
+def layout_sheet(outdir, archetypes, path):
+    """把各 archetype 的代表页光栅出来拼成一张——版式命名得看得见页面。"""
+    use_layout = all(a.get('rep') is None for a in archetypes)
+    reps = [a.get('rep_layout') if use_layout else a.get('rep') for a in archetypes]
+    reps = [x for x in reps if x is not None]
+    if not reps:
+        return None
+    import subprocess
+    r = subprocess.run([sys.executable, os.path.join(HERE, 'render_pages.py'), outdir,
+                        '--pages', 'layouts' if use_layout else 'slides',
+                        '--only', ','.join(map(str, reps)), '--no-html'],
+                       capture_output=True, text=True)
+    png_dir = os.path.join(outdir, 'ref', 'rebuild', 'png')
+    if r.returncode or not os.path.isdir(png_dir):
+        return None
+    try:
+        from PIL import Image, ImageDraw
+    except Exception:
+        return None
+    cols = 2 if len(archetypes) > 1 else 1
+    cw, ch, pad, lab = 480, 270, 16, 20
+    rows = (len(archetypes) + cols - 1) // cols
+    sheet = Image.new('RGB', (cols * (cw + pad) + pad, rows * (ch + pad + lab) + pad),
+                      (245, 245, 247))
+    dr = ImageDraw.Draw(sheet)
+    for i, a in enumerate(archetypes):
+        x = pad + (i % cols) * (cw + pad)
+        y = pad + (i // cols) * (ch + pad + lab)
+        no = a.get('rep_layout') if use_layout else a.get('rep')
+        f = os.path.join(png_dir, '%s-%s.png' % ('layout' if use_layout else 'slide', no))
+        if os.path.exists(f):
+            im = Image.open(f).convert('RGB')
+            im.thumbnail((cw, ch))
+            sheet.paste(im, (x, y))
+        dr.rectangle([x, y, x + cw, y + ch], outline=(120, 120, 128))
+        # 标注只写 ASCII——Pillow 默认字体没有 CJK 字形，中文会渲染成方框
+        dr.text((x + 2, y + ch + 5), '[%s]  %s  bg=%s'
+                % (a['name'],
+                   ('layout %s' % a.get('rep_layout')) if use_layout
+                   else ('slide %s x%d pages' % (a.get('rep'), len(a['pages']))),
+                   a.get('bg') or '-'),
+                fill=(20, 20, 24))
+    sheet.save(path, optimize=True)
+    return path
+
+
+def contact_sheet(outdir, cands, path):
+    try:
+        from PIL import Image, ImageDraw
+    except Exception:
+        return None
+    cell, pad, cols = 220, 20, 4
+    items = cands[:12]
+    if not items:
+        return None
+    rows = (len(items) + cols - 1) // cols
+    W = cols * (cell + pad) + pad
+    H = rows * (cell + pad + 18) + pad
+    sheet = Image.new('RGB', (W, H), (245, 245, 247))
+    dr = ImageDraw.Draw(sheet)
+    for idx, c in enumerate(items):
+        x = pad + (idx % cols) * (cell + pad)
+        y = pad + (idx // cols) * (cell + pad + 18)
+        # 棋盘格底，透明区看得见
+        for gy in range(0, cell, 16):
+            for gx in range(0, cell, 16):
+                if (gx // 16 + gy // 16) % 2 == 0:
+                    dr.rectangle([x + gx, y + gy, x + gx + 15, y + gy + 15], fill=(214, 214, 218))
+        try:
+            im = Image.open(os.path.join(outdir, c['out'])).convert('RGBA')
+            im.thumbnail((cell, cell))
+            sheet.paste(im, (x + (cell - im.width) // 2, y + (cell - im.height) // 2), im)
+        except Exception:
+            dr.text((x + 8, y + 8), 'unreadable', fill=(200, 0, 0))
+        dr.rectangle([x, y, x + cell, y + cell], outline=(120, 120, 128))
+        dr.text((x + 2, y + cell + 4), '[%d] %s  %dx%d  used=%d'
+                % (idx + 1, c['file'], c['probe'].get('w') or 0, c['probe'].get('h') or 0, c['n']),
+                fill=(20, 20, 24))
+    sheet.save(path, optimize=True)
+    return path
+
+
+# ---------------------------------------------------------------- 落盘
+def write(p, s):
+    with open(p, 'w', encoding='utf-8') as f:
+        f.write(s)
+
+
+def emit_manifest(d, assets, ldir):
+    L = ['version: alpha',
+         'name: TODO-style-name        # 英文 kebab，体现气质，不要用文件名',
+         'name_zh: TODO中文名',
+         'description: >',
+         '  TODO: 一句话说清这套模板的视觉性格（底色 / 主色 / 字形 / 版面骨架），给消费模型定调。']
+    themes = d['theme_topology'].get('themes') or ['single']
+    if themes != ['single'] and len(themes) > 1:
+        L += ['themes: [%s]' % ', '.join(themes), 'default-theme: %s' % themes[0]]
+    if assets:
+        L.append('assets:')
+        for a in assets:
+            L.append('  - id: %s' % a['id'])
+            L.append('    source_media: %s' % a['src']['file'])
+            L.append('    kind: %s' % a['kind'])
+            if a['role']:
+                L.append('    role: %s' % a['role'])
+            if a['kind'] in ('logo', 'slogan'):
+                L.append('    on-bg: %s' % (a.get('on_bg') or 'light'))
+            if a['use_full']:
+                L.append('    use_full: true')
+    write(os.path.join(ldir, 'manifest.yaml'), '\n'.join(L) + '\n')
+
+
+def emit_frontmatter(d, tokens, fonts, roles, anchors, gaps, ldir):
+    L = ['colors:']
+    for name, r in tokens:
+        L.append('  %s: "%s"' % (name, r['hex']))
+    body_font = fonts[1] if len(fonts) > 1 else (fonts[0] if fonts else None)
+    disp_font = fonts[0] if fonts else None
+    if disp_font:
+        L.append('typography:')
+        L.append("  fontFamily: '%s'" % font_css(disp_font['stack']))
+        if body_font and body_font is not disp_font:
+            L.append("  bodyFontFamily: '%s'" % font_css(body_font['stack']))
+        for role, t in roles.items():
+            lh = lh_of(t)
+            L.append('  %s: {fontSize: %dpx%s}' % (
+                role, round(t['sz_px']), ', lineHeight: %s' % lh if lh else ''))
+    sp = d.get('spacing_candidates') or {}
+    pads = sp.get('paddings') or []
+    edge = {}
+    for p in pads:
+        edge.setdefault(p['edge'], p['px'])
+    # 四边都测出来才写 spacing / safe-area。缺一边就整段不写，并在 gaps 说明——
+    # 拿另一套模板的边距当默认值，会让消费端按一个从没在本模板出现过的网格排版。
+    edges_full = all(edge.get(k) is not None for k in ('top', 'right', 'bottom', 'left'))
+    if edges_full:
+        L.append('spacing:')
+        L.append('  page-padding: {top: %s, right: %s, bottom: %s, left: %s}'
+                 % (edge['top'], edge['right'], edge['bottom'], edge['left']))
+    # 只排除「圆角量为零」（那是直角不是圆角），不再设「出现几次才算数」的门槛
+    radii = [r for r in (d.get('radii_census') or []) if r['px'] >= 1]
+    if radii:
+        top = max(radii, key=lambda r: r['n'])
+        L.append('rounded:')
+        L.append('  card: %dpx' % round(top['px']))
+    if edges_full:
+        L.append('safe-area:')
+        L.append('  content: {top: %s, right: %s, bottom: %s, left: %s, applies-to: [content]}'
+                 % (edge['top'], edge['right'], edge['bottom'], edge['left']))
+        L.append('  confidence: medium')
+    else:
+        gaps = list(gaps) + ['本模板没测出四边都稳定的页边距（普查到 %s），'
+                             '因此不给 spacing / safe-area：按各页型 slot 的实际坐标排版，'
+                             '不要自造统一边距。'
+                             % ('、'.join('%s=%s' % (k, edge[k]) for k in
+                                          ('top', 'right', 'bottom', 'left') if edge.get(k) is not None)
+                                or '一边都没有')]
+    L.append('anchors:')
+    for aid, typ, desc in anchors:
+        L.append('  - {id: %s, type: %s, desc: "%s"}' % (aid, typ, desc))
+    L.append('gaps:')
+    for g in gaps:
+        L.append('  - "%s"' % g)
+    write(os.path.join(ldir, 'frontmatter.yaml'), '\n'.join(L) + '\n')
+
+
+def emit_layouts(archetypes, ldir):
+    prefilled = sum(1 for a in archetypes if a.get('zh'))
+    L = ['# 只改 names / roles / bg_rules 三段（都是扁平键值，改完 package.py 自动并回各页型）。',
+         '# 下面 layouts 段是普查数值，一个字都不要动——改它容易连带删掉 slots/confidence。']
+    if prefilled:
+        L.append('# names 已按模板自带的版式名填好 %d 条，读一遍确认表意即可，通常不用改。' % prefilled)
+    L.append('names:')
+    for a in archetypes:
+        if a.get('zh'):
+            # 模板自己给版式起了名（form=3），直接用——比看图起名准，也省掉一轮判断
+            L.append('  %s: %s' % (a['name'], q(a['zh'])))
+        else:
+            L.append('  %s: TODO中文名（代表页 %s，共 %d 页）'
+                     % (a['name'], a['rep'], len(a['pages'])))
+    # 角色（封面 / 章节页 / 内容页……）是看图才能下的结论，脚本不猜。模板自己按页型
+    # 命名时用它的标注，否则连同客观事实一起摆出来，由看得到重建图的你来定。
+    need_role = [a for a in archetypes if not a.get('role')]
+    if need_role:
+        L.append('roles:   # 取值 cover|section|content|quote|closing|blank|custom')
+        for a in need_role:
+            szs = sorted({round(s['sz']) for s in a['slots'] if s.get('sz')}, reverse=True)
+            L.append('  %s: TODO角色   # 代表页 %s，共 %d 页；文字块 %d 个，字号 %s；'
+                     '图片 %d 张%s'
+                     % (a['name'], a['rep'], len(a['pages']),
+                        len([s for s in a['slots'] if not s.get('asset')]),
+                        '/'.join(str(x) for x in szs[:5]) or '未声明',
+                        a.get('pic_n') or 0, '；有满屏底图' if a.get('bg_raw') else ''))
+    # 禁放区是**背景图**的属性，不是页型的属性——按背景资产分组，页型再多也不涨
+    bgs = []
+    for a in archetypes:
+        if a['bg'] and a['bg'] not in bgs:
+            bgs.append(a['bg'])
+    if bgs:
+        L.append('bg_rules:')
+        for bg in bgs:
+            users = [a['name'] for a in archetypes if a['bg'] == bg]
+            L.append('  %s:   # 用它的页型：%s' % (bg, ', '.join(users)))
+            L.append('    text_safe: TODO安全文字区[x,y,w,h]，按这张背景的主体避让后填写')
+            L.append('    avoid: TODO禁放区列表；无禁放区写 []，有则写 [{box: [x,y,w,h], reason: "..."}]')
+            L.append('    pairing_rule: "TODO这张背景上标题/正文/图表要避让哪些区域"')
+    L.append('layouts:')
+    for a in archetypes:
+        L.append('  %s:' % a['name'])
+        if a.get('role'):
+            L.append('    role: %s' % a['role'])
+        if a['bg']:
+            L.append('    background: %s' % a['bg'])
+        L.append('    slots:')
+        for s in a['slots']:
+            extra = ''
+            if s.get('asset'):
+                extra += ', asset: %s' % s['asset']
+            for k in ('size', 'weight', 'color', 'align', 'valign'):
+                if s.get(k) is not None:
+                    v = s[k]
+                    extra += ', %s: %s' % (k, '"%s"' % v if k == 'color' else v)
+            L.append('      - {role: %s, box: %s, type: %s%s}'
+                     % (s['role'], s['box'], s['type'], extra))
+        if a.get('decor'):
+            L.append('    decor:')
+            for dcr in a['decor']:
+                L.append('      - {box: %s, geom: %s, css: "%s"}'
+                         % (dcr['box'], dcr['geom'], dcr['css'].replace('"', "'")))
+        L.append('    confidence: %s' % a.get('confidence', 'medium'))
+    write(os.path.join(ldir, 'layouts.yaml'), '\n'.join(L) + '\n')
+
+
+def emit_body(d, tokens, fonts, roles, assets, archetypes, exceptions, cusage, ldir):
+    """design.md 正文。
+
+    每条规则只出现一次——同一条散在 Fast Path / Usage / Background Safety /
+    Hard Rules 各写一遍时措辞必然漂移，消费端无法判断哪份权威。
+    坐标、字号、色值、资产位置的权威都在 layouts.md；本文件只给色板、字体栈与纪律。
+    """
+    canvas = d['canvas']['px']
+    cover = next((a for a in assets if a['id'] == 'bg-cover'), None)
+    logo = next((a for a in assets if a['kind'] == 'logo'), None)
+    imp, webs = import_line(fonts)
+    sidecar = '`layouts.md`'
+
+    L = ['## Overview', '',
+         'TODO: 两三句话讲清这套模板的性格与适用场景——看过联系表和页面重建图之后再写。', '']
+    L.append(('模板自带 %d 种版式，页型、坐标、字号、色值都直读自版式层。'
+              % len(archetypes)) if (d.get('form_hint') or {}).get('form') == 3 else
+             ('%d 页样张归纳出 %d 种页型。' % (d['counts']['slides'], len(archetypes))))
+    L += ['', '## Usage', '',
+          '搭一页 PPT 五步，中间三步的数据都在 %s：' % sidecar, '']
+    L += ['1. **定画布** —— 舞台按 `layouts.md` 的 `canvas` 设成 %d×%d，'
+          '别套用默认尺寸：源模板的长宽比不一定是 16:9，套错了整页坐标全偏。'
+          '舞台尺寸改不了时，整体等比缩放 `min(舞台宽/%d, 舞台高/%d)` 后居中留白——'
+          '逐轴拉伸会把圆压成椭圆、把字挤扁。' % (canvas[0], canvas[1], canvas[0], canvas[1]),
+          '2. **挑页型** —— 在 %s 里按用途选一个 archetype（清单见下面 Layouts 段）。'
+          '页数多于页型时，挑最接近的一个原样套用它的 slot，多出来的槽删掉。' % sidecar,
+          '3. **按 slot 落元素** —— 每个 slot 渲染成一个绝对定位元素：`box` 是 '
+          '`[x, y, w, h]`（%dx%d 画布上的绝对像素），字号取 slot 的 `size`，'
+          '字重取 `weight`，颜色取 `color`，对齐取 `align` / `valign`。'
+          '带 `asset` 的 slot 是图片元素（logo、角标），把该资产放在它自己的 `box` 里；'
+          '这个页型没有 `asset` 槽，这一页就不出现该资产。' % (canvas[0], canvas[1]),
+          '4. **铺装饰几何** —— 页型的 `decor` 是这一页的图形骨架（图标托底的圆、'
+          '卡片、分隔线）：每条渲染成一个绝对定位空元素，`box` 给位置，`css` 原样写进 style，'
+          '`geom: ellipse` 另加 `border-radius: 50%`。它们压在背景之上、slot 之下，'
+          '落在 slot 上的图标正是靠它们托住。',
+          '5. **配色与字体** —— 色板见下面 Colors 段，字体栈与 `@import` 见 Typography 段。']
+    if assets:
+        L += ['', '资产文件（背景由页型的 `background` 字段指定，'
+              '图片资产的位置由该页型 `slots` 里带 `asset` 的槽给出）：', '',
+              '{{ASSET_TABLE}}']
+    L += ['', '文字与容器的外接矩形落在该页型 `background` 对应的 `text_safe` 内，'
+          '避开 `avoid` 列出的区域（两者都在 %s 的 `backgrounds` 段）。内容装不下时换页型或拆页。'
+          % sidecar, '',
+          '## Colors', '', '| token | 值 | 用途 |', '|---|---|---|']
+    for name, r in tokens:
+        L.append('| `%s` | `%s` | %s |'
+                 % (name, r['hex'], usage_phrase(cusage.get(r['hex'].upper()))))
+    L += ['', '## Typography', '']
+    for f in fonts[:2]:
+        L.append('- **%s** —— 栈 `%s`%s' % (
+            f['names'][0], font_css(f['stack']),
+            '，源为商业/内部字体无 web 分发源，按气质降级到 %s' % f['stack'][1]
+            if len(f['stack']) > 1 else ''))
+    L += ['', '字号轴：' + '、'.join('%s %dpx' % (k, round(v['sz_px'])) for k, v in roles.items())
+          + '。slot 自带 `size` 时以 slot 为准；层级在轴上没有的，复用最接近的一档。', '',
+          '字体加载（**HARD REQUIREMENT：下面这行 @import 原样写入全局样式首行，禁止替换为 '
+          'fonts.googleapis.com 或其他域**）：', '', '```', imp, '```', '',
+          '镜像只保证 wght 400 一档，更粗的字重由浏览器合成，字重不能作为唯一区分手段；'
+          '系统字体 PingFang SC / Microsoft YaHei 置于栈末保底，中文场景负字距清零。', '',
+          '## Layouts', '', '页型清单如下，每个页型的 slots、background、'
+          '禁放区都在 %s：' % sidecar, '', '{{LAYOUT_LIST}}',
+          '', '## Hard Rules', '']
+    if cover:
+        L.append('- 封面页铺满 `bg-cover`，整幅覆盖 %dx%d 画布。' % (canvas[0], canvas[1]))
+    if any(a['role'] == 'content' for a in assets):
+        L.append('- 内容页的背景由该页型的 `background` 字段指定，整幅铺满。')
+    if logo:
+        L.append('- `%s` 的位置来自各页型 `slots` 里 `role: logo` 的 `box`——原样使用该文件，'
+                 '保持原比例。' % logo['id'])
+    L += ['- 坐标、字号、色值、资产位置以 %s 为准；本文件的 Colors / Typography 是可用值的清单。'
+          % sidecar,
+          '- 内容语义色（增长绿、下降红之类）本模板没有：用色板内颜色的深浅或透明度表达正负。',
+          '- 本包里的数值就是普查结果，照用即可，无需重新统计颜色、字体或版式。',
+          '- 风格包以文本形式（zip 摘要等）到手时，直接用摘要里 design.md / layouts.md 的文本。',
+          '- TODO: 补 1-2 条这套模板特有的硬规则（看过重建图之后写，例如主色只许用在哪类元素）。',
+          '', '## Exceptions', '']
+    if exceptions:
+        L += ['- ' + e for e in exceptions]
+    else:
+        L.append('- 无额外例外：所有页型都遵守上面的安全区与色板纪律。')
+    L.append('')
+    write(os.path.join(ldir, 'body.md'), '\n'.join(L) + '\n')
+
+
+def emit_brief(d, ctx, ldir):
+    (tokens, rest, fonts, roles, assets, rejected, todos, archetypes, cands, sheet,
+     leftover, lsheet) = ctx
+    canvas = d['canvas']['px']
+    L = ['# 抽取简报（草案已生成，读完这一页就能改）', '',
+         '源：`%s`  画布 %dx%d  %d 页 / %d 版式  主题 %s  form=%s'
+         % (d['source']['filename'], canvas[0], canvas[1], d['counts']['slides'],
+            d['counts']['layouts'], d['theme_topology']['themes'],
+            d['form_hint']['form']), '',
+         '## 待判断（草案里已标 TODO，逐条改掉）', '']
+    base_todos = ['给风格起名：`manifest.yaml` 的 name / name_zh / description（看两张图定气质）',
+                  '`layouts.yaml` 顶部 `names:` 一段填 %d 个中文页型名（看 layout-sheet.png，'
+                  '一次改完；下面 layouts 段不要动）' % len(archetypes),
+                  '`body.md` 的 Overview 与 Hard Rules 末条（Colors 用途列草案已填好，觉得不对再改）']
+    for t in base_todos + todos:
+        L.append('- ' + t)
+    L += ['', '## 联系表（一次看完所有候选图）', '',
+          '`l-out/contact-sheet.png`  —— 编号对应下表；看完再决定 logo / 封面归属。' if sheet
+          else '（Pillow 不可用，未生成联系表；逐张看 `media-out/`）', '',
+          '| # | 文件 | 尺寸 | 出现 | 满屏 | 页 | 草案判定 |', '|---|---|---|---|---|---|---|']
+    decided = {a['src']['file']: a['id'] for a in assets}
+    why = {c['file']: r for c, r in rejected}
+    for i, c in enumerate(cands[:12], 1):
+        L.append('| %d | `%s` | %sx%s | %d | %s | %s | %s |' % (
+            i, c['file'], c['probe'].get('w') or '?', c['probe'].get('h') or '?', c['n'],
+            'Y' if c['fullscreen'] else '', ','.join(map(str, c['slides'][:6])) or 'layout',
+            decided.get(c['file']) or ('✗ ' + why.get(c['file'], '未采纳'))))
+    L += ['', '## 颜色（草案 token 已写进 frontmatter.yaml）', '',
+          '| token | hex | 出现 |', '|---|---|---|']
+    for name, r in tokens:
+        L.append('| `%s` | %s | %d |' % (name, r['hex'], r['n']))
+    if rest:
+        L.append('')
+        L.append('未取用高频色：' + '、'.join('%s(%d)' % (r['hex'], r['n']) for r in rest))
+    L += ['', '## 字体 / 字号', '']
+    for f in fonts:
+        L.append('- `%s` 渲染 %d 处，字重 %s → 降级链 `%s`%s' % (
+            f['names'][0], f['rendered'], f['weights'], ' > '.join(f['stack']),
+            '（映射表命中 %s）' % f['mapped'] if f['mapped'] else '（映射表未命中，已留原名）'))
+    L.append('')
+    L.append('字号轴：' + '、'.join('%s=%dpx(n=%d)' % (k, round(v['sz_px']), v['n'])
+                                 for k, v in roles.items()))
+    L += ['', '## 版式聚类（草案已写进 layouts.yaml）', '',
+          '`l-out/layout-sheet.png` 是各页型代表页的重建图——**看它给页型起名**，'
+          '不用再逐页查 shapes。' if lsheet else '（未生成版式图，按下面的 slot 原文命名）', '',
+          '| archetype | 页数 | 代表页 | 背景 | slot 数 |', '|---|---|---|---|---|']
+    for a in archetypes:
+        L.append('| `%s` | %d | %s | %s | %d |' % (
+            a['name'], len(a['pages']), a['rep'], a['bg'] or '（无资产底图）', len(a['slots'])))
+    if leftover:
+        L += ['', '未归入 archetype 的页：%s —— 都是单页孤例，需要就自己补一个 archetype。'
+              % ', '.join(map(str, leftover))]
+    L += ['', '各 archetype 的 slot 原文（据此起中文页型名、改 role）：', '']
+    for a in archetypes:
+        L.append('- `%s`（第 %s 页，覆盖 %s）' % (a['name'], a['rep'], a['pages']))
+        for s in a['slots']:
+            L.append('  - %s %spx 「%s」' % (s['role'], round(s['sz']), s['txt']))
+    L += ['', '## 下一步', '',
+          '1. 看 `contact-sheet.png` 和 `layout-sheet.png`；'
+          '2. 用一次批量编辑/patch 改掉四份草案里的 TODO；3. 跑 `package.py`。']
+    write(os.path.join(ldir, 'BRIEF.md'), '\n'.join(L) + '\n')
+
+
+def main(argv=None):
+    ap = argparse.ArgumentParser()
+    ap.add_argument('outdir')
+    a = ap.parse_args(argv)
+    outdir = os.path.abspath(a.outdir)
+    d = json.load(open(os.path.join(outdir, 'extract.json'), encoding='utf-8'))
+    ldir = os.path.join(outdir, 'l-out')
+    os.makedirs(ldir, exist_ok=True)
+
+    all_shapes = json.load(open(os.path.join(outdir, 'ref', 'shapes.json'),
+                                encoding='utf-8'))['shapes']
+    cusage = color_usage(all_shapes, d)
+    tokens, rest, rows = draft_colors(d, cusage)
+    fonts = draft_fonts(d)
+    archetypes, pages, leftover = draft_layouts(d, outdir)
+    cover_media = next((a['bg_raw'] for a in archetypes if a['name'] == 'cover'), None)
+    bg_needed = {a['bg_raw'] for a in archetypes if a['bg_raw'] and a['bg_raw'].startswith('ppt/media')}
+    bg_under = {p['no']: p['bg_media'] for p in pages}
+    assets, rejected, todos, alias, pool = draft_assets(d, outdir, bg_needed, cover_media, bg_under)
+    media_to_asset = {a['src']['media']: a['id'] for a in assets}
+    for m, w in (alias or {}).items():
+        if w in media_to_asset:
+            media_to_asset.setdefault(m, media_to_asset[w])
+
+    # 版式里那些贴在装饰容器上的小图（图标托底圆里的图标之类）：不进包的话，消费端只看到
+    # 一个空圆，只能自己编图形。它们是版式的一部分，按 icon 收进来。
+    ICON_CAP = 12
+    ICON_BUDGET = 3 * 1024 * 1024      # 图标是小件，占包体不该超过背景
+    cW, cH = d['canvas']['px']
+    icon_i, icon_bytes = 0, 0
+    for a in archetypes:
+        for s in a['slots']:
+            m = s.get('media')
+            if not m or media_to_asset.get(m) or media_to_asset.get(alias.get(m, m)):
+                continue
+            c = pool.get(alias.get(m, m)) or pool.get(m)
+            if not c or not c.get('out') or icon_i >= ICON_CAP:
+                continue
+            if icon_bytes + (c.get('bytes') or 0) > ICON_BUDGET:
+                continue
+            if s['box'][2] > cW * 0.25 or s['box'][3] > cH * 0.25:
+                continue                # 不是图标，是内容配图，交给消费端自备
+            icon_i += 1
+            icon_bytes += c.get('bytes') or 0
+            aid = 'icon-%d' % icon_i
+            assets.append({'id': aid, 'kind': 'icon', 'role': None, 'src': c, 'use_full': False})
+            media_to_asset[c['media']] = aid
+            media_to_asset[m] = aid
+    dropped_slots = []
+    for a in archetypes:
+        a['bg'] = media_to_asset.get(a['bg_raw'])
+        # 版式自带的图片元素：映射到资产 id。映射不到时**保留槽位但不写 asset**——
+        # 删掉整条槽，消费端看到的是一个没有图标的托底圆，和图标不进包是同一个失败模式，
+        # 而且它连「这里本来有东西」都不知道。
+        keep = []
+        for s in a['slots']:
+            if s.get('media'):
+                aid = media_to_asset.get(s['media'])
+                if not aid:
+                    s['role'] = 'icon'
+                    s.pop('media', None)
+                    dropped_slots.append((a['name'], s['box']))
+                    keep.append(s)
+                    continue
+                s['asset'] = aid
+                # role 跟着资产走：图标槽写成 logo 会让消费端把它当品牌标识，每页都摆一个
+                s['role'] = next((x['kind'] for x in assets if x['id'] == aid), s['role'])
+            keep.append(s)
+        a['slots'] = keep
+    roles = draft_scale(d, archetypes)
+    slot_added = cover_slot_colors(tokens, archetypes, rows, cusage)
+    cands = sorted([c for c in [a['src'] for a in assets]] +
+                   [c for c, _ in rejected], key=lambda c: (-c['n'], c['file']))
+    sheet = contact_sheet(outdir, cands, os.path.join(ldir, 'contact-sheet.png'))
+    lsheet = layout_sheet(outdir, archetypes, os.path.join(ldir, 'layout-sheet.png'))
+
+    anchors = draft_anchors(d, tokens, fonts, roles, assets, archetypes)
+    gaps, exceptions = [], []
+    for c, why in rejected:
+        if '近全透明' in why:
+            gaps.append('母版/版式里的 %s 是%s，不是设计资产，任何情况下不要当背景用。' % (c['file'], why))
+    if dropped_slots:
+        gaps.append('这些图标槽的源图没有随包分发（超出图标配额或不适合进包）：%s。'
+                    '槽位保留了坐标，渲染时留空或用中性占位，不要自造图形去填。'
+                    % '、'.join('%s %s' % (n, b) for n, b in dropped_slots[:8]))
+    # 「没命中映射表」不等于「装不上」：降级目标本身（Noto Sans SC 之类）和 Office 出厂体
+    # 都不在 match 列里，但它们本来就可用。真正危险的是**既没命中、又不是已知可用字体**的
+    # 那种——design.md 的字体栈里留着一个消费端装不上的商业字体名，且没有任何降级说明。
+    web_ok = {norm(x) for fam in parse_fallback_table() for x in fam['fallback']}
+    web_ok |= {norm(x.strip().strip('"')) for x in SYS_FALLBACK.split(',')}
+    for f in fonts:
+        if f.get('mapped'):
+            gaps.append('源字体 %s 无 web 授权源，已按 font-fallback 表降级到 %s；字形细节与原稿有差异。'
+                        % (f['names'][0], f['stack'][1]))
+        elif norm(f['names'][0]) in OFFICE_DEFAULT_FONTS_NORM:
+            gaps.append('%s 是 Office 出厂字体，多半是模板里没清干净的残留而非设计选型；'
+                        '按正文/标题的实际气质挑替代体，不要照抄它。' % f['names'][0])
+        elif norm(f['names'][0]) not in web_ok:
+            gaps.append('源字体 %s 不在 font-fallback 表里，字体栈只有原名，消费端很可能装不上；'
+                        '按气质挑一个有 web 分发源的近似体补进栈，不要照抄原名。' % f['names'][0])
+    nosize = [(a['name'], s['box']) for a in archetypes for s in a['slots']
+              if not s.get('asset') and not s.get('size')]
+    if nosize:
+        gaps.append('这些文字槽在源文件任何层级都没有字号声明（都不是占位符，是普通文本框，'
+                    '继承源是 presentation.xml 的 defaultTextStyle，本抽取按约定不解继承链）：'
+                    '%s。用 typography 里最接近的档位，不要自造新档。'
+                    % '、'.join('%s %s' % (n, b) for n, b in nosize[:6]))
+
+    if leftover:
+        exceptions.append('源 deck 第 %s 页是单页孤例，没有归纳成 archetype；需要类似构图时按最接近的页型改。'
+                          % '、'.join(map(str, leftover)))
+
+    emit_manifest(d, assets, ldir)
+    emit_frontmatter(d, tokens, fonts, roles, anchors, gaps, ldir)
+    emit_layouts(archetypes, ldir)
+    emit_body(d, tokens, fonts, roles, assets, archetypes, exceptions, cusage, ldir)
+    emit_brief(d, (tokens, rest, fonts, roles, assets, rejected, todos, archetypes, cands, sheet,
+                   leftover, lsheet), ldir)
+
+    print('草案就绪 -> %s' % ldir)
+    print('  资产 %d（%s）  版式 %d  色 %d  字体 %d'
+          % (len(assets), ', '.join(x['id'] for x in assets), len(archetypes), len(tokens), len(fonts)))
+    print('  先读 l-out/BRIEF.md，再看 l-out/contact-sheet.png')
+    return 0
+
+
+if __name__ == '__main__':
+    sys.exit(main())