@lark-apaas/coding-steering 0.1.18-dev.655b398 → 0.1.18-dev.7f786ca

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

@@ -98,7 +98,8 @@ L 层判断单 schema（<l-out-dir> 四个文件，这段就是填写说明书
         role: cover
         background: bg-cover
         slots:
-          - {role: title, box: [<x>, <y>, <w>, <h>], type: title}
+          - {role: title, box: [<x>, <y>, <w>, <h>], type: title,
+             css: "<由源模板转译出的 CSS 声明串>"}
         confidence: high
 
   可选 `body:` 块标量 —— 追加到 layouts.md frontmatter 之后作为说明正文。
@@ -234,11 +235,13 @@ def parse_item_list(lines):
 
 def read_manifest(path):
     blocks = split_top_blocks(open(path, encoding='utf-8').read())
-    man, assets, raw = {}, [], {}
+    man, assets, asset_decisions, raw = {}, [], [], {}
     derived = []
     for key, inline, lines in blocks:
         if key == 'assets':
             assets = parse_item_list(lines)
+        elif key == 'asset_decisions':
+            asset_decisions = parse_item_list(lines)
         elif key == 'derived':
             derived = parse_item_list(lines)
         elif inline.startswith('['):
@@ -252,6 +255,7 @@ def read_manifest(path):
             # 不把作者的折行改成一条长行。
             raw[key] = (inline, lines)
     man['assets'] = assets
+    man['asset_decisions'] = asset_decisions
     man['derived'] = derived
     man['_raw'] = raw
     return man
@@ -274,6 +278,10 @@ def truthy(v):
     return str(v).strip().lower() in ('1', 'true', 'yes', 'on')
 
 
+# 浏览器能解码的图片格式。落进包的资产必须在此列，否则消费端引用到就是一张空白图。
+WEB_SAFE_EXT = {'png', 'jpg', 'jpeg', 'webp', 'gif', 'svg', 'avif'}
+
+
 def asset_ext(name):
     return name.rsplit('.', 1)[-1].lower() if '.' in name else ''
 
@@ -286,6 +294,68 @@ def strip_kind_prefix(aid, kind):
     return aid
 
 
+def apply_asset_decisions(manifest, bound_sources=None):
+    """把临时图片判断并入正式 assets；content 只用于删除候选，不进入消费产物。"""
+    allowed = {'content', 'texture', 'logo', 'icon', 'slogan'}
+    decisions = {}
+    for item in manifest.get('asset_decisions') or []:
+        source = unquote(item.get('source_media') or '')
+        decision = unquote(item.get('decision') or '')
+        if not source or decision not in allowed:
+            raise Fail('asset_decisions 必须逐项填写 source_media 和 decision；'
+                       'decision 只能是 %s' % '|'.join(sorted(allowed)))
+        decisions[source] = decision
+    if bound_sources is not None:
+        unbound = sorted(set(decisions) - set(bound_sources))
+        if unbound:
+            raise Fail('asset_decisions 中这些图片没有对应图片槽：%s'
+                       % '、'.join(unbound))
+
+    assets = []
+    by_source = {}
+    serial = Counter()
+    used_ids = {unquote(item.get('id') or '')
+                for item in manifest.get('assets') or [] if item.get('id')}
+    for item in manifest.get('assets') or []:
+        source = unquote(item.get('source_media') or '')
+        if source and decisions.get(source) == 'content':
+            continue
+        row = dict(item)
+        decision = decisions.get(source)
+        old_kind = unquote(row.get('kind') or '')
+        if decision:
+            row['kind'] = decision
+            if decision != old_kind:
+                serial[decision] += 1
+                aid = '%s-%d' % (KIND_PREFIX[decision], serial[decision])
+                while aid in used_ids:
+                    serial[decision] += 1
+                    aid = '%s-%d' % (KIND_PREFIX[decision], serial[decision])
+                row['id'] = aid
+                for field in ('role', 'theme', 'on-bg', 'mark'):
+                    row.pop(field, None)
+        used_ids.add(unquote(row.get('id') or ''))
+        assets.append(row)
+        if source:
+            by_source[source] = row
+
+    for source, decision in decisions.items():
+        if decision == 'content' or source in by_source:
+            continue
+        serial[decision] += 1
+        prefix = KIND_PREFIX[decision]
+        aid = '%s-%d' % (prefix, serial[decision])
+        while aid in used_ids:
+            serial[decision] += 1
+            aid = '%s-%d' % (prefix, serial[decision])
+        used_ids.add(aid)
+        row = {'id': aid, 'source_media': source, 'kind': decision}
+        assets.append(row)
+        by_source[source] = row
+    manifest['assets'] = assets
+    return decisions, {source: unquote(item['id']) for source, item in by_source.items()}
+
+
 def media_row_of(extract, source_media):
     for m in extract.get('media') or []:
         if m.get('out') and os.path.basename(m['out']) == source_media:
@@ -353,12 +423,25 @@ def place_assets(manifest, extract, stage1, pack):
                 entry['path'] = 'assets/%ss/%s.%s' % (kind, base, cext)
                 if truthy(a.get('use_full')):
                     oext = asset_ext(row['out'])
-                    fdst = os.path.join(sub, '%s@full.%s' % (base, oext))
-                    shutil.copy2(orig_path, fdst)
-                    copied.append(fdst)
-                    entry['full'] = 'assets/%ss/%s@full.%s' % (kind, base, oext)
+                    if oext.lower() in WEB_SAFE_EXT:
+                        fdst = os.path.join(sub, '%s@full.%s' % (base, oext))
+                        shutil.copy2(orig_path, fdst)
+                        copied.append(fdst)
+                        entry['full'] = 'assets/%ss/%s@full.%s' % (kind, base, oext)
+                    else:
+                        # 原图是浏览器不解码的格式（tiff/bmp 之类）。落进包并在 design.md
+                        # 里声明成可用资源，消费端引用它就是一张空白图——实测踩过一次，
+                        # 封面与结束页因此空白。压缩版已经带着全部像素，full 不给。
+                        print('  ⚠ %s 的原图是 .%s，浏览器不解码，只给压缩版' % (aid, oext))
             else:
                 oext = asset_ext(row['out'])
+                if oext.lower() not in WEB_SAFE_EXT:
+                    # 转码两条路（Pillow / sips）都没成，原图又是浏览器不解码的格式。
+                    # 照落进去就是把一张永远显示不出来的图当资产下发——实测封面因此空白。
+                    raise Fail('%s: 原图是 .%s，浏览器不解码，而转码没有产物'
+                               '（extract.json 里看 transcode_blocked 的原因）。'
+                               '装上 Pillow 重跑抽取，或把这条资产从 manifest 删掉'
+                               '并在 gaps 写明。' % (aid, oext))
                 dst = os.path.join(sub, '%s.%s' % (base, oext))
                 shutil.copy2(orig_path, dst)
                 copied.append(dst)
@@ -457,6 +540,16 @@ def expand_placeholders(body, manifest, consumer, audit, extract, layouts_text):
                 f += '（原图 `%s`）' % e['full']
             rows.append('| `%s` | %s | %s |' % (aid, f, when))
         body = body.replace('{{ASSET_TABLE}}', '\n'.join(rows))
+    if '{{LOGO_RULES}}' in body:
+        rows = []
+        for aid, entry in consumer.items():
+            if entry.get('kind') != 'logo':
+                continue
+            owners = _archetypes_using(layouts_text, aid)
+            rows.append('- `%s` 只出现在这些页型上：%s；其余页型不放。位置取该页型 '
+                        '`slots` 里 `role: logo` 那一项的 `box`，原样使用该文件、保持原比例。'
+                        % (aid, '、'.join('`%s`' % owner for owner in owners) or '（无）'))
+        body = body.replace('{{LOGO_RULES}}', '\n'.join(rows))
     if '{{LAYOUT_LIST}}' in body:
         rows, sect, names = [], None, {}
         for line in (layouts_text or '').split('\n'):
@@ -490,7 +583,7 @@ def render_assets_block(consumer):
 
 # ------------------------------------------------- 数值可追溯机检（抄错即 FAIL）
 HEX_RE = re.compile(r'#([0-9A-Fa-f]{6})\b')
-FONTSIZE_RE = re.compile(r'\bfontSize:\s*([\d.]+)px')
+FONTSIZE_RE = re.compile(r'\b(?:fontSize|font-size):\s*([\d.]+)px')
 BOX_RE = re.compile(r'\bbox:\s*\[\s*(-?[\d.]+)\s*,\s*(-?[\d.]+)\s*,'
                     r'\s*(-?[\d.]+)\s*,\s*(-?[\d.]+)\s*\]')
 KEYLINE_RE = re.compile(r'^(\s*)-?\s*([A-Za-z_][\w-]*):\s*(.*)$')
@@ -633,6 +726,42 @@ def _box_hit(box, idx):
 JUDGEMENT_KEYS = frozenset(('avoid', 'text_safe', 'pairing_rule'))
 
 
+def media_integrity(stage1, extract):
+    """extract.json 记录的尺寸，必须和磁盘上那个文件真实的尺寸一致。
+
+    这条挡的是「记录全对、文件被顶替」——两个 media 的输出名撞车时，后写的覆盖先写的，
+    extract.json 里各自的记录都还是对的，任何只读记录的检查都发现不了；只有把记录和
+    文件本身对一遍才抓得到。实测某模板因此把一张 109x109 的图当成了整页背景。
+    """
+    try:
+        from PIL import Image
+    except Exception:
+        return []                      # 没有 Pillow 就量不了，跳过而不是假装通过
+    bad, seen = [], {}
+    for m in extract.get('media') or []:
+        for key, rel in (('source_px', m.get('out')),
+                         ('compressed_px', m.get('compressed_out'))):
+            rec = m.get(key)
+            if not rel or not rec:
+                continue
+            path = os.path.join(stage1, rel)
+            if not os.path.exists(path):
+                bad.append('%s 的 %s 指向 %s，文件不存在' % (m['media'], key, rel))
+                continue
+            try:
+                with Image.open(path) as im:
+                    real = list(im.size)
+            except Exception:
+                continue
+            if real != list(rec):
+                bad.append('%s 的 %s 记录 %s，但 %s 实际是 %s'
+                           % (m['media'], key, rec, rel, real))
+            if rel in seen and seen[rel] != m['media']:
+                bad.append('%s 与 %s 都写到 %s' % (seen[rel], m['media'], rel))
+            seen[rel] = m['media']
+    return bad
+
+
 def trace_check(pack, extract, shapes, derived_values, derived_tokens, factor):
     """产物里每个 hex / 字号 / slot 坐标都必须可追溯到普查值或 derived 声明。"""
     idx = build_trace_index(extract, shapes)
@@ -849,14 +978,157 @@ def build_design(manifest, l_frontmatter, consumer, body, has_sidecar, canvas):
     return text
 
 
-def build_layouts_md(layouts_blocks, canvas):
+def layout_forms(lines):
+    """每个页型草案里实际给了哪几种形态（flow / slots）。"""
+    out, cur = {}, None
+    for line in lines:
+        m = re.match(r'^  ([\w-]+):\s*$', line)
+        if m:
+            cur = m.group(1)
+            out[cur] = set()
+            continue
+        m = re.match(r'^    (flow|slots):\s*$', line)
+        if m and cur:
+            out[cur].add(m.group(1))
+    return out
+
+
+def layout_modes(lines):
+    """读取扁平 `layout_modes:` 判断区。"""
+    out = {}
+    for line in lines:
+        m = re.match(r'^\s{2}([\w-]+):\s*([^\s#]+)', line)
+        if m:
+            out[m.group(1)] = m.group(2).strip()
+    return out
+
+
+def text_role_boxes(lines):
+    """从 slots 里的同名标记取回文本槽坐标，供 flow 固定锚点复用。"""
+    out, pending = {}, None
+    for line in lines:
+        marker = re.match(r'^\s*#\s*text-role:\s*([\w-]+)\s*$', line)
+        if marker:
+            pending = marker.group(1)
+            continue
+        if pending:
+            box = re.search(r'\bbox:\s*(\[[^\]]+\])', line)
+            if box:
+                out[pending] = box.group(1)
+                pending = None
+    return out
+
+
+def select_layout_forms(lines, modes):
+    """按 `layout_modes` 只保留每个页型选中的 flow 或 slots。"""
+    out, layout, drop = [], None, False
+    for line in lines:
+        layout_match = re.match(r'^  ([\w-]+):\s*$', line)
+        form_match = re.match(r'^    (flow|slots):\s*$', line)
+        if layout_match:
+            layout, drop = layout_match.group(1), False
+        elif form_match:
+            drop = modes.get(layout) not in (None, form_match.group(1))
+        elif drop and re.match(r'^    \S', line):
+            drop = False
+        if not drop:
+            out.append(line)
+    return out
+
+
+def shrink_safe_area(lines):
+    """text_safe 与 avoid 相交时把安全区收掉重叠的那部分。
+
+    text_safe 是脚本按「该背景各页型的槽位并集」算的，而模板里的槽位本身可能就压在
+    主视觉上；avoid 是看图的人填的。两者从不同来源来，会直接打架——实测一张背景的
+    text_safe 有 34% 落在 avoid 里，消费端按 text_safe 把标题放进了禁放区，正好压在
+    背景的山峰主体上。这里以 avoid 为准收缩：能不能放字是看图的人说了算。
+    """
+    def parse_box(s):
+        m = re.findall(r'-?\d+', s)
+        return [int(x) for x in m[:4]] if len(m) >= 4 else None
+
+    ts_i = ts = None
+    avoids = []
+    for i, ln in enumerate(lines):
+        st = ln.strip()
+        if st.startswith('text_safe:'):
+            ts_i, ts = i, parse_box(st.split(':', 1)[1].split('#')[0])
+        elif st.startswith('avoid:'):
+            for chunk in re.findall(r'box:\s*\[[^\]]*\]', st):
+                b = parse_box(chunk)
+                if b:
+                    avoids.append(b)
+    if ts is None or not avoids:
+        return lines, None
+    x0, y0, x1, y1 = ts[0], ts[1], ts[0] + ts[2], ts[1] + ts[3]
+    for a in avoids:
+        ax0, ay0, ax1, ay1 = a[0], a[1], a[0] + a[2], a[1] + a[3]
+        if ax1 <= x0 or ax0 >= x1 or ay1 <= y0 or ay0 >= y1:
+            continue                       # 不相交
+        # 从被侵占得最少的一边切：优先保留面积最大的剩余矩形
+        cands = []
+        if ax0 > x0:
+            cands.append((x0, y0, ax0, y1))
+        if ax1 < x1:
+            cands.append((ax1, y0, x1, y1))
+        if ay0 > y0:
+            cands.append((x0, y0, x1, ay0))
+        if ay1 < y1:
+            cands.append((x0, ay1, x1, y1))
+        if not cands:
+            return lines, 'text_safe 被 avoid 完全覆盖，这张背景没有可放文字的区域'
+        x0, y0, x1, y1 = max(cands, key=lambda c: (c[2] - c[0]) * (c[3] - c[1]))
+    new = [x0, y0, x1 - x0, y1 - y0]
+    if new == ts:
+        return lines, None
+    lines = list(lines)
+    lines[ts_i] = '    text_safe: [%d, %d, %d, %d]   # 已按 avoid 收缩（原 %s）' % (
+        new[0], new[1], new[2], new[3], ts)
+    return lines, None
+
+
+def resolve_asset_candidate_lines(lines, decisions, asset_ids):
+    """把 source_media 临时字段转成资产引用；内容图保留通用 pic 槽。"""
+    out = []
+    content_slots = set()
+    for line in lines:
+        match = re.search(r'\bsource_media:\s*([^,}]+)', line)
+        if not match:
+            out.append(line)
+            continue
+        source = unquote(match.group(1).strip())
+        decision = decisions.get(source)
+        line = re.sub(r'\s*,?\s*source_media:\s*[^,}]+', '', line, count=1)
+        if decision == 'content':
+            line = re.sub(r'\s*,?\s*asset:\s*[^,}]+', '', line, count=1)
+            line = re.sub(r'(\brole:\s*)[\w-]+', r'\g<1>pic', line, count=1)
+            content_key = line.strip()
+            if content_key in content_slots:
+                continue
+            content_slots.add(content_key)
+            out.append(line)
+            continue
+        aid = asset_ids.get(source)
+        if not aid:
+            raise Fail('layouts.yaml 引用了未完成资产判断的 source_media: %s' % source)
+        if re.search(r'\basset:\s*[^,}]+', line):
+            line = re.sub(r'(\basset:\s*)[^,}]+', r'\g<1>%s' % aid, line, count=1)
+        else:
+            line = line.replace('}', ', asset: %s}' % aid, 1)
+        line = re.sub(r'(\brole:\s*)[\w-]+', r'\g<1>%s' % decision, line, count=1)
+        out.append(line)
+    return out
+
+
+def build_layouts_md(layouts_blocks, canvas, asset_decisions=None, asset_ids=None):
     blocks = {k: (inline, lines) for k, inline, lines in layouts_blocks}
     if 'canvas' in blocks:
         raise Fail('layouts.yaml 不要写 canvas —— 脚本从 extract.json 取')
     if 'layouts' not in blocks:
         raise Fail('layouts.yaml 缺顶层键 `layouts:`')
-    # `names:` / `bg_rules:` 是给 L 层集中填判断的两块扁平区——在这里并回各
-    # archetype，本身不进产物。让 L 层只改扁平键值，别去动 layouts 里的
+    # `names:` / `roles:` / `text_roles:` / `layout_modes:` / `bg_rules:` 是给 L 层集中填判断的
+    # 扁平区——在这里并回各 archetype，本身不进产物。让 L 层只改扁平键值，别去动 layouts 里的
     # slots/confidence 结构（嵌套结构手改极易破坏缩进，进而静默改变语义）。
     names, roles = {}, {}
     for key, sink in (('names', names), ('roles', roles)):
@@ -864,6 +1136,17 @@ def build_layouts_md(layouts_blocks, canvas):
             m = re.match(r'^\s{2}([\w-]+):\s*(.+?)\s*$', line)
             if m:
                 sink[m.group(1)] = unquote(m.group(2))
+    text_roles = {}
+    allowed_text_roles = {'title', 'subtitle', 'header', 'footer', 'body'}
+    for line in blocks.get('text_roles', ('', []))[1]:
+        m = re.match(r'^\s{2}([\w-]+):\s*([A-Za-z-]+)(?:\s+#.*)?$', line)
+        if not m:
+            continue
+        role_id, role = m.groups()
+        if role not in allowed_text_roles:
+            raise Fail('text_roles.%s 取值 %s 非法；应为 %s'
+                       % (role_id, role, '|'.join(sorted(allowed_text_roles))))
+        text_roles[role_id] = role
     bg_rules, cur = {}, None
     for line in blocks.get('bg_rules', ('', []))[1]:
         # 键后面允许行内注释（草案会标「用它的页型：…」）
@@ -880,25 +1163,102 @@ def build_layouts_md(layouts_blocks, canvas):
     if bg_rules:
         out.append('backgrounds:')
         for bg, lines in bg_rules.items():
+            lines, err = shrink_safe_area(lines)
+            if err:
+                raise Fail('%s: %s' % (bg, err))
             out.append('  %s:' % bg)
             out += lines
+    modes = layout_modes(blocks.get('layout_modes', ('', []))[1])
     out.append('layouts:')
-    for line in blocks['layouts'][1]:
-        out.append(line)
+    pending_text_role = None
+    used_text_roles = set()
+    source_layout_lines = resolve_asset_candidate_lines(
+        blocks['layouts'][1], asset_decisions or {}, asset_ids or {})
+    role_boxes = text_role_boxes(source_layout_lines)
+    layout_lines = select_layout_forms(source_layout_lines, modes)
+    cur, fixed_items = None, []
+
+    def flush_fixed_items():
+        if not fixed_items:
+            return
+        out.append('        - kind: free')
+        out.append('          items:')
+        out.extend(fixed_items)
+        fixed_items.clear()
+
+    for line in layout_lines:
         m = re.match(r'^  ([\w-]+):\s*$', line)
+        if m:
+            flush_fixed_items()
+            cur = m.group(1)
+        elif fixed_items and re.match(r'^    \S', line):
+            flush_fixed_items()
+        # 判断单里的结构事实（栅格、间距序列、样张字数、命中配方）是给 L 层判断用的，
+        # 不进产物——消费端要的是结论，不是推导过程。layout_mode 同理，它是判断的载体。
+        if line.lstrip().startswith('#'):
+            marker = re.match(r'^\s*#\s*text-role:\s*([\w-]+)\s*$', line)
+            if marker:
+                pending_text_role = marker.group(1)
+            continue
+        if pending_text_role:
+            if pending_text_role not in text_roles:
+                raise Fail('text_roles 缺少 %s 的判断' % pending_text_role)
+            role = text_roles[pending_text_role]
+            slot_type = role if role in ('title', 'subtitle', 'header', 'footer') else 'body'
+            line, role_n = re.subn(r'(\{\s*role:\s*)[\w-]+',
+                                   r'\g<1>%s' % role, line, count=1)
+            line, type_n = re.subn(r'(\btype:\s*)[\w-]+',
+                                   r'\g<1>%s' % slot_type, line, count=1)
+            if role_n != 1 or type_n != 1:
+                raise Fail('text_roles.%s 没有命中一个文本槽' % pending_text_role)
+            if (modes.get(cur) == 'flow' and role in ('header', 'footer')
+                    and re.match(r'^\s{12}-\s*\{', line) and 'box:' not in line):
+                box = role_boxes.get(pending_text_role)
+                if not box:
+                    raise Fail('text_roles.%s 识别为 %s，但 slots 中没有坐标'
+                               % (pending_text_role, role))
+                line = re.sub(r',\s*type:', ', box: %s, type:' % box, line, count=1)
+                fixed_items.append(line)
+                used_text_roles.add(pending_text_role)
+                pending_text_role = None
+                continue
+            used_text_roles.add(pending_text_role)
+            pending_text_role = None
+        out.append(line)
         if m and m.group(1) in names:
             out.append('    name: "%s"' % names.pop(m.group(1)))
         if m and m.group(1) in roles:
             out.append('    role: %s' % roles.pop(m.group(1)))
+    flush_fixed_items()
     if names:
         raise Fail('names 里这些页型在 layouts 下找不到：%s' % ', '.join(sorted(names)))
     if roles:
         raise Fail('roles 里这些页型在 layouts 下找不到：%s' % ', '.join(sorted(roles)))
+    unused_text_roles = set(text_roles) - used_text_roles
+    if unused_text_roles:
+        raise Fail('text_roles 里这些判断没有命中文本槽：%s'
+                   % ', '.join(sorted(unused_text_roles)))
     missing_role = [k for k in re.findall(r'^  ([\w-]+):\s*$', '\n'.join(blocks['layouts'][1]), re.M)
                     if not re.search(r'^  %s:\s*$(?:\n(?!  \S).*)*?\n    role:' % re.escape(k),
                                      '\n'.join(out), re.M)]
     if missing_role:
         raise Fail('这些页型没有 role（在 layouts.yaml 的 roles 段填）：%s' % ', '.join(missing_role))
+    # `layout_modes.*: TODO` 由上面那道通用 TODO 扫描报（它连行内提示一起打出来），
+    # 这里只管它管不到的两种：整行被删、以及填了 flow/slots 之外的值。
+    forms = layout_forms(blocks['layouts'][1])
+    bad = []
+    for k, v in sorted(modes.items()):
+        if len(forms.get(k) or ()) < 2:
+            continue                          # 只有一份形态，无从选择
+        if v not in ('flow', 'slots'):
+            bad.append('%s 的 layout_modes 判断是 %r' % (k, v))
+        elif v not in forms[k]:
+            bad.append('%s 选了 %s 但该页型没有这一份' % (k, v))
+    for k, forms_for_layout in sorted(forms.items()):
+        if len(forms_for_layout) >= 2 and k not in modes:
+            bad.append('%s 缺 layout_modes 判断' % k)
+    if bad:
+        raise Fail('layout_modes 只能填 flow 或 slots，一个页型一个词：%s' % '；'.join(bad))
     declared = set(re.findall(r'^    background:\s*(\S+)\s*$',
                               '\n'.join(blocks['layouts'][1]), re.M))
     stray = set(bg_rules) - declared
@@ -981,12 +1341,24 @@ def main(argv=None):
     lay_path = os.path.join(lout, 'layouts.yaml')
     layouts_blocks = (split_top_blocks(open(lay_path, encoding='utf-8').read())
                       if os.path.exists(lay_path) else None)
+    bound_sources = set()
+    if layouts_blocks is not None:
+        for _, _, lines in layouts_blocks:
+            for line in lines:
+                match = re.search(r'\bsource_media:\s*([^,}]+)', line)
+                if match:
+                    bound_sources.add(unquote(match.group(1).strip()))
+    asset_decisions, asset_ids = apply_asset_decisions(
+        manifest, bound_sources=bound_sources if manifest.get('asset_decisions') else None)
     canvas = extract['canvas']['px']
+    final_layouts = (build_layouts_md(
+        layouts_blocks, canvas, asset_decisions=asset_decisions, asset_ids=asset_ids)
+        if layouts_blocks is not None else None)
 
     os.makedirs(pack, exist_ok=True)
     consumer, audit, copied = place_assets(manifest, extract, stage1, pack)
 
-    lay_text = open(lay_path, encoding='utf-8').read() if os.path.exists(lay_path) else ''
+    lay_text = final_layouts or ''
     body = expand_placeholders(body, manifest, consumer, audit, extract, lay_text)
     design = build_design(manifest, l_fm, consumer, body,
                           has_sidecar=layouts_blocks is not None, canvas=canvas)
@@ -994,7 +1366,7 @@ def main(argv=None):
         f.write(design)
     if layouts_blocks is not None:
         with open(os.path.join(pack, 'layouts.md'), 'w', encoding='utf-8') as f:
-            f.write(build_layouts_md(layouts_blocks, canvas))
+            f.write(final_layouts)
 
     # 审计记录写回**抽取工作目录**，不进交付包：包是消费产物，`ref/` 里的东西
     # 没有任何门禁读、消费模型也用不上，放进去只会让「别读我」和「几 MB 材料」同时下发。
@@ -1042,6 +1414,12 @@ def main(argv=None):
     shapes = json.load(open(sp, encoding='utf-8'))['shapes'] if os.path.exists(sp) else []
     problems, checked = trace_check(pack, extract, shapes,
                                     derived_values, derived_tokens, factor)
+    integrity = media_integrity(stage1, extract)
+    if integrity:
+        print('\n--- 媒体产物完整性 ---')
+        for b in integrity:
+            print('  FAIL ' + b)
+        raise Fail('media-out 里的文件和 extract.json 的记录对不上（%d 处）' % len(integrity))
     print('\n--- 数值可追溯机检 ---')
     print('  受检 hex %d / fontSize %d / slot box %d；derived 豁免 %d%s%s'
           % (checked['hex'], checked['size'], checked['box'], checked['exempt'],

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

@@ -393,6 +393,9 @@ def walk_tree(el, ctx, out, path=(), xf=(1.0, 1.0, 0.0, 0.0), depth=0):
             blip = sp.find('p:blipFill/a:blip', NS)
             if blip is not None:
                 rec['media'] = ctx.media_of(blip.get(R_EMBED)) or ctx.media_of(blip.get(R_LINK))
+                alpha = blip.find('a:alphaModFix', NS)
+                if alpha is not None and alpha.get('amt') is not None:
+                    rec['opacity'] = round(int(alpha.get('amt')) / 100000.0, 6)
                 svg = blip.find('a:extLst//asvg:svgBlip', NS)
                 if svg is not None:
                     rec['media_svg'] = ctx.media_of(svg.get(R_EMBED))

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

@@ -244,14 +244,10 @@ def _recipe_css(fill, line, radii, effects):
             dash = (line or {}).get('dash')
             style = 'dashed' if dash and 'dash' in dash else 'solid'
             out.append('border: %dpx %s %s' % (w, style, lc))
-    if radii:
+    if radii and all(r >= 1 for r in radii):
         lo, hi = min(radii), max(radii)
         if abs(hi - lo) <= 0.5:
             out.append('border-radius: %gpx' % round(lo, 1))
-        else:
-            out.append('border-radius: %gpx\x00/* 源内 %g~%gpx 共 %d 档，归一档位由 L11 定 */'
-                       % (round(sum(radii) / len(radii), 1), round(lo, 1), round(hi, 1),
-                          len(set(round(r, 1) for r in radii))))
     for e in effects or []:
         if e.get('type') == 'outerShdw':
             col = _css_color(e.get('color')) or 'rgba(0,0,0,0.25)'
@@ -267,7 +263,7 @@ def _recipe_css(fill, line, radii, effects):
 def _sig(fill, line, effects):
     """分组键 = 填充 + 描边 + 效果。**不含圆角**——OOXML 圆角是 min(w,h) 的百分比，
     同一配方在不同尺寸的卡上绝对 px 必然不同，把它计入键会把一个配方拆成多组；
-    归一到哪一档是判断，脚本只报区间。"""
+    只有组内每个形状都明确共享同一绝对半径时才输出组级圆角，否则留给逐形状 CSS。"""
     f = 'none'
     if isinstance(fill, dict):
         if fill.get('type') == 'solid':
@@ -305,8 +301,7 @@ def cmd_recipes(a, outdir):
         g = groups.setdefault(k, {'n': 0, 'parts': Counter(), 'sizes': [], 'radii': [],
                                   'fill': fill, 'line': line, 'fx': fx})
         g['n'] += 1
-        if radius:
-            g['radii'].append(radius)
+        g['radii'].append(radius or 0)
         g['parts'][short(s['part'])] += 1
         b = s.get('box') or {}
         if b.get('w'):