cardbuddy 0.14.3 → 0.16.0

package/dist/vendored/skills/dsl-card-generator/scripts/lib/v3_extract.mjs

@@ -0,0 +1,4214 @@
+/**
+ * v3_extract.mjs — 语义识别层（启发式提名；2026-09-21 自 spec_to_schema_v3.mjs 拆出）。
+ * extractSemantics：spec.json 几何聚类 → 语义决策（Phase 2 的"提名者"）。
+ * semDecisionsView / applySemDecisions：AI 终审决策回路（白名单覆盖）。
+ * 消费方：lib/v3_assemble.mjs（generate 无 semOverride 时调用）、CLI。
+ */
+import fs from 'node:fs'
+import { T } from './layout-tokens.mjs'
+import { sampleOutlineRing } from './design_sample.mjs'
+import { resolveSliceExport, sliceRefPath } from './slicePath.mjs'
+import {
+  FORM_ROW_BASE_GAP,
+  LABEL_MAX_NUM_FONT,
+  RIGHT_ACTION_X_RATIO,
+  ROLE_BASE_NAME,
+  classifyValue,
+  container,
+  detectChartClusters,
+  detectEnumStatStrip,
+  displayPrefixRe,
+  entityKeyFor,
+  hexToRgba,
+  isBg,
+  lum,
+  parseAmount,
+  radiusMax,
+  rect,
+  rectInside,
+  roleFieldKey,
+  sameRow,
+  splitValueTokens,
+  textOf,
+  ts,
+  uniqueKey,
+  unmask,
+  valueExpr,
+} from './v3_shared.mjs'
+export function extractSemantics(spec, cardIndex = 0, opts = {}) {
+  // 设计稿聚焦图（可选）：标注缺陷交叉校验（小 pill 描边环采样等），视觉优先；缺省跳过校验。
+  const _designImage = opts.designImage || null
+  const card = (spec.cards || [])[Number(cardIndex) || 0] || {}
+  const all = (card.elements || []).length ? card.elements : (spec.elements || [])
+  let content = all.filter((e) => !isBg(e))
+  // 图表矢量簇（柱+网格线+轴/值标签）先整体摘出：下游无图表消费通道，不摘出会被静默丢弃/错排
+  const chartClusters = detectChartClusters(content)
+  if (chartClusters.length) {
+    const absorbed = new Set(chartClusters.flatMap((c) => [...c.members, ...c.texts]))
+    content = content.filter((e) => !absorbed.has(e))
+  }
+  const rawTexts = content
+    .filter((e) => e.type === 'text' && textOf(e))
+    .sort((a, b) => (rect(a).y || 0) - (rect(b).y || 0))
+  // 上游标注偶发「合并重复层」：同一位置既有"排队：5"又有"排队："+"5"（粒度层）。
+  // 若 A 与 B 同位且 A.text 以 B.text 为前缀、且余下片段在同一行存在独立文本层 → 丢弃合并层 A，
+  // 否则下游会同时渲染"排队："与"排队：5"造成重复文本。
+  const mergedDup = new Set()
+  for (const a of rawTexts) {
+    const ta = textOf(a)
+    for (const b of rawTexts) {
+      if (a === b || mergedDup.has(a)) continue
+      const tb = textOf(b)
+      if (!ta.startsWith(tb) || ta.length <= tb.length) continue
+      if (Math.abs((rect(a).x || 0) - (rect(b).x || 0)) > 4 || Math.abs((rect(a).y || 0) - (rect(b).y || 0)) > 4) continue
+      const rest = ta.slice(tb.length)
+      const hasGranular = rawTexts.some((c) => c !== a && c !== b && textOf(c) === rest
+        && sameRow(c, b) && (rect(c).x || 0) >= (rect(b).x || 0))
+      if (hasGranular) { mergedDup.add(a); break }
+    }
+  }
+  const _preMerged = mergedDup.size ? rawTexts.filter((e) => !mergedDup.has(e)) : rawTexts
+  // 同行重叠层去重：同 y 行（高度差 ≤4）两文本层重叠面积 ≥50% 且文案互为包含（超串）时，
+  // 丢弃较短层（如 "¥9,293.25" 与 "9,293.25" 是同一份金额的重复标注，并存会被双重绑定）。
+  const containedFrag = new Set()
+  for (const a of _preMerged) {
+    const ta = textOf(a)
+    for (const b of _preMerged) {
+      if (a === b || containedFrag.has(a) || containedFrag.has(b)) continue
+      const tb = textOf(b)
+      if (!ta || !tb || ta === tb) continue
+      if (!(ta.includes(tb) || tb.includes(ta))) continue
+      if (!sameRow(a, b, 6)) continue
+      const ra = rect(a); const rb = rect(b)
+      if (Math.abs((ra.height || 0) - (rb.height || 0)) > 4) continue
+      const ox = Math.min((ra.x || 0) + (ra.width || 0), (rb.x || 0) + (rb.width || 0)) - Math.max(ra.x || 0, rb.x || 0)
+      const oy = Math.min((ra.y || 0) + (ra.height || 0), (rb.y || 0) + (rb.height || 0)) - Math.max(ra.y || 0, rb.y || 0)
+      if (ox <= 0 || oy <= 0) continue
+      const shorter = ta.length <= tb.length ? a : b
+      const shorterArea = (rect(shorter).width || 0) * (rect(shorter).height || 0)
+      if ((ox * oy) / Math.max(1, shorterArea) >= 0.5) containedFrag.add(shorter)
+    }
+  }
+  const _preStitch = containedFrag.size ? _preMerged.filter((e) => !containedFrag.has(e)) : _preMerged
+  // 同行数字碎片拼接：标注偶发把同一金额拆成连续碎片（"3,821"+"."+"50"），
+  // 同基线(±2)、同学号、x 间隙 ≤3、拼接结果为纯数字/货币/标点 → 合成一个虚拟文本元素。
+  // 碎片不拼接则各自渲染/绑定（"50" 曾被当成独立主金额）。
+  const stitchedOut = []
+  const stitchConsumed = new Set()
+  {
+    const fragRe = /^[\d.,，%％\p{Sc}\-]$/u
+    const numericish = /^[\p{Sc}\-]?[\d.,，%％]+$/u
+    const byLine = new Map()
+    for (const t of _preStitch) {
+      const key = Math.round((rect(t).y || 0) / 2) + ':' + (ts(t).fontSize || 0)
+      if (!byLine.has(key)) byLine.set(key, [])
+      byLine.get(key).push(t)
+    }
+    for (const [, line] of byLine) {
+      const sortedLine = line.sort((a, b) => (rect(a).x || 0) - (rect(b).x || 0))
+      let chain = []
+      const flushChain = () => {
+        if (chain.length >= 2) {
+          const joined = chain.map((c) => textOf(c)).join('')
+          if (numericish.test(joined) && /\d/.test(joined) && chain.some((c) => fragRe.test(textOf(c)))) {
+            const first = chain[0]
+            const last = chain[chain.length - 1]
+            const rx = Math.min(...chain.map((c) => rect(c).x || 0))
+            const ry = Math.min(...chain.map((c) => rect(c).y || 0))
+            const rr = Math.max(...chain.map((c) => (rect(c).x || 0) + (rect(c).width || 0)))
+            const rb = Math.max(...chain.map((c) => (rect(c).y || 0) + (rect(c).height || 0)))
+            stitchedOut.push({
+              ...first,
+              text: joined,
+              rect: { x: rx, y: ry, width: rr - rx, height: rb - ry },
+              _stitched: true,
+            })
+            chain.forEach((c) => stitchConsumed.add(c))
+          }
+        }
+        chain = []
+      }
+      for (const t of sortedLine) {
+        if (!chain.length) { chain.push(t); continue }
+        const prev = chain[chain.length - 1]
+        const gap = (rect(t).x || 0) - ((rect(prev).x || 0) + (rect(prev).width || 0))
+        if (gap >= -1 && gap <= 3) chain.push(t)
+        else { flushChain(); chain.push(t) }
+      }
+      flushChain()
+    }
+  }
+  const dedupedTexts = stitchConsumed.size
+    ? [..._preStitch.filter((e) => !stitchConsumed.has(e)), ...stitchedOut]
+    : _preStitch
+  // —— 富文本段落：大容器文本层被 ≥2 个碎片层逐行铺满（碎片拼接 ≈ 容器文本）——
+  // 容器与碎片同文同源，并存会重复渲染（曾出现"截止至"被渲染 4 次）。
+  // 保留碎片（位置/字重精确，粗体金额片段得以还原），整体移除容器与碎片出通用 text 流。
+  const richBlocks = (() => {
+    const inside = (big, small) => {
+      const b = rect(big), s = rect(small)
+      return (s.x || 0) >= (b.x || 0) - 2 && (s.y || 0) >= (b.y || 0) - 2
+        && ((s.x || 0) + (s.width || 0)) <= (b.x || 0) + (b.width || 0) + 2
+        && ((s.y || 0) + (s.height || 0)) <= (b.y || 0) + (b.height || 0) + 2
+    }
+    const blocks = []
+    for (const big of dedupedTexts) {
+      const br = rect(big)
+      if ((br.height || 0) < (ts(big).fontSize || 14) * 2.2) continue
+      const bigText = textOf(big)
+      const inner = dedupedTexts.filter((t) => {
+        if (t === big || !inside(big, t)) return false
+        // 微型文本（≤2 字符）若并非容器文案的子串，是压在段落区域上的独立元素
+        // （如序号徽章数字），不是富文本碎片——排除以免被段落吞掉
+        const fragText = (textOf(t) || '').trim()
+        if (fragText.length > 0 && fragText.length <= 2 && bigText && !bigText.includes(fragText)) return false
+        return true
+      })
+      if (inner.length < 2) continue
+      // 至少两行铺开
+      const lineYs = new Set(inner.map((t) => Math.round((rect(t).y || 0) / 8)))
+      if (lineYs.size < 2) continue
+      // 碎片拼接文本与容器文本的字符集重合度 ≥80%
+      const bigChars = new Set([...textOf(big)])
+      const innerText = inner.map((t) => textOf(t)).join('')
+      const cover = [...innerText].filter((ch) => bigChars.has(ch)).length / Math.max(1, innerText.length)
+      if (cover < 0.8) continue
+      // 按行分组（同 y ±4）
+      const lineMap = new Map()
+      for (const frag of inner) {
+        const key = Math.round((rect(frag).y || 0) / 4)
+        if (!lineMap.has(key)) lineMap.set(key, [])
+        lineMap.get(key).push(frag)
+      }
+      const lines = [...lineMap.entries()]
+        .sort((a, b) => a[0] - b[0])
+        .map(([, frags]) => frags.sort((a, b) => (rect(a).x || 0) - (rect(b).x || 0)))
+      blocks.push({ container: big, fragments: inner, lines, y: br.y || 0, x: br.x || 0 })
+    }
+    return blocks
+  })()
+  const richAll = new Set(richBlocks.flatMap((b) => [b.container, ...b.fragments]))
+  const texts = richAll.size ? dedupedTexts.filter((e) => !richAll.has(e)) : dedupedTexts
+  const shapes = content.filter((e) => e.type === 'shape')
+  const slices = content.filter((e) => e.type === 'slice')
+  // 纯矢量 logo 组（shapes 组、无切图导出）：上游已按 rect 画板裁切（annotationDefect.cropSlice），
+  // 凭 cropSlice 提权进切片池，让行图标/值内前置图标/行尾 affordance 等消费通道认领；
+  // 不提权则这些媒体被静默丢弃（付款卡黄色行标曾整批缺失）。
+  for (const groupEl of content) {
+    if (groupEl.type === 'group' && groupEl.annotationDefect && groupEl.annotationDefect.cropSlice) {
+      slices.push(groupEl)
+    }
+  }
+  const symbols = content.filter((e) => e.type === 'symbol')
+  // 标注重复媒体去重：同一图标可能同时以 symbol 与 slice 形态出现（rect 几乎重合），
+  // 二者都会被各自消费通道认领一份，未消费的副本会渲染成孤立行——保留 symbol 移除 slice 副本。
+  {
+    const sameRect = (a, b) => Math.abs((rect(a).x || 0) - (rect(b).x || 0)) <= 1
+      && Math.abs((rect(a).y || 0) - (rect(b).y || 0)) <= 1
+      && Math.abs((rect(a).width || 0) - (rect(b).width || 0)) <= 1
+      && Math.abs((rect(a).height || 0) - (rect(b).height || 0)) <= 1
+    for (let i = slices.length - 1; i >= 0; i -= 1) {
+      if (symbols.some((sy) => sameRect(slices[i], sy))) slices.splice(i, 1)
+    }
+  }
+
+  // —— Tab 切换头：顶部 2-3 个并列短文本 ——
+  const tabs = []
+  if (texts.length >= 2) {
+    const top = texts[0]
+    const sameLine = texts.filter((t) => sameRow(t, top) && t !== top)
+    if (sameLine.length >= 1 && sameLine.length <= 3) {
+      const group = [top, ...sameLine].sort((a, b) => (rect(a).x || 0) - (rect(b).x || 0))
+      const allShort = group.every((t) => textOf(t).length <= 5)
+      const spread = (rect(group[group.length - 1]).x || 0) - (rect(group[0]).x || 0)
+      if (allShort && spread >= 100) {
+        group.forEach((t, i) => {
+          const T = ts(t)
+          tabs.push({
+            value: textOf(t),
+            color: T.color || '#111111',
+            fontSize: T.fontSize || 16,
+            fontWeight: T.fontWeight || '500',
+            height: rect(t).height || 0,
+            x: rect(t).x || 0,
+            width: rect(t).width || 0,
+            y: rect(t).y || 0,
+          })
+        })
+      }
+    }
+  }
+  const tabY = tabs.length ? rect(texts.find((t) => textOf(t) === tabs[0].value) || texts[0]).y || 0 : 0
+
+  // —— 选项组：同高、近似同宽、横向等距、含居中文本的短壳。 ——
+  // 只依赖几何重复性，不识别选项文案；≥2 个才成组，避免把独立主按钮误判为选项。
+  const optionGroups = (() => {
+    const chipCandidates = shapes.filter((shape) => {
+      const r = rect(shape)
+      const width = r.width || 0
+      const height = r.height || 0
+      if (width < 56 || width > 180 || height < 26 || height > 60) return false
+      const radius = shape.style?.radius?.borderRadius || 0
+      const hasVisualShell = !!shape.style?.fill?.color || !!shape.style?.border || radius >= 4
+      const hasCenterText = texts.some((text) => {
+        const tr = rect(text)
+        return true
+          && (tr.x || 0) >= (r.x || 0) - 4 && (tr.x || 0) + (tr.width || 0) <= (r.x || 0) + width + 4
+          && (tr.y || 0) >= (r.y || 0) - 4 && (tr.y || 0) + (tr.height || 0) <= (r.y || 0) + height + 4
+      })
+      return hasVisualShell && hasCenterText
+    }).sort((a, b) => (rect(a).y || 0) - (rect(b).y || 0) || (rect(a).x || 0) - (rect(b).x || 0))
+
+    const rows = []
+    for (const shape of chipCandidates) {
+      const current = rect(shape)
+      const row = rows.find((items) => {
+        const first = rect(items[0])
+        return Math.abs((current.y || 0) - (first.y || 0)) <= 4
+          && Math.abs((current.height || 0) - (first.height || 0)) <= Math.max(4, (first.height || 0) * 0.2)
+      })
+      if (row) row.push(shape)
+      else rows.push([shape])
+    }
+
+    const groups = []
+    for (const row of rows) {
+      row.sort((a, b) => (rect(a).x || 0) - (rect(b).x || 0))
+      let segment = []
+      const flush = () => {
+        if (segment.length < 2) { segment = []; return }
+        const rects = segment.map((shape) => rect(shape))
+        const widths = rects.map((item) => item.width || 0)
+        const gaps = []
+        for (let index = 1; index < segment.length; index += 1) {
+          gaps.push((rects[index].x || 0) - ((rects[index - 1].x || 0) + (rects[index - 1].width || 0)))
+        }
+        const regularGaps = gaps.length && Math.max(...gaps) - Math.min(...gaps) <= Math.max(...gaps) * 0.5
+        const similarWidths = Math.max(...widths) - Math.min(...widths) <= Math.max(...widths) * 0.3
+        const solidPair = segment.length === 2 && segment.every((shape) =>
+          !!shape.style?.fill?.color && !shape.style?.fill?.gradient)
+        if (!regularGaps || !similarWidths || (segment.length === 2 && !solidPair)) { segment = []; return }
+        const left = Math.min(...rects.map((item) => item.x || 0))
+        const top = Math.min(...rects.map((item) => item.y || 0))
+        const right = Math.max(...rects.map((item) => (item.x || 0) + (item.width || 0)))
+        const bottom = Math.max(...rects.map((item) => (item.y || 0) + (item.height || 0)))
+        const members = segment.map((shape) => {
+          const sr = rect(shape)
+          const inner = texts.find((text) => {
+            const tr = rect(text)
+            return (tr.x || 0) >= (sr.x || 0) - 4 && (tr.x || 0) + (tr.width || 0) <= (sr.x || 0) + (sr.width || 0) + 4
+              && (tr.y || 0) >= (sr.y || 0) - 4 && (tr.y || 0) + (tr.height || 0) <= (sr.y || 0) + (sr.height || 0) + 4
+          })
+         const style = ts(inner)
+          return {
+           text: textOf(inner),
+            color: style.color || '#111111',
+            fontSize: style.fontSize || 14,
+            fontWeight: style.fontWeight || '400',
+            fillColor: shape.style?.fill?.color || null,
+            gradient: shape.style?.fill?.gradient || null,
+            radius: shape.style?.radius?.borderRadius || 6,
+            width: sr.width || 0,
+            height: sr.height || 0,
+            x: sr.x || 0,
+            y: sr.y || 0,
+            sourceShapeEl: shape,
+            sourceTextEl: inner,
+          }
+        })
+        const memberTexts = new Set(members.map((member) => member.sourceTextEl).filter(Boolean))
+        const labelCands = texts.filter((text) => {
+          const tr = rect(text)
+          const bottom = (tr.y || 0) + (tr.height || 0)
+          return !memberTexts.has(text) && bottom <= top && top - bottom <= 48
+            && (tr.x || 0) >= left - 24 && (tr.x || 0) <= left + 24
+            && (ts(text).fontSize || 0) >= 14
+        }).sort((a, b) => (rect(b).y || 0) - (rect(a).y || 0))
+        let labelEl = labelCands[0] || null
+        let _sideLabel = false
+        if (!labelEl) {
+          // Side label: text at same y (vertically overlapping), to the LEFT of the group
+          const _grpCY = top + (bottom - top) / 2
+          const _sideCands = texts.filter((text) => {
+            const tr = rect(text)
+            const tcY = (tr.y || 0) + (tr.height || 0) / 2
+            return !memberTexts.has(text)
+              && Math.abs(tcY - _grpCY) <= Math.max(15, (bottom - top) * 0.6)
+              && (tr.x || 0) + (tr.width || 0) <= left + 4
+              && (ts(text).fontSize || 0) >= 13
+          }).sort((a, b) => (rect(a).x || 0) - (rect(b).x || 0))
+          if (_sideCands[0]) { labelEl = _sideCands[0]; _sideLabel = true }
+        }
+        const labelStyle = labelEl ? ts(labelEl) : null
+        groups.push({
+          x: left,
+          y: top,
+          labelY: labelEl ? rect(labelEl).y || 0 : top,
+          width: right - left,
+          height: bottom - top,
+          label: labelEl ? {
+            text: textOf(labelEl),
+            color: labelStyle.color || '#111111',
+            fontSize: labelStyle.fontSize || 16,
+            fontWeight: labelStyle.fontWeight || '500',
+            height: rect(labelEl).height || (labelStyle.fontSize || 16) * 1.4,
+            x: rect(labelEl).x || 0,
+            y: rect(labelEl).y || 0,
+            width: rect(labelEl).width || 0,
+          } : null,
+          members,
+          sourceLabelEl: labelEl, sideLabel: _sideLabel,
+          sourceTextEls: members.map((m) => m.sourceTextEl).filter(Boolean),
+        })
+        segment = []
+      }
+      for (const shape of row) {
+        if (!segment.length) { segment.push(shape); continue }
+        const previous = rect(segment[segment.length - 1])
+        const current = rect(shape)
+        const gap = (current.x || 0) - ((previous.x || 0) + (previous.width || 0))
+        if (gap < 4 || gap > 48 || Math.abs((current.width || 0) - (previous.width || 0)) > Math.max(previous.width || 0) * 0.3) {
+          flush()
+        }
+        segment.push(shape)
+      }
+      flush()
+    }
+    // —— 竖排选项组（整行 pill 纵向等距堆叠，如身份/金额维度选择列表）——
+    // 横向 chip 判定 width≤180 会漏掉整行选项（宽 311 > 180），导致选项被误吞为按钮/列表标题。
+    const cardW0 = rect(card).width || (spec.size && spec.size.width) || 375
+    const memberOf = (shape) => {
+      const sr = rect(shape)
+      const inner = texts.find((text) => {
+        const tr = rect(text)
+        return (tr.x || 0) >= (sr.x || 0) - 4 && (tr.x || 0) + (tr.width || 0) <= (sr.x || 0) + (sr.width || 0) + 4
+          && (tr.y || 0) >= (sr.y || 0) - 4 && (tr.y || 0) + (tr.height || 0) <= (sr.y || 0) + (sr.height || 0) + 4
+      })
+      if (!inner) return null
+      const style = ts(inner)
+      return {
+        text: textOf(inner),
+        color: style.color || '#111111',
+        fontSize: style.fontSize || 14,
+        fontWeight: style.fontWeight || '400',
+        fillColor: shape.style?.fill?.color || null,
+        gradient: shape.style?.fill?.gradient || null,
+        radius: shape.style?.radius?.borderRadius || 6,
+        width: sr.width || 0,
+        height: sr.height || 0,
+        x: sr.x || 0,
+        y: sr.y || 0,
+        textInset: Math.max(0, Math.round((rect(inner).x || 0) - (sr.x || 0))),
+        sourceTextEl: inner,
+        sourceShapeEl: shape,
+      }
+    }
+    const cardFillUpper = String(card.cardFill || '#FFFFFF').toUpperCase()
+    const vCands = shapes.filter((shape) => {
+      const r = rect(shape)
+      const w = r.width || 0, h = r.height || 0
+      if (w < cardW0 * 0.5 || h < 26 || h > 64) return false
+      const radius = shape.style?.radius?.borderRadius || 0
+      // 选项 pill 必须可见（填充色 ≠ 卡底色）——同底色的整行壳是表单行/内容行（如地址表单行），
+      // 且表单行壳内含 label+value 两个文本，选项 pill 只含一个文本。两个信号缺一不可。
+      const fillColor = String(shape.style?.fill?.color || '').toUpperCase()
+      if (!fillColor || fillColor === cardFillUpper) return false
+      if (!shape.style?.fill?.color && !shape.style?.border && radius < 4) return false
+      const insideTexts = texts.filter((text) => {
+        const tr = rect(text)
+        return (tr.x || 0) >= (r.x || 0) - 4 && (tr.x || 0) + (tr.width || 0) <= (r.x || 0) + w + 4
+          && (tr.y || 0) >= (r.y || 0) - 4 && (tr.y || 0) + (tr.height || 0) <= (r.y || 0) + h + 4
+      })
+      return insideTexts.length === 1
+    }).sort((a, b) => (rect(a).y || 0) - (rect(b).y || 0))
+    let vSeg = []
+    const vFlush = () => {
+      if (vSeg.length < 2) { vSeg = []; return }
+      const gaps = []
+      for (let i = 1; i < vSeg.length; i++) {
+        gaps.push((rect(vSeg[i]).y || 0) - ((rect(vSeg[i - 1]).y || 0) + (rect(vSeg[i - 1]).height || 0)))
+      }
+      const uniform = gaps.length && gaps.every((g) => Math.abs(g - gaps[0]) <= Math.max(4, Math.abs(gaps[0]) * 0.5))
+      if (!uniform) { vSeg = []; return }
+      const members = vSeg.map(memberOf).filter(Boolean)
+      if (members.length < 2) { vSeg = []; return }
+      const left = Math.min(...vSeg.map((s) => rect(s).x || 0))
+      const top = Math.min(...vSeg.map((s) => rect(s).y || 0))
+      const right = Math.max(...vSeg.map((s) => (rect(s).x || 0) + (rect(s).width || 0)))
+      const bottom = Math.max(...vSeg.map((s) => (rect(s).y || 0) + (rect(s).height || 0)))
+      const labelCands = texts.filter((text) => {
+        const tr = rect(text)
+        const bottom = (tr.y || 0) + (tr.height || 0)
+        return !members.some((m) => m.sourceTextEl === text) && bottom <= top && top - bottom <= 48
+          && (tr.x || 0) >= left - 24 && (tr.x || 0) <= left + 24
+          && (ts(text).fontSize || 0) >= 14
+      }).sort((a, b) => (rect(b).y || 0) - (rect(a).y || 0))
+      const labelEl = labelCands[0] || null
+      const labelStyle = labelEl ? ts(labelEl) : null
+      groups.push({
+        x: left, y: top,
+        labelY: labelEl ? rect(labelEl).y || 0 : top,
+        width: right - left,
+        height: bottom - top,
+        label: labelEl ? {
+          text: textOf(labelEl),
+          color: labelStyle.color || '#111111',
+          fontSize: labelStyle.fontSize || 16,
+          fontWeight: labelStyle.fontWeight || '500',
+          height: rect(labelEl).height || (labelStyle.fontSize || 16) * 1.4,
+        } : null,
+        members,
+        memberGap: Math.round(gaps[0] || 8),
+        vertical: true,
+        sourceLabelEl: labelEl,
+        sourceTextEls: members.map((m) => m.sourceTextEl),
+      })
+      vSeg = []
+    }
+    for (const shape of vCands) {
+      if (!vSeg.length) { vSeg.push(shape); continue }
+      const prev = rect(vSeg[vSeg.length - 1])
+      const curr = rect(shape)
+      const sameCol = Math.abs((curr.x || 0) - (prev.x || 0)) <= 4
+        && Math.abs((curr.width || 0) - (prev.width || 0)) <= Math.max(4, (prev.width || 0) * 0.05)
+        && Math.abs((curr.height || 0) - (prev.height || 0)) <= Math.max(4, (prev.height || 0) * 0.2)
+      if (!sameCol) vFlush()
+      vSeg.push(shape)
+    }
+    vFlush()
+    return groups.sort((a, b) => a.y - b.y)
+  })()
+  // 成员已携带源 shape 引用，直接汇集——几何重匹配对竖排组必然失配
+  // （成员 y 各不相同，按组顶 y±2 匹配为 0 → 选项壳漏判 → 选项被重复渲染）。
+  const optionShapeSet = new Set(optionGroups.flatMap((group) =>
+    group.members.map((m) => m.sourceShapeEl).filter(Boolean)))
+  const optionTextSet = new Set(optionGroups.flatMap((group) => group.sourceTextEls || []))
+  const optionLabelSet = new Set(optionGroups.map((group) => group.sourceLabelEl).filter(Boolean))
+  if (optionGroups.length) {
+    for (const group of optionGroups) delete group.sourceTextEls
+  }
+
+  // —— 按钮：宽 80-220 高 30-70 的圆角 shape + 内嵌居中文本；小 pill（行内操作件）放宽到 40-80×20-36 ——
+  const _cardRForPill = rect(card)
+  const _pillRingCache = new Map()
+  const _pillRingColor = (sr) => {
+    const key = `${sr.x}:${sr.y}:${sr.width}:${sr.height}`
+    if (_pillRingCache.has(key)) return _pillRingCache.get(key)
+    const color = _designImage
+      ? sampleOutlineRing(_designImage, Math.round(_cardRForPill.width || 375), {
+        x: (sr.x || 0) - (_cardRForPill.x || 0),
+        y: (sr.y || 0) - (_cardRForPill.y || 0),
+        width: sr.width || 0,
+        height: sr.height || 0,
+      })
+      : null
+    _pillRingCache.set(key, color)
+    return color
+  }
+  const buttons = []
+  const tabYs = tabs.map((t) => rect(texts.find((e) => textOf(e) === t.value) || { y: -1 }).y || -1)
+  const buttonShapes = shapes.filter((s) => {
+    const sr = rect(s)
+    const w = sr.width || 0, h = sr.height || 0
+    const _radius = radiusMax(s.style)
+    // 小 pill（行内操作件，如 修改/重发）：宽 40-80 高 20-36——主按钮尺寸带（w>=80）会漏判。
+    const smallPill = w >= 40 && w < 80 && h >= 20 && h <= 36
+    if (!(w >= 80 && w <= 360 && h >= 30 && h <= 80) && !smallPill) return false
+    const f = (s.style || {}).fill || {}
+    const fillUpper = String(f.color || '').toUpperCase().trim()
+    const hasFillEvidence = f.gradient
+      || (f.color && !['#FFFFFF','#F8F8F8','#FAFAFA','#F0F0F0','#EFF0F6'].includes(fillUpper))
+    const hasBorderEvidence = !!(s.style?.border?.isBorder)
+    const ok = hasFillEvidence
+      || hasBorderEvidence
+      || (_radius >= 10 && h >= 30 && w >= 80)
+      // 无填充/无描边标注的小 pill：以图像环采样为证据（视觉优先），无图则保守放过
+      || (smallPill && _radius >= 8 && _pillRingColor(sr) != null)
+    if (!ok) return false
+    if (tabYs.some((y) => Math.abs((sr.y || 0) - y) < 30)) return false
+    const innerTexts = texts.filter((t) => {
+      const tr = rect(t)
+      return (tr.x || 0) >= (sr.x || 0) && (tr.y || 0) >= (sr.y || 0)
+        && ((tr.x || 0) + (tr.width || 0)) <= ((sr.x || 0) + w)
+        && ((tr.y || 0) + (tr.height || 0)) <= ((sr.y || 0) + h)
+    })
+    const textRowCount = new Set(innerTexts.map((t) => Math.round((rect(t).y || 0) / 18))).size
+    if (textRowCount > 1) return false
+    return !optionShapeSet.has(s)
+  })
+  for (const s of buttonShapes) {
+    const sr = rect(s)
+    const inner = texts.filter((t) => {
+      const tr = rect(t)
+      const T = ts(t)
+      // 文本框几何居中即可：设计工具的 textAlign 描述的是文本层内部对齐（常为 right），
+      // 不代表按钮文案未居中（曾有"确定"按钮因此漏识别，黄底全丢）。
+      const geoCentered = Math.abs(((tr.x || 0) + (tr.width || 0) / 2) - ((sr.x || 0) + (sr.width || 0) / 2)) <= Math.max(8, (sr.width || 0) * 0.08)
+      return (T.textAlign === 'center' || geoCentered)
+        && (tr.x || 0) >= (sr.x || 0) - 4 && (tr.x || 0) + (tr.width || 0) <= (sr.x || 0) + (sr.width || 0) + 4
+        && (tr.y || 0) >= (sr.y || 0) - 4 && (tr.y || 0) + (tr.height || 0) <= (sr.y || 0) + (sr.height || 0) + 4
+    })
+    if (!inner.length) continue
+    const t = inner[0]
+    const T = ts(t)
+    const fill = (s.style || {}).fill || {}
+    const r = (s.style || {}).radius || {}
+    buttons.push({
+      text: textOf(t),
+      color: T.color || '#FFFFFF',
+      fontSize: T.fontSize || 17,
+      fontWeight: T.fontWeight || '500',
+      fillColor: fill.color || null,
+      gradient: fill.gradient || null,
+      opacity: s.style?.opacity ?? 1,
+      radius: radiusMax(s.style),
+      borderColor: (s.style?.border?.isBorder && s.style?.border?.borderColor)
+        ? s.style.border.borderColor
+        : ((!fill.color && !fill.gradient) ? _pillRingColor(sr) : null),
+    })
+  }
+  buttons.sort((a, b) => 0) // 保持 spec 顺序（已在 buttonShapes 里）
+  // 按 x 坐标排序，左侧在前
+  const buttonShapeSorted = buttonShapes.sort((a, b) => (rect(a).x || 0) - (rect(b).x || 0))
+  buttons.length = 0
+  for (const s of buttonShapeSorted) {
+    const sr = rect(s)
+    const inner = texts.find((t) => {
+      const tr = rect(t)
+      const T = ts(t)
+      const geoCentered = Math.abs(((tr.x || 0) + (tr.width || 0) / 2) - ((sr.x || 0) + (sr.width || 0) / 2)) <= Math.max(8, (sr.width || 0) * 0.08)
+      return (T.textAlign === 'center' || geoCentered)
+        && (tr.x || 0) >= (sr.x || 0) - 4 && (tr.x || 0) + (tr.width || 0) <= (sr.x || 0) + (sr.width || 0) + 4
+        && (tr.y || 0) >= (sr.y || 0) - 4 && (tr.y || 0) + (tr.height || 0) <= (sr.y || 0) + (sr.height || 0) + 4
+    })
+    if (!inner) continue
+    const T = ts(inner)
+    const fill = (s.style || {}).fill || {}
+    const r = (s.style || {}).radius || {}
+    buttons.push({
+      text: textOf(inner),
+      color: T.color || '#FFFFFF',
+      fontSize: T.fontSize || 17,
+      fontWeight: T.fontWeight || '500',
+      align: 'center', // 按钮文案几何居中才通过检测；textAlign 是文本层内部对齐（常为 right），不能用于按钮对齐
+      fillColor: fill.color || null,
+      gradient: fill.gradient || null,
+      opacity: s.style?.opacity ?? 1,
+      radius: radiusMax(s.style),
+      borderColor: (s.style?.border?.isBorder && s.style?.border?.borderColor)
+        ? s.style.border.borderColor
+        : ((!fill.color && !fill.gradient) ? _pillRingColor(sr) : null),
+      sourceEl: inner,
+      height: sr.height || 46,
+      width: sr.width || 0,
+      x: sr.x || 0,
+      y: sr.y || 0, // 按钮几何（footer 文案第一项上方留白推导用）
+    })
+  }
+
+  // 空间散布的图表顶点标签（如雷达图五边形周围的类别 pill）：
+  // 动作按钮必然横向成排（y-span ≤ 30px），若 ≥3 个候选按钮的 y 跨度 > 40px
+  // 且分布在 ≥3 个 y 带，判为空间散布的图表顶点标签而非按钮排。
+  // 检出后：收集这些 pill + 其周围的文本/形状为一个 vertexRegion（AbsoluteLayout 整块渲染），
+  // 从 buttons / auxTexts / postAmountTexts / isolatedBlocks 等路径排除以防重影。
+  let vertexClusters = null
+  const _vertexConsumedEls = new Set()
+  if (buttons.length >= 3) {
+    const ys = buttons.map((b) => b.y || 0)
+    const xs = buttons.map((b) => b.x || 0)
+    const ySpan = Math.max(...ys) - Math.min(...ys)
+    const xSpan = Math.max(...xs) - Math.min(...xs)
+    if (ySpan > 40 && xSpan > 80) {
+      const yBands = new Set(ys.map((y) => Math.floor(y / 20)))
+      if (yBands.size >= 3) {
+        vertexClusters = buttons.map((btn, bi) => {
+          const bx = btn.x || 0, by = btn.y || 0
+          const bw = btn.width || 0, bh = btn.height || 0
+          const pillShape = buttonShapeSorted[bi]
+          if (pillShape) _vertexConsumedEls.add(pillShape)
+          if (btn.sourceEl) _vertexConsumedEls.add(btn.sourceEl)
+          const clusterEls = content.filter((e) => {
+            if (e === btn.sourceEl || (pillShape && e === pillShape)) return false
+            if (_vertexConsumedEls.has(e)) return false
+            const r = rect(e)
+            const ex = (r.x || 0) + (r.width || 0) / 2
+            const ey = (r.y || 0) + (r.height || 0) / 2
+            return ex >= bx - 15 && ex <= bx + bw + 15
+              && ey >= by - 8 && ey <= by + bh + 35
+          })
+          clusterEls.forEach((e) => _vertexConsumedEls.add(e))
+          return {
+            pill: {
+              text: btn.text, color: btn.color, fontSize: btn.fontSize,
+              fontWeight: btn.fontWeight || '400',
+              fillColor: btn.fillColor, radius: btn.radius,
+              shape: pillShape, sourceEl: btn.sourceEl,
+            },
+            texts: clusterEls.filter((e) => textOf(e)),
+            shapes: clusterEls.filter((e) => !textOf(e)),
+            x: bx, y: by, width: bw, height: bh,
+          }
+        })
+        buttons.length = 0
+        for (let ti = texts.length - 1; ti >= 0; ti--)
+          if (_vertexConsumedEls.has(texts[ti])) texts.splice(ti, 1)
+        for (let si = shapes.length - 1; si >= 0; si--)
+          if (_vertexConsumedEls.has(shapes[si])) shapes.splice(si, 1)
+        for (let ci2 = content.length - 1; ci2 >= 0; ci2--)
+          if (_vertexConsumedEls.has(content[ci2])) content.splice(ci2, 1)
+        for (let bs2 = buttonShapes.length - 1; bs2 >= 0; bs2--)
+          if (_vertexConsumedEls.has(buttonShapes[bs2])) buttonShapes.splice(bs2, 1)
+      }
+        for (let si3 = slices.length - 1; si3 >= 0; si3--)
+          if (_vertexConsumedEls.has(slices[si3])) slices.splice(si3, 1)
+    }
+  }
+  // 重复面板组（同尺寸壳纵向等距重复、壳内结构同构）→ 面板列表 ——
+  // 纯几何识别，无任何业务词：
+  //   ① ≥2 个同尺寸(±4px)带填充/渐变的壳（非按钮、非全卡背景）
+  //   ② 纵向 pitch 一致(±8px)
+  //   ③ 每壳成员文本数一致且字号多重集一致（结构同构：同产品不同内容）
+  //   ④ 壳内无切片（含切片的壳结构复杂，回退既有逐语义路径）
+  // 命中后：壳成员文本/按钮从主金额/表单行/列表/辅助文案等所有单例语义路径排除，
+  // 由 panelGroup 整体接管渲染（否则同一面板内容被多条路径重复渲染）。
+  const _panelGroupShells = []
+  const _panelGroupMemberEls = new Set()
+  const _panelGroupButtonShapeEls = new Set()
+  const _panelGroupShellSet = new Set()
+  let panelGroup = null
+  {
+    const cardR = rect(card)
+    const centerIn = (el, sr) => {
+      const er = rect(el)
+      const cx = (er.x || 0) + (er.width || 0) / 2
+      const cy = (er.y || 0) + (er.height || 0) / 2
+      return cx >= (sr.x || 0) && cx <= (sr.x || 0) + (sr.width || 0)
+        && cy >= (sr.y || 0) && cy <= (sr.y || 0) + (sr.height || 0)
+    }
+    const shellCands = shapes.filter((sh) => {
+      const sr = rect(sh)
+      const w = sr.width || 0, h = sr.height || 0
+      if (!w || !h) return false
+      if (w < (cardR.width || 375) * 0.6 || h < 60 || h > (cardR.height || 600) * 0.6) return false
+      if (buttonShapes.includes(sh)) return false
+      const f = (sh.style || {}).fill || {}
+      return !!(f.gradient || f.color)
+    }).sort((a, b) => (rect(a).y || 0) - (rect(b).y || 0))
+    const sizeGroups = []
+    for (const sh of shellCands) {
+      const sr = rect(sh)
+      const grp = sizeGroups.find((g) => Math.abs(g.w - (sr.width || 0)) <= 4 && Math.abs(g.h - (sr.height || 0)) <= 4)
+      if (grp) grp.items.push(sh)
+      else sizeGroups.push({ w: sr.width || 0, h: sr.height || 0, items: [sh] })
+    }
+    for (const grp of sizeGroups) {
+      if (grp.items.length < 2) continue
+      const sorted = grp.items
+      const pitch = (rect(sorted[1]).y || 0) - (rect(sorted[0]).y || 0)
+      if (pitch <= 0) continue
+      if (!sorted.every((sh, i) => i < 2
+        || Math.abs(((rect(sh).y || 0) - (rect(sorted[i - 1]).y || 0)) - pitch) <= 8)) continue
+      const memberTexts = sorted.map((sh) => texts.filter((t) => centerIn(t, rect(sh))))
+      if (memberTexts.some((mt) => mt.length < 3)) continue
+      const fsSig = (mt) => mt.map((t) => ts(t).fontSize || 0).sort((a, b) => b - a).join(',')
+      if (!memberTexts.every((mt) => fsSig(mt) === fsSig(memberTexts[0]))) continue
+      if (sorted.some((sh) => slices.some((sl) => centerIn(sl, rect(sh))))) continue
+      _panelGroupShells.push(...sorted)
+    }
+    if (_panelGroupShells.length >= 2) {
+      const panels = []
+      for (const sh of _panelGroupShells) {
+        const sr = rect(sh)
+        const btnShape = buttonShapes.find((b) => centerIn(b, sr)) || null
+        const btnEntry = btnShape
+          ? buttons.find((b) => Math.abs((b.x || 0) - (rect(btnShape).x || 0)) <= 2
+            && Math.abs((b.y || 0) - (rect(btnShape).y || 0)) <= 2)
+          : null
+        const members = texts.filter((t) => centerIn(t, sr)
+          && !(btnShape && centerIn(t, rect(btnShape))))
+        // 行聚类：垂直重叠 ≥50% 归同一行（大字号行会包裹小字号的基线同行单位，如金额+万元），
+        // 行内按 x 排序
+        const rows = []
+        for (const t of [...members].sort((a, b) =>
+          ((rect(a).y || 0) - (rect(b).y || 0)) || ((rect(a).x || 0) - (rect(b).x || 0)))) {
+          const tr = rect(t)
+          const tTop = tr.y || 0
+          const tBottom = tTop + (tr.height || (ts(t).fontSize || 14) * 1.4)
+          const row = rows.find((r) => {
+            const overlap = Math.min(r.bottom, tBottom) - Math.max(r.y, tTop)
+            return overlap >= Math.min(tBottom - tTop, r.bottom - r.y) * 0.5
+          })
+          if (row) { row.items.push(t); row.bottom = Math.max(row.bottom, tBottom) }
+          else rows.push({ y: tTop, bottom: tBottom, items: [t] })
+        }
+        rows.sort((a, b) => a.y - b.y)
+        if (rows.length < 2) continue
+        // 角色按几何层级分配：首行最大字号=标题，同行其余=副标题；
+        // 剩余行中字号最大者=金额，其同行小字号=单位；再下一行=说明。
+        const titleRow = rows[0]
+        const titleEl = [...titleRow.items].sort((a, b) => (ts(b).fontSize || 0) - (ts(a).fontSize || 0))[0]
+        const subtitleEls = titleRow.items.filter((t) => t !== titleEl)
+        const restRows = rows.slice(1)
+        let amountRow = null; let amountEl = null
+        for (const r of restRows) {
+          for (const t of r.items) {
+            if (!amountEl || (ts(t).fontSize || 0) > (ts(amountEl).fontSize || 0)) { amountEl = t; amountRow = r }
+          }
+        }
+        const unitEls = amountRow ? amountRow.items.filter((t) => t !== amountEl) : []
+        const captionRow = restRows.find((r) => r !== amountRow && amountRow && r.y > amountRow.y)
+          || restRows.find((r) => r !== amountRow) || null
+        // 行内并排双列检测（column-compare tile）：行内最大横向 gap ≥12 且 ≥2×次大 gap + 4
+        // → 该 gap 是列间缝（纯几何，不靠业务词）。左簇保持原角色（单位/说明），
+        // 右簇进 rightStack（逐行），否则右列文案被拼进 unit/caption（v6「%1万元起存」塌缩）。
+        const splitRowByColumnGap = (row) => {
+          if (!row || row.items.length < 2) return null
+          const sorted = [...row.items].sort((a, b) => (rect(a).x || 0) - (rect(b).x || 0))
+          const gaps = sorted.slice(1).map((t, i) =>
+            (rect(t).x || 0) - ((rect(sorted[i]).x || 0) + (rect(sorted[i]).width || 0)))
+          let best = -1
+          for (let i = 0; i < gaps.length; i += 1) {
+            const others = gaps.filter((_, j) => j !== i)
+            const second = others.length ? Math.max(...others) : 0
+            if (gaps[i] >= 12 && gaps[i] >= 2 * second + 4 && (best < 0 || gaps[i] > gaps[best])) best = i
+          }
+          if (best < 0) return null
+          return { left: sorted.slice(0, best + 1), right: sorted.slice(best + 1), gap: Math.round(gaps[best]) }
+        }
+        const amountSplit = splitRowByColumnGap(amountRow)
+        const captionSplit = splitRowByColumnGap(captionRow)
+        const unitElsFinal = amountSplit ? amountSplit.left.filter((t) => t !== amountEl) : unitEls
+        const captionItemsFinal = captionSplit ? captionSplit.left : (captionRow ? captionRow.items : [])
+        const rightStack = [amountSplit, captionSplit]
+          .filter(Boolean)
+          .map((split) => {
+            const head = split.right[0]
+            return {
+              text: split.right.map((t) => textOf(t)).join(' '),
+              color: ts(head).color, fontSize: ts(head).fontSize,
+              fontWeight: ts(head).fontWeight, height: rect(head).height || 0,
+            }
+          })
+        const columnGaps = [amountSplit, captionSplit].filter(Boolean).map((s) => s.gap)
+        const rightHeads = [amountSplit, captionSplit].filter(Boolean).map((s) => rect(s.right[0]).x || 0)
+        const padLeftV = Math.max(0, Math.round((rect(titleEl).x || 0) - (sr.x || 0)))
+        const f = (sh.style || {}).fill || {}
+        const titleRowH = Math.max(...titleRow.items.map((t) => rect(t).height || (ts(t).fontSize || 14) * 1.4))
+        const amountRowBottom = amountRow
+          ? amountRow.y + Math.max(...amountRow.items.map((t) => rect(t).height || (ts(t).fontSize || 14) * 1.4))
+          : titleRow.y + titleRowH
+        panels.push({
+          shellEl: sh,
+          x: sr.x || 0, y: sr.y || 0, width: sr.width || 0, height: sr.height || 0,
+          gradient: f.gradient || null, fill: f.color || null,
+          opacity: sh.style?.opacity ?? 1,
+          radius: (sh.style || {}).radius?.borderRadius || 0,
+          padTop: Math.max(0, Math.round(titleRow.y - (sr.y || 0))),
+          padLeft: padLeftV,
+          // 右列左沿相对内容左沿的实测偏移（列缝定位用，纯几何）
+          rightOffset: rightHeads.length
+            ? Math.max(0, Math.round(Math.min(...rightHeads) - ((sr.x || 0) + padLeftV))) : 0,
+          padRight: btnShape ? Math.max(0, Math.round(((sr.x || 0) + (sr.width || 0))
+            - ((rect(btnShape).x || 0) + (rect(btnShape).width || 0)))) : 0,
+          gapTitleAmount: amountRow ? Math.max(0, Math.round(amountRow.y - (titleRow.y + titleRowH))) : 0,
+          gapAmountCaption: captionRow ? Math.max(0, Math.round(captionRow.y - amountRowBottom)) : 0,
+          gapTitleSubtitle: subtitleEls.length
+            ? Math.max(0, Math.round((rect(subtitleEls[0]).x || 0)
+              - ((rect(titleEl).x || 0) + (rect(titleEl).width || 0)))) : 0,
+          gapAmountUnit: unitElsFinal.length
+            ? Math.max(0, Math.round((rect(unitElsFinal[0]).x || 0)
+              - ((rect(amountEl).x || 0) + (rect(amountEl).width || 0)))) : 0,
+          columnGap: columnGaps.length
+            ? columnGaps.slice().sort((a, b) => a - b)[Math.floor(columnGaps.length / 2)] : 0,
+          rightStack,
+          title: textOf(titleEl),
+          titleColor: ts(titleEl).color, titleFontSize: ts(titleEl).fontSize, titleFontWeight: ts(titleEl).fontWeight,
+          titleHeight: rect(titleEl).height || 0,
+          subtitle: subtitleEls.map((t) => textOf(t)).join(' '),
+          subtitleColor: subtitleEls[0] ? ts(subtitleEls[0]).color : undefined,
+          subtitleFontSize: subtitleEls[0] ? ts(subtitleEls[0]).fontSize : undefined,
+          subtitleHeight: subtitleEls[0] ? (rect(subtitleEls[0]).height || 0) : 0,
+          amount: amountEl ? textOf(amountEl) : '',
+          amountColor: amountEl ? ts(amountEl).color : undefined,
+          amountFontSize: amountEl ? ts(amountEl).fontSize : undefined,
+          amountFontWeight: amountEl ? ts(amountEl).fontWeight : undefined,
+          amountHeight: amountEl ? (rect(amountEl).height || 0) : 0,
+          unit: unitElsFinal.map((t) => textOf(t)).join(''),
+          unitColor: unitElsFinal[0] ? ts(unitElsFinal[0]).color : undefined,
+          unitFontSize: unitElsFinal[0] ? ts(unitElsFinal[0]).fontSize : undefined,
+          unitFontWeight: unitElsFinal[0] ? ts(unitElsFinal[0]).fontWeight : undefined,
+          unitHeight: unitElsFinal[0] ? (rect(unitElsFinal[0]).height || 0) : 0,
+          caption: captionItemsFinal.map((t) => textOf(t)).join(' '),
+          captionColor: captionItemsFinal[0] ? ts(captionItemsFinal[0]).color : undefined,
+          captionFontSize: captionItemsFinal[0] ? ts(captionItemsFinal[0]).fontSize : undefined,
+          captionHeight: captionItemsFinal.length
+            ? Math.max(...captionItemsFinal.map((t) => rect(t).height || 0)) : 0,
+          button: btnEntry ? {
+            text: btnEntry.text, color: btnEntry.color, fontSize: btnEntry.fontSize,
+            fontWeight: btnEntry.fontWeight, fillColor: btnEntry.fillColor,
+            gradient: btnEntry.gradient, radius: btnEntry.radius,
+            width: btnEntry.width, height: btnEntry.height,
+          } : null,
+        })
+        for (const t of members) _panelGroupMemberEls.add(t)
+        if (btnEntry && btnEntry.sourceEl) _panelGroupMemberEls.add(btnEntry.sourceEl)
+        if (btnShape) _panelGroupButtonShapeEls.add(btnShape)
+      }
+      if (panels.length >= 2) {
+        const pitch = panels[1].y - panels[0].y
+        panelGroup = { items: panels, gap: Math.max(0, Math.round(pitch - panels[0].height)), y: panels[0].y }
+        for (const sh of _panelGroupShells) _panelGroupShellSet.add(sh)
+        // 面板成员按钮从全局按钮列表移除（由面板项模板渲染）
+        for (let i = buttons.length - 1; i >= 0; i -= 1) {
+          if (buttons[i].sourceEl && _panelGroupMemberEls.has(buttons[i].sourceEl)) buttons.splice(i, 1)
+        }
+      } else {
+        _panelGroupMemberEls.clear()
+        _panelGroupButtonShapeEls.clear()
+        _panelGroupShells.length = 0
+      }
+    }
+  }
+
+  // —— 重复波段探测：同一 label 文案出现在 ≥2 个垂直分离的并列组（如多行账户各自的
+  // 「活期余额/可用余额」列对）→ 这是列表行的重复结构，不是一组副金额。
+  // 命中时：主金额/副金额不得捕获波段内文本（否则全部行的金额被揉进一个金额块）。
+  const isAmountish = (value) => /\p{Sc}|元|\.\d|\d{1,3}(,\d{3})+/u.test(value) ||
+    value.replace(/[,，\p{Sc}\s\-]/gu, '').length >= 3
+  const _bandSrc = texts.filter((t) => {
+    const T = ts(t)
+    return (T.fontSize || 0) >= 12 && (T.fontSize || 0) <= 16
+      && !tabs.some((tab) => tab.value === textOf(t))
+  })
+  const _bandYGroups = new Map()
+  for (const lab of _bandSrc) {
+    const ly = rect(lab).y || 0
+    let hitGroup = false
+    for (const [key, group] of _bandYGroups) {
+      if (Math.abs(ly - key) <= 12) { group.push(lab); hitGroup = true; break }
+    }
+    if (!hitGroup) _bandYGroups.set(ly, [lab])
+  }
+  const _bands = [..._bandYGroups.entries()].sort((a, b) => a[0] - b[0])
+    .map(([top, g]) => [top, g.filter((lab) => {
+      const lr = rect(lab)
+      return texts.some((v) => {
+        if (v === lab || !isAmountish(textOf(v))) return false
+        const vr = rect(v)
+        const vdy = (vr.y || 0) - (lr.y || 0)
+        return vdy >= 10 && vdy <= 50 && Math.abs((vr.x || 0) - (lr.x || 0)) <= 24
+      })
+    })])
+    .filter(([, g]) => g.length >= 2)
+  const _repeatLabelTexts = new Set()
+  for (let bi = 0; bi < _bands.length; bi += 1) {
+    for (let bj = bi + 1; bj < _bands.length; bj += 1) {
+      if (_bands[bj][0] - _bands[bi][0] <= 30) continue
+      for (const lab of _bands[bj][1]) {
+        if (_bands[bi][1].some((o) => textOf(o) === textOf(lab))) _repeatLabelTexts.add(textOf(lab))
+      }
+    }
+  }
+  const repeatRowMode = _repeatLabelTexts.size > 0
+  const _repeatBandTops = _bands
+    .filter(([, g]) => g.some((lab) => _repeatLabelTexts.has(textOf(lab))))
+    .map(([top]) => top)
+  // 全量波段（含少数派行：标签不重复但几何同构——≥2 标签且各有金额值在正下方）。
+  // 用途：复合行模式下守卫主金额/表单行/行标题候选不被少数派行成员污染。
+  const _allBands = _bands.filter(([, g]) => g.length >= 2)
+  const _allBandTops = _allBands.map(([top]) => top)
+  const _allBandLabelEls = new Set(_allBands.flatMap(([, g]) => g))
+
+  // 卡片内同文案计数：同一文本在卡内出现 ≥2 次，是「重复行/面板成员」的强信号，
+  // 不能作为主金额/表单行标签/列表标题（这些都是单例结构节点）。纯文本计数，不依赖业务词。
+  const _contentTextCounts = new Map()
+  for (const t of texts) {
+    const k = (textOf(t) || '').trim()
+    if (!k) continue
+    _contentTextCounts.set(k, (_contentTextCounts.get(k) || 0) + 1)
+  }
+  const _isRepeatedRowText = (t) => (_contentTextCounts.get((textOf(t) || '').trim()) || 0) >= 2
+
+  // —— 主金额：fontSize ≥ 24 的数值文本 ——
+  // 金额特征（¥/元/小数点/千分位）或去符号后 ≥3 位，排除倒计时/序号/角标等 1-2 位短数字被误判为金额（如状态卡倒计时 "2"）。
+  const sortedByFs = [...texts].sort((a, b) => (ts(b).fontSize || 0) - (ts(a).fontSize || 0))
+  let primaryAmountEl
+  sortedByFs.find((candidate) => {
+    if ((ts(candidate).fontSize || 0) < 24) return false
+    if (_panelGroupMemberEls.has(candidate)) return false // 面板成员：由面板列表模板渲染
+    // 复合行模式：落在标签波段（标签行+其下值行）内的大字号是行成员，不是全卡主金额。
+    // 注意：少数派行（标签文本不重复，如异类账户行）不构成"重复"波段，
+    // 但其几何结构（≥2 标签且各有金额值在正下方）与重复波段一致，同样应守卫。
+    if (repeatRowMode) {
+      const cy = rect(candidate).y || 0
+      if (_allBandTops.some((bt) => cy >= bt - 8 && cy <= bt + 70)) return false
+    }
+    const value = textOf(candidate)
+    // 重复出现的金额是行/面板成员（如产品面板列表每行同款金额），不是全卡唯一主视觉
+    // 但仅当候选位于某个「子壳」（小于卡片 98% 的填充 shape）内部时才算行成员——
+    // 壳外的顶部重复金额（总额与某面板数值巧合相同，如 ¥1,008.63 同现于头部与贷款面板）
+    // 仍是全卡主视觉，否则主金额会被错误降级到面板内部金额。
+    if (_isRepeatedRowText(candidate)) {
+      const cr = rect(candidate)
+      const ccx = (cr.x || 0) + (cr.width || 0) / 2
+      const ccy = (cr.y || 0) + (cr.height || 0) / 2
+      const cardW0 = rect(card).width || 375
+      const inSubShell = shapes.some((sh) => {
+        const sr = rect(sh)
+        if ((sr.width || 0) >= cardW0 * 0.98) return false // 卡片背景壳不算
+        const f = (sh.style || {}).fill || {}
+        if (!f.color && !f.gradient) return false
+        return ccx >= (sr.x || 0) && ccx <= (sr.x || 0) + (sr.width || 0)
+          && ccy >= (sr.y || 0) && ccy <= (sr.y || 0) + (sr.height || 0)
+      })
+      if (inSubShell) return false
+    }
+    if (isAmountish(value) && !/^\p{Sc}$/u.test(value)) {
+      primaryAmountEl = candidate
+      return true
+    }
+    const cr = rect(candidate)
+    const center = (cr.y || 0) + (cr.height || 0) / 2
+    const neighbour = texts.find((other) => {
+      if (other === candidate) return false
+      // 单位后缀（如"万元"/"元"/"%"）字号显著小于主数字（fs≥11 即可），
+      // 与货币符号同属排版单位字符，不涉及业务语义；倒计时"秒"等不在其列。
+      const ofs = ts(other).fontSize || 0
+      const isUnitSuffix = /^[\u4e00-\u9fa5%％]{1,4}$/.test(textOf(other))
+        && /[元万%％]/.test(textOf(other))
+        && ofs >= 11 && ofs < (ts(candidate).fontSize || 0)
+      if (ofs < 20 && !isUnitSuffix) return false
+      const or = rect(other)
+      const otherCenter = (or.y || 0) + (or.height || 0) / 2
+      const gap = (or.x || 0) > ((cr.x || 0) + (cr.width || 0))
+        ? (or.x || 0) - ((cr.x || 0) + (cr.width || 0))
+        : ((cr.x || 0) > ((or.x || 0) + (or.width || 0))
+          ? (cr.x || 0) - ((or.x || 0) + (or.width || 0))
+          : 0)
+      return Math.abs(center - otherCenter) <= 12 && gap <= 36
+        && isAmountish(textOf(other)) && !/^\p{Sc}$/u.test(textOf(other))
+    })
+    if (!neighbour) return false
+    const nr = rect(neighbour)
+    // 单位后缀邻居（小字号 元/万/% 等）：主金额只取数字本体，
+    // 单位由渲染期 unitText 路径以原始小字号单独渲染——合并成单文本会丢失字号差异。
+    const nIsUnitSuffix = /^[\u4e00-\u9fa5%％]{1,4}$/.test(textOf(neighbour))
+      && /[元万%％]/.test(textOf(neighbour))
+      && (ts(neighbour).fontSize || 0) < (ts(candidate).fontSize || 0)
+    if (nIsUnitSuffix && (nr.x || 0) >= (cr.x || 0) + (cr.width || 0) - 4) {
+      primaryAmountEl = candidate
+      return true
+    }
+    const left = (rect(candidate).x || 0) <= (nr.x || 0) ? candidate : neighbour
+    const right = left === candidate ? neighbour : candidate
+    const lr = rect(left)
+    const rr = rect(right)
+    const base = (ts(left).fontSize || 0) >= (ts(right).fontSize || 0) ? left : right
+    primaryAmountEl = {
+      ...base,
+      text: textOf(left) + textOf(right),
+      rect: {
+        x: Math.min(lr.x || 0, rr.x || 0),
+        y: Math.min(lr.y || 0, rr.y || 0),
+        width: Math.max((lr.x || 0) + (lr.width || 0), (rr.x || 0) + (rr.width || 0)) -
+          Math.min(lr.x || 0, rr.x || 0),
+        height: Math.max(lr.height || 0, rr.height || 0),
+      },
+    }
+    return true
+  })
+  const primaryAmountIcon = primaryAmountEl ? slices.find((slice) => {
+    const sr = rect(slice)
+    const pr = rect(primaryAmountEl)
+    return (sr.width || 0) >= 16 && (sr.width || 0) <= 44
+      && Math.abs(((sr.y || 0) + (sr.height || 0) / 2) -
+        ((pr.y || 0) + (pr.height || 0) / 2)) <= 16
+      // 碎片合并后的层框右沿比可视字形宽（标注字体窄于渲染字体），
+      // 允许图标左沿落在层框右沿内侧一小段（≤max(16, 12%宽)），但必须位于金额右半。
+      && (sr.x || 0) >= ((pr.x || 0) + (pr.width || 0)) - Math.max(16, (pr.width || 0) * 0.12)
+      && (sr.x || 0) + (sr.width || 0) > (pr.x || 0) + (pr.width || 0) * 0.6
+  }) || null : null
+  const primaryAmount = primaryAmountEl ? {
+    text: textOf(primaryAmountEl),
+    color: ts(primaryAmountEl).color,
+    fontSize: ts(primaryAmountEl).fontSize,
+    fontWeight: ts(primaryAmountEl).fontWeight,
+    editable: !!primaryAmountIcon &&
+      /^\p{Sc}/u.test(textOf(primaryAmountEl)) &&
+      /\d/.test(textOf(primaryAmountEl)),
+    y: rect(primaryAmountEl).y || 0,
+    x: rect(primaryAmountEl).x || 0,
+    width: rect(primaryAmountEl).width || 0,
+    height: rect(primaryAmountEl).height || 0,
+    iconSlice: primaryAmountIcon,
+    // 窄体/非标字体（如 RobotoCondensed）平台无法表达：渲染字形比设计宽 ~15%，
+    // Input 单行盒会裁掉末位并露出输入框白底——此类金额降级为绑定文本还原视觉。
+    unsupportedFont: (() => {
+      const family = String(ts(primaryAmountEl).fontFamily || ts(primaryAmountEl).fontFace || '')
+      return !!family && !/^PingFang/i.test(family)
+    })(),
+  } : null
+  for (const group of optionGroups) {
+    const labelEl = group.sourceLabelEl
+    const isPrimaryAmountFragment = primaryAmountEl && labelEl
+      && textOf(primaryAmountEl).includes(textOf(labelEl))
+      && Math.abs((rect(labelEl).y || 0) - (rect(primaryAmountEl).y || 0)) <= 8
+    if (isPrimaryAmountFragment) {
+      group.label = null
+      group.labelY = group.y
+    }
+    delete group.sourceLabelEl
+  }
+
+  // —— 副金额对：13-14px 居中标签 + 紧随其后的 16px 居中值（纯几何/尺寸驱动，不靠业务关键词）——
+
+  const subAmounts = []
+  const labels = texts.filter((t) => {
+    const T = ts(t)
+    if (_panelGroupMemberEls.has(t)) return false
+    if (repeatRowMode && _repeatLabelTexts.has(textOf(t))) return false
+    return (T.fontSize || 0) >= 12 && (T.fontSize || 0) <= 16
+      && !tabs.some((tab) => tab.value === textOf(t))
+  })
+  // Filter out text fragments that are spatially part of the primary amount (split ¥ + number)
+  const primaryRect = primaryAmountEl ? rect(primaryAmountEl) : null
+  const isPrimaryFragment = (t) => {
+    if (!primaryRect || t === primaryAmountEl) return true
+    const r = rect(t)
+    const xOverlap = (r.x || 0) < (primaryRect.x || 0) + (primaryRect.width || 0)
+      && (r.x || 0) + (r.width || 0) > (primaryRect.x || 0)
+    return Math.abs((r.y || 0) - (primaryRect.y || 0)) <= 8 && xOverlap
+  }
+  // Group labels by Y baseline - subAmounts are parallel columns at the same Y
+  const labelYGroups = new Map()
+  for (const lab of labels) {
+    if (lab === primaryAmountEl || isPrimaryFragment(lab)) continue
+    const ly = rect(lab).y || 0
+    let grouped = false
+    for (const [key, group] of labelYGroups) {
+      if (Math.abs(ly - key) <= 12) { group.push(lab); grouped = true; break }
+    }
+    if (!grouped) labelYGroups.set(ly, [lab])
+  }
+  // Only accept Y groups with 2+ parallel labels (true subAmount columns)
+  const parallelLabels = new Set()
+  for (const [, group] of labelYGroups) {
+    if (group.length >= 2) group.forEach((lab) => parallelLabels.add(lab))
+  }
+  // 与主金额标签同带的并列汇总列（总支出/总收入）不是副金额：留给面板通道整带渲染，
+  // 否则次列被副金额通道甩到卡底（汇总区只剩单列）。
+  const primaryLabelEl = primaryAmountEl ? texts.find((t2) => {
+    const r2 = rect(t2)
+    const dy2 = (primaryRect.y || 0) - ((r2.y || 0) + (r2.height || 0))
+    return dy2 >= -6 && dy2 <= 40 && Math.abs((r2.x || 0) - (primaryRect.x || 0)) <= 40
+  }) || null : null
+  for (const lab of labels) {
+    if (!parallelLabels.has(lab)) continue
+    if (primaryLabelEl && Math.abs((rect(lab).y || 0) - (rect(primaryLabelEl).y || 0)) <= 12) continue
+    // 副金额列标签必须位于主金额值之下：与主值同带的是并列汇总列（总支出/总收入），归面板通道。
+    if (primaryRect && (rect(lab).y || 0) <= (primaryRect.y || 0) + (primaryRect.height || 0)) continue
+    const labR = rect(lab)
+    const valCands = texts.filter((t) => {
+      if (isPrimaryFragment(t)) return false
+      const r = rect(t)
+      const T = ts(t)
+      return t !== lab && t !== primaryAmountEl &&
+        (T.fontSize || 0) >= 16 &&
+        Math.abs((r.x || 0) - (labR.x || 0)) <= 40 &&
+        (r.y || 0) >= ((labR.y || 0) + (labR.height || 0) - 8) &&
+        (r.y || 0) <= ((labR.y || 0) + (labR.height || 0) + 36)
+    })
+    // 金额值必须含数字：设计稿常把"¥"与数字拆成两个文本层，纯符号层不是值
+    // （曾把"¥"当值 → 绑定默认 0 → 渲染成"¥0"，真实金额丢失）。
+    valCands.sort((a, b) =>
+      (/\d/.test(textOf(b)) ? 1 : 0) - (/\d/.test(textOf(a)) ? 1 : 0)
+      || Math.abs((rect(a).x || 0) - (labR.x || 0)) - Math.abs((rect(b).x || 0) - (labR.x || 0)))
+    const valEl = valCands[0]
+    if (valEl) {
+      // 值左侧紧邻的裸货币符号层（"¥"/"￥"）并入值文本（视觉上是同一个金额）。
+      let symEl = null
+      if (!/^\p{Sc}/u.test(textOf(valEl))) {
+        symEl = texts.find((t) => {
+          if (t === valEl || isPrimaryFragment(t)) return false
+          const r = rect(t)
+          const gap = (rect(valEl).x || 0) - ((r.x || 0) + (r.width || 0))
+          return /^\p{Sc}$/u.test(textOf(t))
+            && Math.abs((rect(t).y || 0) - (rect(valEl).y || 0)) <= 8
+            && gap >= -4 && gap <= 20
+        }) || null
+      }
+      subAmounts.push({
+        label: textOf(lab),
+        value: (symEl ? textOf(symEl) : '') + textOf(valEl),
+        labelColor: ts(lab).color,
+        valueColor: ts(valEl).color,
+        valueFontSize: ts(valEl).fontSize,
+        labelEl: lab,
+        valueEl: valEl,
+        symbolEl: symEl,
+      })
+    }
+  }
+  // 副金额元素身份集合（含并入的货币符号层）：下游归属判定一律用元素身份，
+  // 不做文案比较——符号并入后 value 文案与任何单层文本都不相等，字符串比对必然漏判。
+  const subAmountEls = new Set(subAmounts.flatMap((item) => [item.labelEl, item.valueEl, item.symbolEl]).filter(Boolean))
+  // 副金额列标签的行内后缀（如「可用余额」右侧的币种选择器「美元⌄」）：
+  // 与标签同行(±8)、紧贴标签右沿（≤48px）的未消费短文本归入该列标签后缀随标签行渲染；
+  // 其右侧紧邻的小图标切片（下拉箭头等）一并归入，否则图标会丢失或错行渲染。
+  for (const sub of subAmounts) {
+    if (!sub.labelEl) continue
+    const lr = rect(sub.labelEl)
+    const labelRight = (lr.x || 0) + (lr.width || 0)
+    const suffix = texts.find((t) => {
+      if (t === sub.labelEl || subAmountEls.has(t)) return false
+      if (_panelGroupMemberEls.has(t)) return false
+      const tr = rect(t)
+      return Math.abs((tr.y || 0) - (lr.y || 0)) <= 8
+        && (tr.x || 0) >= labelRight - 2 && (tr.x || 0) <= labelRight + 48
+        && (tr.width || 0) <= Math.max(80, (lr.width || 0) * 1.5)
+    })
+    if (!suffix) continue
+    sub.labelSuffixEl = suffix
+    sub.labelSuffix = {
+      text: textOf(suffix), color: ts(suffix).color,
+      fontSize: ts(suffix).fontSize, fontWeight: ts(suffix).fontWeight,
+    }
+    subAmountEls.add(suffix)
+    const suffixR = rect(suffix)
+    const suffixSlice = slices.find((s) => {
+      const sr = rect(s)
+      const w = sr.width || 0, h = sr.height || 0
+      return w >= 8 && w <= 28 && h >= 8 && h <= 28
+        && Math.abs((sr.y || 0) - (suffixR.y || 0)) <= 10
+        && (sr.x || 0) >= (suffixR.x || 0) + (suffixR.width || 0) - 4
+        && (sr.x || 0) <= (suffixR.x || 0) + (suffixR.width || 0) + 32
+    }) || null
+    if (suffixSlice) sub.labelSuffixSlice = suffixSlice
+  }
+
+  // —— 序号徽章行（编号列表）：小尺寸近方形壳(10-28px，带边框/填充)内嵌 ≤2 字符微型文本，
+  // 右侧同线挂内容文本，纵向同列(壳左沿 ±4) ≥2 行成立。纯几何信号，不依赖业务词。 ——
+  // 典型：①②③④⑤ 步骤说明行；壳与数字由徽章容器渲染，内容文本右侧排列。
+  const badgeRows = []
+  const _badgeRowTextEls = new Set()
+  {
+    const badgeShells = shapes.filter((sh) => {
+      const sr = rect(sh)
+      const w = sr.width || 0, h = sr.height || 0
+      if (w < 10 || w > 28 || Math.abs(w - h) > 4) return false
+      const st = sh.style || {}
+      return !!(st.border?.isBorder || st.fill?.color || st.fill?.gradient)
+    })
+    const badgeConsumed = new Set()
+    const badgeConsumedRich = new Set()
+    const candRows = []
+    for (const shell of badgeShells) {
+      const sr = rect(shell)
+      const scx = (sr.x || 0) + (sr.width || 0) / 2
+      const scy = (sr.y || 0) + (sr.height || 0) / 2
+      const digit = texts.find((t) => {
+        if (badgeConsumed.has(t) || subAmountEls.has(t) || _panelGroupMemberEls.has(t)
+          || optionTextSet.has(t) || optionLabelSet.has(t)) return false
+        if ((textOf(t) || '').trim().length > 2) return false
+        const tr = rect(t)
+        return Math.abs((tr.x || 0) + (tr.width || 0) / 2 - scx) <= 6
+          && Math.abs((tr.y || 0) + (tr.height || 0) / 2 - scy) <= 6
+      })
+      if (!digit) continue
+      const content = texts.filter((t) => {
+        if (t === digit || badgeConsumed.has(t) || subAmountEls.has(t)
+          || _panelGroupMemberEls.has(t) || optionTextSet.has(t) || optionLabelSet.has(t)) return false
+        const tr = rect(t)
+        const gap = (tr.x || 0) - ((sr.x || 0) + (sr.width || 0))
+        if (gap < 0 || gap > 24) return false
+        // 多行文本以首行中心对齐徽章中心
+        const firstLineH = Math.min(tr.height || 0, (ts(t).fontSize || 14) * 1.4)
+        const tcy = (tr.y || 0) + firstLineH / 2
+        return Math.abs(tcy - scy) <= 12
+      }).sort((a, b) => (rect(a).y || 0) - (rect(b).y || 0))
+      // 行内容是富文本段落（混合字重被抽成 richBlock，不在通用 text 流里）时先标记，
+      // 待同列成组确认后按徽章行切分段落行（一个段落块可能纵跨多行徽章）
+      const richCand = !content.length
+      if (!content.length && !richCand) continue
+      badgeConsumed.add(digit)
+      content.forEach((t) => badgeConsumed.add(t))
+      candRows.push({ shellEl: shell, digitEl: digit, contentEls: content, richCand, y: sr.y || 0, x: sr.x || 0 })
+    }
+    const colRows = candRows.filter((row) => Math.abs(row.x - (candRows[0]?.x ?? 0)) <= 4)
+    if (colRows.length >= 2) {
+      const sortedRows = colRows.sort((a, b) => a.y - b.y)
+      // 富文本行内容分配：段落块纵向覆盖徽章壳中心才相关；行按 y 桶分到最近上方徽章行
+      const richRows = sortedRows.filter((row) => row.richCand)
+      if (richRows.length) {
+        for (const row of richRows) {
+          const shellR = rect(row.shellEl)
+          const scy = (shellR.y || 0) + (shellR.height || 0) / 2
+          const rb = (richBlocks || []).find((blk) =>
+            blk.lines.some((line) => {
+              const lineY = rect(line[0]).y || 0
+              const lineH = Math.max(...line.map((f) => rect(f).height || 0))
+              return scy >= lineY - 8 && scy <= lineY + lineH + 8
+            }))
+          if (rb) row._richBlock = rb
+        }
+        const assigned = richRows.filter((row) => row._richBlock)
+        for (let i = 0; i < assigned.length; i++) {
+          const row = assigned[i]
+          const rb = row._richBlock
+          const shellR = rect(row.shellEl)
+          const nextShellY = i + 1 < assigned.length && assigned[i + 1]._richBlock === rb
+            ? rect(assigned[i + 1].shellEl).y || 0 : Infinity
+          const rowLines = rb.lines.filter((line) => {
+            const lineY = rect(line[0]).y || 0
+            return lineY >= (shellR.y || 0) - 8 && lineY < nextShellY - 8
+          })
+          if (rowLines.length) {
+            row.contentRichLines = rowLines
+            row.contentRichBlock = rb
+            badgeConsumedRich.add(rb)
+          }
+        }
+        // 未分到内容的 richCand 行整行放弃（避免渲染裸徽章）
+        for (const row of richRows) {
+          if (!row.contentRichLines) {
+            const idx = sortedRows.indexOf(row)
+            if (idx >= 0) sortedRows.splice(idx, 1)
+          }
+        }
+      }
+      if (sortedRows.length < 2) sortedRows.length = 0
+      badgeRows.push(...sortedRows)
+      for (const row of badgeRows) {
+        _badgeRowTextEls.add(row.digitEl)
+        row.contentEls.forEach((t) => _badgeRowTextEls.add(t))
+      }
+      badgeRows._consumedRich = badgeConsumedRich
+    }
+  }
+
+  // —— 标题与主金额之间的同 y 文本簇（如「名称文本」+「(code)」）+ 同位切片图标（纯几何聚类，不暗示业务含义） ——
+  // 纯几何判定：标题底沿与主金额之间、同行(±8px)文本 ≥2 个即聚类；**无主金额时不识别**
+  // （否则主金额不存在时 y 上界=∞，把下方表单行/字段行误收进 midCluster 导致重复渲染与绑定混乱）。
+  const midCluster = (() => {
+    if (!primaryAmountEl) return null
+    const titleBottom = texts.length ? (rect(texts[0]).y || 0) + (rect(texts[0]).height || 20) : 0
+    const amountY = primaryAmountEl ? rect(primaryAmountEl).y || 9999 : 9999
+    const cands = texts.filter((t) => {
+      const y = rect(t).y || 0
+      return y > titleBottom && y < amountY && !tabs.some((tab) => tab.value === textOf(t))
+        && !subAmountEls.has(t)
+        && !_badgeRowTextEls.has(t)
+    })
+    if (cands.length < 2) return null
+    const clusters = []
+    let cur = [cands[0]]
+    for (let i = 1; i < cands.length; i++) {
+      if (sameRow(cands[i], cands[i - 1], 8)) { cur.push(cands[i]) }
+      else { if (cur.length >= 2) clusters.push(cur); cur = [cands[i]] }
+    }
+    if (cur.length >= 2) clusters.push(cur)
+    if (!clusters.length) return null
+    const group = clusters[0].sort((a, b) => (rect(a).x || 0) - (rect(b).x || 0))
+    const grpY = rect(group[0]).y || 0
+    const logoSlice = slices.find((s) => Math.abs((rect(s).y || 0) - grpY) < 15 && (rect(s).x || 0) < rect(group[0]).x)
+    // 标签簇下方同列数值行（并行汇总双列「总支出/总收入」下一行的大字号数值）：
+    // 每个标签 x±24、位于标签带底沿之下 24-56px、含数字 → 归为该簇的值（随带整块渲染）。
+    const grpBottom = Math.max(...group.map((t) => (rect(t).y || 0) + (rect(t).height || 0)))
+    const clusterValues = group.map((t) => {
+      const tr = rect(t)
+      const cand = texts.find((v) => {
+        if (v === t || group.includes(v)) return false
+        const vr = rect(v)
+        const dy = (vr.y || 0) - grpBottom
+        return /\d/.test(textOf(v)) && dy >= 8 && dy <= 56
+          && Math.abs((vr.x || 0) - (tr.x || 0)) <= 24 && (vr.width || 0) <= 160
+      })
+      return cand ? {
+        text: textOf(cand), color: ts(cand).color, fontSize: ts(cand).fontSize,
+        fontWeight: ts(cand).fontWeight, x: rect(cand).x || 0, y: rect(cand).y || 0,
+        width: rect(cand).width || 0, height: rect(cand).height || 0,
+      } : null
+    })
+    return {
+      logoSlice: logoSlice || null,
+      items: group.map((t) => ({
+        text: textOf(t), color: ts(t).color, fontSize: ts(t).fontSize,
+        fontWeight: ts(t).fontWeight, x: rect(t).x || 0, width: rect(t).width || 0,
+        y: rect(t).y || 0, height: rect(t).height || 0,
+      })),
+      values: clusterValues.some(Boolean) ? clusterValues : null,
+      y: grpY,
+    }
+  })()
+
+  // —— 顶部辅助文案（标题 / 副标题等）——
+  // 主视觉区底沿：有主金额用主金额；否则用最大字号文本兜底（头部主数字块，如未读消息数
+  // "12" 30px）——否则 mainBottom=0 会把整个卡片都当表单带/列表区域，头部被误吞。
+  // 复合行模式无全卡主视觉（最大的数字是列表行成员），锚点置空，
+  // 由 listTitle/复合行路径接管纵向结构。
+  const mainVisualEl = repeatRowMode ? null
+    : (primaryAmountEl || sortedByFs.find((t) => !_panelGroupMemberEls.has(t)) || null)
+  const standaloneHeaderPeer = (t) => !primaryAmountEl && !tabs.length && texts[0] &&
+    t !== texts[0] && sameRow(t, texts[0], 12)
+  const mainY = mainVisualEl ? rect(mainVisualEl).y || 0 : 0
+  const mainBottom = mainVisualEl ? (rect(mainVisualEl).y || 0) + (rect(mainVisualEl).height || 0) : 0
+  // 无主视觉元素（纯信息卡）时，用首个表单行 y 作为上下界，
+  // 让表单行上方的文案进入 auxTexts 而非 postAmountTexts
+  // 无主视觉时，用首个以「：」结尾的文本（表单行标签特征）y 值作为分界线
+  const _formLabelYs = texts
+    .filter((t) => /：$/.test(textOf(t)) && (rect(t).y || 0) > (rect(card).y || 0))
+    .map((t) => rect(t).y || 0)
+    .sort((a, b) => a - b)
+  const _formRowTopY = _formLabelYs.length ? _formLabelYs[0] : null
+  // 仅真正的 primaryAmountEl 才能定义主视觉分界线；fallback 到 sortedByFs[0]（最大字号文本）
+  // 只能视为标题，不应阻止其下方文案进入 auxTexts
+  const _hasRealPrimary = !!primaryAmountEl
+  // 无主金额但有主视觉（大字号元素，如产品名/大数字）时，以主视觉 y 作为 auxTexts 上界——
+  // 否则标题区文案（主视觉上方）既非 aux 又非 postAmount，整体掉入死区不渲染。
+  const _anchorY = mainY || (rect(card).y || 0)
+  const _effectiveMainY = _hasRealPrimary ? mainY : (_formRowTopY ?? _anchorY)
+  const _effectiveMainBottom = _hasRealPrimary ? mainBottom : (_formRowTopY ?? _anchorY)
+  const backgroundShellFor = (sourceEl) => {
+    const tr = rect(sourceEl)
+    return (card.elements || []).find((element) => {
+      const fill = element.style?.fill || {}
+      if (element.type !== 'shape' || !fill.color) return false
+      const sr = rect(element)
+      const grow = (dimension, textLength, shellLength) =>
+        shellLength >= textLength && shellLength - textLength <= Math.max(8, textLength * 0.25)
+      return grow('width', tr.width || 0, sr.width || 0)
+        && grow('height', tr.height || 0, sr.height || 0)
+        && Math.abs((sr.x || 0) - (tr.x || 0)) <= 6
+        && Math.abs((sr.y || 0) - (tr.y || 0)) <= 6
+    }) || null
+  }
+  // 描边 pill 壳：文本完整包含在 isBorder+圆角 shape 内（如 标题行右侧的描边操作 pill）。
+  // 与 backgroundShell（填充壳）互补：描边壳 fill 为空，仅靠 border/radius 表达。
+  // 尺寸上限约束壳不显著大于文本（排除面板级描边容器）。
+  const outlineShellFor = (sourceEl) => {
+    const tr = rect(sourceEl)
+    return (card.elements || []).find((element) => {
+      const border = element.style?.border || {}
+      const radius = Number(element.style?.radius?.borderRadius)
+      if (element.type !== 'shape' || !border.isBorder || !(radius >= 4)) return false
+      const sr = rect(element)
+      // 卡壳自排除：覆盖整卡的描边圆角壳是卡片本体（白描边在浅底上不可见），
+      // 认成段落描边 pill 会在卡中部画出一圈可见圆角框（大段落文本曾把 2×h+20 上限撑穿）。
+      const cR = rect(card)
+      if ((sr.width || 0) >= (cR.width || 0) * 0.9 && (sr.height || 0) >= (cR.height || 0) * 0.9) return false
+      return (tr.x || 0) >= (sr.x || 0) - 2 && (tr.y || 0) >= (sr.y || 0) - 2
+        && ((tr.x || 0) + (tr.width || 0)) <= ((sr.x || 0) + (sr.width || 0)) + 2
+        && ((tr.y || 0) + (tr.height || 0)) <= ((sr.y || 0) + (sr.height || 0)) + 2
+        && (sr.width || 0) <= (tr.width || 0) * 2 + 40
+        && (sr.height || 0) <= (tr.height || 0) * 2 + 20
+    }) || null
+  }
+  const highlightShellFor = (sourceEl) => {
+    const textRect = rect(sourceEl)
+    return (card.elements || []).find((element) => {
+      const fill = element.style?.fill || {}
+      if (element.type !== 'shape' || !fill.color) return false
+      const shapeRect = rect(element)
+      const shapeHeight = shapeRect.height || 0
+      const widthRatio = (shapeRect.width || 0) / Math.max(1, textRect.width || 0)
+      return shapeHeight >= 4 && shapeHeight <= Math.max(8, (textRect.height || 0) * 0.5)
+        && widthRatio >= 0.7 && widthRatio <= 1.3
+        && Math.abs(((shapeRect.x || 0) + (shapeRect.width || 0) / 2) -
+          ((textRect.x || 0) + (textRect.width || 0) / 2)) <= 6
+        && Math.abs(((shapeRect.y || 0) + shapeHeight) -
+          ((textRect.y || 0) + (textRect.height || 0))) <= 6
+    }) || null
+  }
+  const auxTexts = texts.filter((t) => {
+    const y = rect(t).y || 0
+    const standaloneHeader = t === texts[0] && !primaryAmountEl && !tabs.length
+
+    return (y > tabY && (y < _effectiveMainY || standaloneHeader || standaloneHeaderPeer(t)))
+      && !tabs.some((tab) => tab.value === textOf(t))
+      && !optionTextSet.has(t) && !optionLabelSet.has(t)
+      && !subAmountEls.has(t)
+      && !_panelGroupMemberEls.has(t)
+      // 按钮文案不得再作辅助文本渲染（与 postAmountTexts 同款排除，防 文本+按钮 重影）
+      && !buttons.some((b) => b.text === textOf(t))
+      // 排除已被 midCluster 归类的文本（避免重复渲染为独立 auxText）
+      && !(midCluster && midCluster.items.some((b) => b.text === textOf(t)))
+      && !_badgeRowTextEls.has(t)
+  }).map((t) => ({
+    text: textOf(t),
+    color: ts(t).color,
+    fontSize: ts(t).fontSize,
+    fontWeight: ts(t).fontWeight,
+    align: ts(t).textAlign,
+    sliceEl: slices.find((slice) => {
+      const sr = rect(slice)
+      const tr = rect(t)
+      const sliceCenter = (sr.y || 0) + (sr.height || 0) / 2
+      const textCenter = (tr.y || 0) + (tr.height || 0) / 2
+      const gapLeft = (tr.x || 0) - ((sr.x || 0) + (sr.width || 0))
+      const gapRight = (sr.x || 0) - ((tr.x || 0) + (tr.width || 0))
+      // 竖直容差随切片高度放宽：大尺寸主视觉（吉祥物/头像）与多行文本的中心差可达
+      // 十几 px，固定 8px 只认小图标 → 主视觉掉进孤立媒体块单独成行（卡头被拆两行）。
+      const vTol = Math.max(8, Math.min((sr.height || 0) * 0.35, (tr.height || 0) * 0.6))
+      const vOverlap = Math.min((sr.y || 0) + (sr.height || 0), (tr.y || 0) + (tr.height || 0))
+        - Math.max(sr.y || 0, tr.y || 0)
+      return Math.abs(sliceCenter - textCenter) <= vTol && vOverlap > 0
+        && ((gapLeft >= -4 && gapLeft <= 24) || (gapRight >= -4 && gapRight <= 24))
+    }) || null,
+    decoSliceEl: slices.find((slice) => {
+      const sr = rect(slice)
+      const tr = rect(t)
+      const sliceCenterX = (sr.x || 0) + (sr.width || 0) / 2
+      const textCenter = (tr.y || 0) + (tr.height || 0) / 2
+      // 文本底带装饰切片（下划波浪/高亮笔触）：水平落在文本宽度内、竖直贴文本下半段
+      // → 随文本行渲染；否则薄切片（高 <20）进不了孤立媒体块被静默丢弃。
+      return (sr.height || 0) >= 4 && (sr.height || 0) <= Math.max(8, (tr.height || 0) * 0.5)
+        && (sr.width || 0) <= (tr.width || 0)
+        && (sr.y || 0) >= textCenter && (sr.y || 0) <= (tr.y || 0) + (tr.height || 0) + 8
+        && sliceCenterX >= (tr.x || 0) && sliceCenterX <= (tr.x || 0) + (tr.width || 0)
+    }) || null,
+    backgroundShell: backgroundShellFor(t),
+    outlineShell: outlineShellFor(t),
+    highlightShell: highlightShellFor(t),
+    y: rect(t).y || 0, // 几何 y（顶部/底部块归属判定用：y < 顶部区底沿 → 顶部容器）
+    x: rect(t).x || 0,
+    width: rect(t).width || 0,
+    height: rect(t).height || (ts(t).fontSize || 14) * 1.4,
+    sourceEl: t,
+  }))
+
+  // —— 表单行（label + 同行 companion）：「左标签 / 右簇值」「附言 / 30字以内…」——
+  // 结构判定优先于颜色：本 spec 逐文本 color 多为 null，无法用灰度判定 placeholder；
+  // Input placeholder 由值文本相对标签文本的亮度差判定；缺少可比较颜色时不成 Input。
+  // —— 表单行（结构优先：先按空间拓扑聚类「左标签 + 右簇」，再区分值、子值、右侧行操作件）——
+  // 拓扑驱动：完全基于元素 x/y 空间关系，不依赖字段名词典（避免把「可用余额：」误判成独立 label）。
+  //   一个表单行 = 表单带内「左锚定文本(label)」+ 其右侧同一竖直窗口内的全部文本与图标切片(右簇)。
+  //   右簇内：基线一致的最上文本为 value；下方短副行为 subValue；最右几何媒体为 rightAffordance。
+  const formRows = []
+  const formConsumed = new Set()
+  const releasedListRows = []
+  // —— 枚举统计行预扫描（Enum-Stat Strip，文本自明优先于几何聚类）——
+  // 文本内嵌「类型标签+数字」多段枚举（如「动账 5 · 转账 2 · 站内 1 · 其他 4」）时，该文本的
+  // 结构由**文本自身**决定（≥2 段标签+数字+统一分隔符），不应被几何聚类误吞为表单行 label/value。
+  // 命中文本：① 从表单行 label 候选排除；② 从右簇候选排除——但不能标记进 formConsumed
+  // （postAmountTexts 用 !formConsumed 过滤，误标会让文本被静默丢弃）。用独立 enumStatConsumed。
+  // 最终会进入 postAmountTexts → midAux 渲染时走枚举统计绑定（detectEnumStatStrip 二次命中）。
+  // 兜底映射：raw 文本 → {items, sep}，供渲染复用（避免重复解析）。
+  const enumStatConsumed = new Set()
+  const enumStatMap = {}
+  for (const t of texts) {
+    const raw = (textOf(t) || '').trim()
+    if (!raw) continue
+    const stat = detectEnumStatStrip(raw)
+    if (stat) {
+      enumStatMap[raw] = stat
+      enumStatConsumed.add(t)
+    }
+  }
+  // 按钮底沿（表单行必须位于按钮上方，避免把按钮内文本误判为 label）
+  // 表单带下界只看主尺寸按钮（w>=80）：行内小 pill（修改/预约）位置高，
+  // 若计入会把其下方整片表单区判为「按钮之下」而丢失全部表单行。
+  const primaryButtonShapes = buttonShapes.filter((b) => (rect(b).width || 0) >= 80)
+  const btnBottom = primaryButtonShapes.length ? Math.max(...primaryButtonShapes.map((b) => (rect(b).y || 0) + (rect(b).height || 0))) : 9999
+  const formBandTop = mainBottom + 6
+  // —— 对比面板组预抽取（并排小卡：壳内左对齐「标签行 + 值行」，可带圆点/状态 tag）——
+  // 通用「label + 同行右簇 value」配对会跨壳把并排面板的两条标签配成一行
+  // （持仓比例 ↔ 建议比例）、值行同理；壳底色/圆角/圆点/状态 tag 也全部丢失。
+  // 故先按壳几何把面板行摘出（每壳一行）并消费其文本，禁止通用配对再碰。
+  const panelShellCands = shapes.filter((s2) => {
+    const f2 = s2.style?.fill
+    if (!f2 || (!f2.color && !f2.gradient)) return false
+    if (radiusMax(s2.style) < 4) return false
+    const r2 = rect(s2)
+    const w2 = r2.width || 0; const h2 = r2.height || 0
+    if (w2 < 100 || w2 > 260 || h2 < 48 || h2 > 120) return false
+    if ((r2.y || 0) <= formBandTop || (r2.y || 0) >= btnBottom) return false
+    const inside = texts.filter((t2) => rectInside(r2, rect(t2), 0))
+    if (inside.length < 2) return false
+    const lineKeys = new Set(inside.map((t2) => Math.round((rect(t2).y || 0) / 6)))
+    return lineKeys.size >= 2
+  })
+  // 同位双层标注（编组+矩形）与内层装饰壳去重：保留最外层且有实体填充色的 shape
+  const panelShells = panelShellCands.filter((a) => {
+    const ra = rect(a)
+    const aSolid = !!(a.style?.fill?.color)
+    return !panelShellCands.some((b) => {
+      if (b === a) return false
+      const rb = rect(b)
+      if (!rectInside(rb, ra, 1)) return false
+      const sameRect = Math.abs((rb.width || 0) - (ra.width || 0)) <= 2
+        && Math.abs((rb.height || 0) - (ra.height || 0)) <= 2
+      if (!sameRect) return true
+      const bSolid = !!(b.style?.fill?.color)
+      return !aSolid || (bSolid && panelShellCands.indexOf(b) < panelShellCands.indexOf(a))
+    })
+  })
+  for (const shellEl of panelShells) {
+    const sr2 = rect(shellEl)
+    const insideTexts = texts
+      .filter((t2) => !formConsumed.has(t2) && !enumStatConsumed.has(t2) && rectInside(sr2, rect(t2), 0))
+      .sort((p, q) => (rect(p).y || 0) - (rect(q).y || 0))
+    if (insideTexts.length < 2) continue
+    const labEl = insideTexts[0]
+    const labR = rect(labEl)
+    const restLines = insideTexts.slice(1)
+    const valEl = restLines[0]
+    const valR = rect(valEl)
+    const tagCand = restLines.find((t2) => t2 !== valEl
+      && (rect(t2).width || 0) <= 60 && (rect(t2).height || 0) <= 24
+      && (rect(t2).x || 0) > (valR.x || 0) + (valR.width || 0) - 2
+      && Math.abs((rect(t2).y || 0) - (valR.y || 0)) <= 12) || null
+    const tagShapeOf = (t2) => shapes.find((s3) => {
+      const r3 = rect(s3); const tr3 = rect(t2)
+      return (r3.width || 0) >= (tr3.width || 0) && (r3.width || 0) <= (tr3.width || 0) + 16
+        && (r3.height || 0) >= (tr3.height || 0) && (r3.height || 0) <= (tr3.height || 0) + 12
+        && Math.abs((r3.x || 0) - (tr3.x || 0)) <= 8 && Math.abs((r3.y || 0) - (tr3.y || 0)) <= 8
+    }) || null
+    const tagShapeEl = tagCand ? tagShapeOf(tagCand) : null
+    // 无壳短文本按子值处理（第二值），有壳才是状态 tag
+    const tagEl = tagShapeEl ? tagCand : null
+    const subEls2 = restLines.filter((t2) => t2 !== valEl && t2 !== tagEl)
+    const dotEl = shapes.find((s3) => {
+      const f3 = s3.style?.fill
+      if (!f3 || !f3.color) return false
+      const r3 = rect(s3)
+      const w3 = r3.width || 0; const h3 = r3.height || 0
+      if (w3 < 6 || w3 > 14 || h3 < 6 || h3 > 14) return false
+      return rectInside(sr2, r3, 0)
+        && (r3.x || 0) + w3 <= (labR.x || 0)
+        && Math.abs(((r3.y || 0) + h3 / 2) - ((labR.y || 0) + (labR.height || 0) / 2)) <= 12
+    }) || null
+    formRows.push({
+      panelShell: {
+        x: sr2.x || 0, y: sr2.y || 0, width: sr2.width || 0, height: sr2.height || 0,
+        fill: shellEl.style?.fill?.color || null,
+        gradient: shellEl.style?.fill?.gradient || null,
+        radius: radiusMax(shellEl.style),
+        opacity: shellEl.style?.opacity ?? 1,
+      },
+      dot: dotEl ? {
+        color: dotEl.style.fill.color,
+        x: rect(dotEl).x || 0, y: rect(dotEl).y || 0,
+        w: Math.round(rect(dotEl).width || 8), h: Math.round(rect(dotEl).height || 8),
+        gap: Math.max(0, Math.round((labR.x || 0) - ((rect(dotEl).x || 0) + (rect(dotEl).width || 0)))),
+      } : null,
+      tag: tagEl ? {
+        text: textOf(tagEl), color: ts(tagEl).color, fontSize: ts(tagEl).fontSize,
+        borderColor: tagShapeEl.style?.border?.isBorder ? tagShapeEl.style.border.color : null,
+        fill: tagShapeEl.style?.fill?.color || null,
+        radius: radiusMax(tagShapeEl.style),
+        w: Math.round(rect(tagShapeEl).width || 24),
+        h: Math.round(rect(tagShapeEl).height || 14),
+        right: Math.round((rect(tagShapeEl).x || 0) + (rect(tagShapeEl).width || 0)),
+      } : null,
+      label: { text: textOf(labEl), color: ts(labEl).color, fontSize: ts(labEl).fontSize, fontWeight: ts(labEl).fontWeight, x: labR.x || 0, y: labR.y || 0, width: labR.width || 0, height: labR.height || (ts(labEl).fontSize || 14) * 1.4 },
+      leftIconSlice: null,
+      value: { text: textOf(valEl), color: ts(valEl).color, fontSize: ts(valEl).fontSize, fontWeight: ts(valEl).fontWeight, x: valR.x || 0, y: valR.y || 0, width: valR.width || 0, height: valR.height || (ts(valEl).fontSize || 14) * 1.4 },
+      subValues: subEls2.map((t2) => ({ text: textOf(t2), color: ts(t2).color, fontSize: ts(t2).fontSize, fontWeight: ts(t2).fontWeight, x: rect(t2).x || 0, y: rect(t2).y || 0, width: rect(t2).width || 0, height: rect(t2).height || (ts(t2).fontSize || 14) * 1.4 })),
+      rightAffordanceSlice: null,
+      isPlaceholder: false,
+      labelEl: labEl,
+      valueEl: valEl,
+      subEls: subEls2,
+    })
+    formConsumed.add(labEl)
+    formConsumed.add(valEl)
+    if (tagEl) formConsumed.add(tagEl)
+    subEls2.forEach((t2) => formConsumed.add(t2))
+  }
+  // 候选左标签：表单带内、左锚定（x < 120）的文本；枚举统计行文本已排除；
+  // 另排除「大字号纯数字」头部主数字（如未读消息数 12）——标题区数字块不是表单 label。
+  const labelCands = texts.filter((t) => {
+    const y = rect(t).y || 0; const x = rect(t).x || 0
+    const T = ts(t)
+    const bigNum = (T.fontSize || 0) >= LABEL_MAX_NUM_FONT && /^\d+$/.test(textOf(t).trim())
+    return x < 120 && y > formBandTop && y < btnBottom && !formConsumed.has(t)
+      && !enumStatConsumed.has(t) && !bigNum
+      && !_isRepeatedRowText(t)
+      && !_panelGroupMemberEls.has(t)
+      && !buttons.some((button) => button.text === textOf(t))
+      && !optionTextSet.has(t) && !optionLabelSet.has(t)
+      && !subAmountEls.has(t)
+      && !_badgeRowTextEls.has(t)
+      // 复合行模式：波段标签本身与其上方的行标题都是列表行成员，不得被表单行吞掉
+      && !(repeatRowMode && _repeatLabelTexts.has(textOf(t)))
+      && !(repeatRowMode && _allBandTops.some((bt) => y >= bt - 4 && y <= bt + 80))
+      && !(repeatRowMode && _allBandTops.some((bt) => {
+        const dy = bt - y
+        return dy >= 18 && dy <= 110
+      }))
+  })
+  for (const lab of labelCands) {
+    const ly = rect(lab).y || 0; const lx = rect(lab).x || 0; const lw = rect(lab).width || 0
+    const labelRight = lx + lw
+    // 右簇文本：y ∈ [ly-16, ly+35]、右边缘超出标签右沿（用右边缘判定，兼容右对齐占位文本左缘落在标签包围盒内的情况）
+    // 窗口必须收窄（曾用 +60 跨行捕获：字段行距 ~40px 时把下一行值/卡号误当本行子值 → 重复渲染 + 对象字段错乱）
+    // 枚举统计行文本除外（双重保险）
+    // P0 升级：① value 必须与 label 视觉基线（y+fontSize）对齐（≤ FORM_ROW_BASE_GAP），
+    //   「上下两行的标题-描述」文本（基线差 16-26px）不得误判为 value；
+    const cardW = (spec.size && spec.size.width) || 375
+    const lBase = ly + (ts(lab).fontSize || 0)
+    // 行尾操作件候选池：slice 与 symbol 同等对待——同一视觉图标在标注里可能是任一形态
+    // （曾只收 slice：行尾箭头被标成 symbol 时整行 affordance 丢失，图标掉进孤立块渲染到卡片底部）。
+    const rightAffordanceCandidates = [...slices, ...symbols].filter((s) => {
+      const sr = rect(s)
+      const width = sr.width || 0
+      const height = sr.height || 0
+      const verticalCenter = (sr.y || 0) + height / 2
+      return width >= 12 && width <= 44 && height >= 12 && height <= 44
+        && Math.abs(width - height) <= Math.max(10, width * 0.5)
+        && ((sr.x || 0) + width) >= (rect(card).x || 0) + cardW - 72
+        && Math.abs(verticalCenter - ((ly || 0) + (ts(lab).fontSize || 0) / 2)) <= 20
+    })
+    const rt = texts.filter((t) => {
+      if (t === lab || formConsumed.has(t) || enumStatConsumed.has(t)) return false
+      if (_panelGroupMemberEls.has(t)) return false
+      if (buttons.some((button) => button.text === textOf(t))) return false
+      if (optionTextSet.has(t) || optionLabelSet.has(t)) return false
+      if (subAmountEls.has(t)) return false
+      const y = rect(t).y || 0; const x = rect(t).x || 0
+      const rEdge = x + (rect(t).width || 0)
+      const vBase = y + (ts(t).fontSize || 0)
+      const isBindableValue = ['amount', 'cardNumber', 'phone', 'code', 'date']
+        .includes(classifyValue(textOf(t)))
+      const isRightAction = !isBindableValue && x >= cardW * RIGHT_ACTION_X_RATIO
+        && rightAffordanceCandidates.some((s) => Math.abs((rect(s).y || 0) - y) <= 20)
+      return y >= ly - 16 && y <= ly + 45 && rEdge > labelRight
+       
+    })
+    // 右侧媒体切片：同竖直窗口、右边缘超出标签右沿，再由几何 candidates 确认。
+    const sl = [...slices, ...symbols].filter((s) => {
+      const y = rect(s).y || 0; const x = rect(s).x || 0
+      const rEdge = x + (rect(s).width || 0)
+      return y >= ly - 20 && y <= ly + 35 && rEdge > labelRight
+    })
+    // 表单行必须「label + 文本 value」同行配对：rt 为空（无同行文本 value）时不成行——
+    // P0 基线判定后，列表项标题/描述（上下两行）的右簇文本已全部被排除。若仅有
+    // 右侧媒体而无同行可绑定文本，则不成立空表单行，避免吞掉后续列表内容。
+    // 写进 formRows 并 formConsumed 吞掉列表项，导致列表识别再次失效。
+    if (rt.length === 0) continue
+    let alignedRightTexts = rt.filter((t) =>
+      Math.abs(((rect(t).y || 0) + (ts(t).fontSize || 0)) -
+        ((rect(lab).y || 0) + (ts(lab).fontSize || 0))) <= FORM_ROW_BASE_GAP)
+    // 多行右栏回退：右簇无同基线文本、但存在「竖直连续、右缘同列、整体垂直居中于 label」
+    // 的多行堆叠时（值行+副值行居中于左标签），按多行值收编，避免整行退化为平铺孤立块。
+    if (alignedRightTexts.length === 0 && rt.length >= 2) {
+      const stacked = [...rt].sort((a, c) => (rect(a).y || 0) - (rect(c).y || 0))
+      const stackTop = rect(stacked[0]).y || 0
+      const stackBottom = Math.max(...stacked.map((t) => (rect(t).y || 0) + (rect(t).height || 0)))
+      const labelVCenter = ly + (rect(lab).height || (ts(lab).fontSize || 14) * 1.4) / 2
+      const contiguous = stacked.every((t, i) => i === 0 ||
+        (rect(t).y || 0) <= (rect(stacked[i - 1]).y || 0) + (rect(stacked[i - 1]).height || 0) + 8)
+      // 右缘同列按「行」度量：一行可能由多个异色 run 拼成（红色警示+灰色补充），
+      // 逐文本度量会把行内左段 run 的右缘混进来，误判整列散开而拒收。
+      const lineRights = new Map()
+      for (const t of stacked) {
+        const key = Math.round((rect(t).y || 0) / 4)
+        const right = (rect(t).x || 0) + (rect(t).width || 0)
+        lineRights.set(key, Math.max(lineRights.get(key) || 0, right))
+      }
+      const rightEdges = [...lineRights.values()]
+      // 右缘同列容忍放宽到 64px：右对齐堆叠里副行（如红色错误提示）比值行宽，
+      // 24px 容忍会把「值行+提示行」整列拒收，整行退化为平铺孤立块。
+      const sameColumn = Math.max(...rightEdges) - Math.min(...rightEdges) <= 64
+      if (contiguous && sameColumn && stackTop - 6 <= labelVCenter && labelVCenter <= stackBottom + 6) {
+        alignedRightTexts = stacked
+      }
+    }
+    if (alignedRightTexts.length === 0) continue
+    // 值 = 与标签同基线的可绑定文本；紧随其下的短副行才作为子值，
+    // 避免把下一表单行误收进来，也不因副行基线不同而丢失「值 + 说明」结构。
+    const valueEl = [...alignedRightTexts].sort((a, c) => (rect(a).y || 0) - (rect(c).y || 0))[0] || null
+    const valueBottom = valueEl ? (rect(valueEl).y || 0) + (rect(valueEl).height || 0) : 0
+    const subEls = rt.filter((t) => t !== valueEl
+      && (rect(t).y || 0) >= valueBottom - 2
+      && (rect(t).y || 0) <= valueBottom + 28)
+      .filter((t) => !labelCands.some((label) => label !== lab && !formConsumed.has(label)
+        && Math.abs((rect(label).y || 0) - (rect(t).y || 0)) <= 8))
+      .sort((a, c) => (rect(a).x || 0) - (rect(c).x || 0))
+    const rightAffordanceSlice = [...sl]
+      .sort((left, right) => ((rect(right).x || 0) + (rect(right).width || 0))
+        - ((rect(left).x || 0) + (rect(left).width || 0)))
+      .find((s) => rightAffordanceCandidates.includes(s)) || null
+    // placeholder 判定：值文本明显比 label 浅时视为输入占位，只消费设计稿自身的视觉对比信号。
+    // 但强调色值（如橙色电话/地址，高饱和度）不是占位符——占位符是浅灰色（低饱和）。
+    // 曾把 #FF8401 橙色值误判为 placeholder → 渲染成空 Input（值整体丢失）。
+    const colorSat = (hex) => {
+      const h = String(hex || '').replace('#', '')
+      if (!/^[0-9a-fA-F]{6}$/.test(h)) return 0
+      const r = parseInt(h.slice(0, 2), 16) / 255, g = parseInt(h.slice(2, 4), 16) / 255, b = parseInt(h.slice(4, 6), 16) / 255
+      const mx = Math.max(r, g, b), mn = Math.min(r, g, b)
+      return mx === 0 ? 0 : (mx - mn) / mx
+    }
+    const isPlaceholder = valueEl
+      ? lum(ts(valueEl).color) - lum(ts(lab).color) > 0.3 && colorSat(ts(valueEl).color) < 0.25
+      : false
+    // 行左图标：label 左侧、竖直中心对齐的小切片（如 营业/排队/电话/地址 行图标）。
+    // 此前左图标无任何归属路径，被静默丢弃。
+    const leftIconSlice = slices.find((s) => {
+      const sr = rect(s)
+      const sw = sr.width || 0, sh = sr.height || 0
+      const vCenter = (sr.y || 0) + sh / 2
+      const lCenter = ly + (ts(lab).fontSize || 0) / 2
+      return sw >= 10 && sw <= 32 && sh >= 10 && sh <= 32
+        && (sr.x || 0) + sw <= lx + 2 && (sr.x || 0) >= (rect(card).x || 0) - 4
+        && Math.abs(vCenter - lCenter) <= 12
+    }) || null
+    // 对比面板壳/圆点/行内状态 tag：壳承行底色/圆角/高度与内缩，圆点进 label 左簇，tag 随值行
+    const labRect0 = rect(lab)
+    const labCenter0 = { x: (labRect0.x || 0) + (labRect0.width || 0) / 2, y: (labRect0.y || 0) + (labRect0.height || 0) / 2 }
+    const panelShellEl = shapes.find((s2) => {
+      const f2 = s2.style?.fill
+      if (!f2 || (!f2.color && !f2.gradient)) return false
+      if (radiusMax(s2.style) < 4) return false
+      const r2 = rect(s2)
+      const w2 = r2.width || 0; const h2 = r2.height || 0
+      if (w2 < 100 || w2 > 260 || h2 < 48 || h2 > 120) return false
+      return labCenter0.x >= (r2.x || 0) && labCenter0.x <= (r2.x || 0) + w2
+        && labCenter0.y >= (r2.y || 0) && labCenter0.y <= (r2.y || 0) + h2
+    }) || null
+    const dotEl = panelShellEl ? shapes.find((s2) => {
+      const f2 = s2.style?.fill
+      if (!f2 || !f2.color) return false
+      const r2 = rect(s2)
+      const w2 = r2.width || 0; const h2 = r2.height || 0
+      if (w2 < 6 || w2 > 14 || h2 < 6 || h2 > 14) return false
+      const pr2 = rect(panelShellEl)
+      return (r2.x || 0) >= (pr2.x || 0) && (r2.x || 0) + w2 <= (pr2.x || 0) + (pr2.width || 0)
+        && (r2.y || 0) >= (pr2.y || 0) && (r2.y || 0) + h2 <= (pr2.y || 0) + (pr2.height || 0)
+        && (r2.x || 0) + w2 <= (labRect0.x || 0)
+        && Math.abs(((r2.y || 0) + h2 / 2) - labCenter0.y) <= 12
+    }) || null : null
+    const tagTextEl = panelShellEl ? texts.find((t2) => {
+      if (t2 === lab || t2 === valueEl || subEls.includes(t2)) return false
+      const r2 = rect(t2)
+      const w2 = r2.width || 0; const h2 = r2.height || 0
+      if (w2 < 8 || w2 > 60 || h2 < 8 || h2 > 24) return false
+      const pr2 = rect(panelShellEl)
+      return (r2.x || 0) >= (pr2.x || 0) && (r2.x || 0) + w2 <= (pr2.x || 0) + (pr2.width || 0)
+        && (r2.y || 0) >= (pr2.y || 0) && (r2.y || 0) + h2 <= (pr2.y || 0) + (pr2.height || 0)
+    }) || null : null
+    const tagShapeEl = tagTextEl ? shapes.find((s2) => {
+      const r2 = rect(s2)
+      const tr2 = rect(tagTextEl)
+      return (r2.width || 0) >= (tr2.width || 0) && (r2.width || 0) <= (tr2.width || 0) + 16
+        && (r2.height || 0) >= (tr2.height || 0) && (r2.height || 0) <= (tr2.height || 0) + 12
+        && Math.abs((r2.x || 0) - (tr2.x || 0)) <= 8 && Math.abs((r2.y || 0) - (tr2.y || 0)) <= 8
+    }) || null : null
+    formRows.push({
+      panelShell: panelShellEl ? {
+        x: rect(panelShellEl).x || 0, y: rect(panelShellEl).y || 0,
+        width: rect(panelShellEl).width || 0, height: rect(panelShellEl).height || 0,
+        fill: panelShellEl.style?.fill?.color || null,
+        gradient: panelShellEl.style?.fill?.gradient || null,
+        radius: radiusMax(panelShellEl.style),
+        opacity: panelShellEl.style?.opacity ?? 1,
+      } : null,
+      dot: dotEl ? {
+        color: dotEl.style.fill.color,
+        x: rect(dotEl).x || 0, y: rect(dotEl).y || 0,
+        w: Math.round(rect(dotEl).width || 8), h: Math.round(rect(dotEl).height || 8),
+        gap: Math.max(0, Math.round((labRect0.x || 0) - ((rect(dotEl).x || 0) + (rect(dotEl).width || 0)))),
+      } : null,
+      tag: tagTextEl ? {
+        text: textOf(tagTextEl), color: ts(tagTextEl).color, fontSize: ts(tagTextEl).fontSize,
+        borderColor: tagShapeEl && tagShapeEl.style?.border?.isBorder ? tagShapeEl.style.border.color : null,
+        fill: tagShapeEl ? (tagShapeEl.style?.fill?.color || null) : null,
+        radius: tagShapeEl ? radiusMax(tagShapeEl.style) : 2,
+        w: Math.round(rect(tagShapeEl || tagTextEl).width || 24),
+        h: Math.round(rect(tagShapeEl || tagTextEl).height || 14),
+        right: Math.round((rect(tagShapeEl || tagTextEl).x || 0) + (rect(tagShapeEl || tagTextEl).width || 0)),
+      } : null,
+      label: { text: textOf(lab), color: ts(lab).color, fontSize: ts(lab).fontSize, fontWeight: ts(lab).fontWeight, x: lx, y: ly, width: rect(lab).width || 0, height: rect(lab).height || (ts(lab).fontSize || 14) * 1.4 },
+      leftIconSlice,
+      value: valueEl ? { text: textOf(valueEl), color: ts(valueEl).color, fontSize: ts(valueEl).fontSize, fontWeight: ts(valueEl).fontWeight, x: rect(valueEl).x || 0, y: rect(valueEl).y || 0, width: rect(valueEl).width || 0, height: rect(valueEl).height || (ts(valueEl).fontSize || 14) * 1.4 } : null,
+      subValues: subEls.map((t) => ({ text: textOf(t), color: ts(t).color, fontSize: ts(t).fontSize, fontWeight: ts(t).fontWeight, x: rect(t).x || 0, y: rect(t).y || 0, width: rect(t).width || 0, height: rect(t).height || (ts(t).fontSize || 14) * 1.4 })),
+      rightAffordanceSlice,
+      isPlaceholder,
+      labelEl: lab,
+      valueEl,
+      subEls,
+    })
+    formConsumed.add(lab)
+    if (valueEl) formConsumed.add(valueEl)
+    subEls.forEach((t) => formConsumed.add(t))
+  }
+
+  // 周期同构行护栏：≥3 个表单行共享同一几何签名（label 列 x/fs + value fs）且行距等周期时，
+  // 它们**可能**是列表行而非独立表单字段——释放消费标记交给列表识别，否则列表退化为平铺表单行、
+  // 行内描述行失去归属被甩到列表之后（账单/记录类卡片高发）。
+  // 但「等周期 + 大行距」不足以判定列表：地址/验证码类表单自带分隔线与行尾编辑件，
+  // 行距可达 55~100px，一旦释放右栏值就失去归属而整段丢失（曾造成地址管理卡回归）。
+  // 判据收紧为「多行行」：行带内除标题外还有左栏描述行，或行首带图标；且组内全部行都满足，
+  // 混合结构一律保留为表单行。
+  {
+    const rowSignature = (row) => [
+      Math.round((row.label.x || 0) / 8),
+      row.label.fontSize || 0,
+      row.value ? (row.value.fontSize || 0) : 0,
+    ].join(':')
+    const signatureGroups = new Map()
+    for (const row of formRows) {
+      const key = rowSignature(row)
+      if (!signatureGroups.has(key)) signatureGroups.set(key, [])
+      signatureGroups.get(key).push(row)
+    }
+    for (const rows of signatureGroups.values()) {
+      if (rows.length < 3) continue
+      const ys = rows.map((row) => row.label.y || 0).sort((a, b) => a - b)
+      const pitches = ys.slice(1).map((y, i) => y - ys[i])
+      if (!pitches.every((pitch) => Math.abs(pitch - pitches[0]) <= 8)) continue
+      // 行距下限：紧凑字段栈（结果卡 转账金额/收款人/收款账户，行距 ~24px）也等周期，
+      // 但它是独立表单字段而非列表行；列表行含描述行，行距 ≥40px。
+      if (pitches[0] < 40) continue
+      const bandPitch = pitches[0]
+      // 多行行判定：标题下方、下一行标题上方，左栏（x 与标题同列 ±24px）还有文本 = 描述行。
+      const isMultiLineRow = (row) => {
+        if (row.leftIconSlice) return true
+        const labelX = row.label.x || 0
+        const labelBottom = (row.label.y || 0) + (row.label.height || (row.label.fontSize || 14) * 1.4)
+        const bandBottom = (row.label.y || 0) + bandPitch
+        const owned = new Set([row.labelEl, row.valueEl, ...(row.subEls || [])])
+        return texts.some((t) => {
+          if (owned.has(t) || !textOf(t).trim()) return false
+          const tr = rect(t)
+          const tx = tr.x || 0
+          const ty = tr.y || 0
+          return ty >= labelBottom - 2 && ty < bandBottom - 2 && Math.abs(tx - labelX) <= 24
+        })
+      }
+      if (!rows.every(isMultiLineRow)) continue
+      for (const row of rows) {
+        const idx = formRows.indexOf(row)
+        if (idx >= 0) formRows.splice(idx, 1)
+        formConsumed.delete(row.labelEl)
+        if (row.valueEl) formConsumed.delete(row.valueEl)
+        for (const sub of row.subEls || []) formConsumed.delete(sub)
+        releasedListRows.push(row)
+      }
+    }
+  }
+
+  // 同名 label 护栏：表单带内同一 label 文本出现 ≥2 次，说明这些行是重复结构的列表行
+  // （如名册中的多个人名行），而非表单行——移除并释放消费标记，让列表识别接管。
+  {
+    const formLabelCounts = new Map()
+    for (const row of formRows) {
+      const key = (row.label?.text || '').trim()
+      if (key) formLabelCounts.set(key, (formLabelCounts.get(key) || 0) + 1)
+    }
+    for (let rowIndex = formRows.length - 1; rowIndex >= 0; rowIndex -= 1) {
+      const row = formRows[rowIndex]
+      if ((formLabelCounts.get((row.label?.text || '').trim()) || 0) >= 2) {
+        if (row.labelEl) formConsumed.delete(row.labelEl)
+        if (row.valueEl) formConsumed.delete(row.valueEl)
+        ;(row.subEls || []).forEach((el) => formConsumed.delete(el))
+        formRows.splice(rowIndex, 1)
+      }
+    }
+  }
+
+  // 行内尾随图标：值文本右侧紧邻的小图标（如 排队：5 后的刷新图标）。
+  // 与行尾 affordance 的区别：贴值右沿而非卡片右缘，是值流的一部分，渲染时随值走。
+  {
+    const trailingPool = [...slices, ...symbols].filter((el) => {
+      const er = rect(el)
+      const w = er.width || 0, h = er.height || 0
+      return w >= 10 && w <= 28 && h >= 10 && h <= 28
+    })
+    for (const row of formRows) {
+      if (row.panelShell) continue
+      if (row.trailingIconSlice || row.rightAffordanceSlice || row.rightActionButton) continue
+      const anchor = row.value
+      if (!anchor) continue
+      const valueRight = (anchor.x || 0) + (anchor.width || 0)
+      const lineCenter = (anchor.y || 0) + (anchor.height || (anchor.fontSize || 14) * 1.4) / 2
+      row.trailingIconSlice = trailingPool
+        .filter((el) => {
+          const er = rect(el)
+          const iconCenter = (er.y || 0) + (er.height || 0) / 2
+          const gap = (er.x || 0) - valueRight
+          return gap >= 0 && gap <= 40 && Math.abs(iconCenter - lineCenter) <= 14
+        })
+        .sort((a, b) => (rect(a).x || 0) - (rect(b).x || 0))[0] || null
+    }
+    // 行内前置图标：值文本左侧紧邻的小媒体（如行内 logo + 卡号），是值流的一部分；
+    // 无归属路径时会被静默丢弃，右栏只剩裸文本。
+    const claimed = new Set(formRows.flatMap((row) =>
+      [row.rightAffordanceSlice, row.leftIconSlice, row.trailingIconSlice].filter(Boolean)))
+    for (const row of formRows) {
+      if (row.panelShell) continue
+      const anchor = row.value
+      if (!anchor || row.valueLeadSlice) continue
+      const valueLeft = anchor.x || 0
+      const lineCenter = (anchor.y || 0) + (anchor.height || (anchor.fontSize || 14) * 1.4) / 2
+      row.valueLeadSlice = trailingPool
+        .filter((el) => !claimed.has(el))
+        .filter((el) => {
+          const er = rect(el)
+          const iconCenter = (er.y || 0) + (er.height || 0) / 2
+          const gap = valueLeft - ((er.x || 0) + (er.width || 0))
+          return gap >= -2 && gap <= 40 && Math.abs(iconCenter - lineCenter) <= 14
+        })
+        .sort((a, b) => (rect(b).x || 0) - (rect(a).x || 0))[0] || null
+      if (row.valueLeadSlice) claimed.add(row.valueLeadSlice)
+    }
+  }
+
+  // Symbol 组件实例是可见媒体：用包含关系剔除外壳后，剩余实例按同行文本聚成媒体行。
+  const containsRect = (outer, inner, tolerance = 2) => {
+    const o = rect(outer)
+    const n = rect(inner)
+    return (o.x || 0) - tolerance <= (n.x || 0)
+      && (o.y || 0) - tolerance <= (n.y || 0)
+      && ((o.x || 0) + (o.width || 0)) + tolerance >= ((n.x || 0) + (n.width || 0))
+      && ((o.y || 0) + (o.height || 0)) + tolerance >= ((n.y || 0) + (n.height || 0))
+  }
+  const overlapRatio = (a, b) => {
+    const ar = rect(a); const br = rect(b)
+    const width = Math.min((ar.x || 0) + (ar.width || 0), (br.x || 0) + (br.width || 0))
+      - Math.max(ar.x || 0, br.x || 0)
+    const height = Math.min((ar.y || 0) + (ar.height || 0), (br.y || 0) + (br.height || 0))
+      - Math.max(ar.y || 0, br.y || 0)
+    if (width <= 0 || height <= 0) return 0
+    return (width * height) / Math.min((ar.width || 1) * (ar.height || 1), (br.width || 1) * (br.height || 1))
+  }
+  // 覆盖率：交集占 outer 面积的比例。用于判断"inner 是否几乎占满 outer"（outer 是 inner 的壳），
+  // 与 overlapRatio 的 min 面积归一不同——小元素落在大壳内时覆盖率低，不会误杀壳候选。
+  const coverRatio = (outer, inner) => {
+    const ar = rect(outer); const br = rect(inner)
+    const width = Math.min((ar.x || 0) + (ar.width || 0), (br.x || 0) + (br.width || 0))
+      - Math.max(ar.x || 0, br.x || 0)
+    const height = Math.min((ar.y || 0) + (ar.height || 0), (br.y || 0) + (br.height || 0))
+      - Math.max(ar.y || 0, br.y || 0)
+    if (width <= 0 || height <= 0) return 0
+    return (width * height) / ((ar.width || 1) * (ar.height || 1))
+  }
+  const leafSymbols = symbols.filter((symbol) =>
+    !symbols.some((other) => other !== symbol && containsRect(symbol, other)))
+  const mediaCardWidth = rect(card).width || (spec.size && spec.size.width) || 375
+  // 与选项/面板壳同位的 symbol 是同一视觉的重复标注（如 pill 同时存在 symbol 实例和矩形壳），
+  // 不剔除会双份渲染（symbol 占位图 + 选项按钮叠在一起）。
+  const shellCovered = (el) => [...optionShapeSet].some((s) => overlapRatio(el, s) > 0.6)
+  // 行壳重复标注：symbol 与同矩形带填充 shape 共存（shape 承载填充色）→ symbol 侧不得进媒体行，
+  // 否则行内容被占位图认领、列表识别被打散（交易行曾裂成「静态行 + 单行列表」）。
+  const shapeShellDup = (el) => {
+    const er = rect(el)
+    return shapes.some((sh) => Math.abs((rect(sh).x || 0) - (er.x || 0)) <= 2
+      && Math.abs((rect(sh).y || 0) - (er.y || 0)) <= 2
+      && Math.abs((rect(sh).width || 0) - (er.width || 0)) <= 2 && Math.abs((rect(sh).height || 0) - (er.height || 0)) <= 2)
+  }
+  const symbolMediaRows = leafSymbols.filter((symbol) =>
+    !shellCovered(symbol) && !shapeShellDup(symbol) &&
+    !buttonShapes.some((button) => overlapRatio(symbol, button) > 0.5) && !(() => {
+      const sr = rect(symbol)
+      return (sr.width || 0) >= mediaCardWidth * 0.8 && (sr.height || 0) >= 100
+    })()).map((symbol) => {
+    const shell = symbols.find((other) => other !== symbol && containsRect(other, symbol)) || symbol
+    const shellRect = rect(shell)
+    const sr = rect(symbol)
+    const symbolBottom = (sr.y || 0) + (sr.height || 0)
+    const paired = texts.filter((t) => {
+      const tr = rect(t)
+      const center = (tr.y || 0) + (tr.height || 0) / 2
+      return (tr.x || 0) >= ((sr.x || 0) + (sr.width || 0) * 0.35)
+      && center >= (sr.y || 0) - 6 && center <= symbolBottom + 6
+      && !formConsumed.has(t)
+      && !buttons.some((button) => button.text === textOf(t))
+    }).sort((a, b) => (rect(a).y || 0) - (rect(b).y || 0))
+    paired.forEach((t) => formConsumed.add(t))
+    const annotatedGaps = paired
+      .map((text) => (rect(text).x || 0) - ((sr.x || 0) + (sr.width || 0)))
+      .filter((gap) => Number.isFinite(gap) && gap >= 0)
+    return {
+      symbolEl: symbol,
+      x: sr.x || 0,
+      y: shellRect.y || sr.y || 0,
+      width: sr.width || 0,
+      height: shellRect.height || sr.height || 0,
+      texts: paired.map((t) => ({
+        text: textOf(t),
+        color: ts(t).color,
+        fontSize: ts(t).fontSize,
+        fontWeight: ts(t).fontWeight,
+        align: ts(t).textAlign,
+        y: rect(t).y || 0,
+        x: rect(t).x || 0,
+        width: rect(t).width || 0,
+        sourceEl: t,
+      })),
+      gap: annotatedGaps.length ? Math.min(...annotatedGaps) : null,
+    }
+  }).filter((row) => row.width > 0 && row.height > 0 && row.texts.length > 0)
+    .sort((a, b) => a.y - b.y)
+  const symbolMediaConsumed = new Set(symbolMediaRows.flatMap((row) =>
+    (row.texts || []).map((text) => text.sourceEl)).filter(Boolean))
+
+  // —— 进度/占比条：同 y 的长轨道 + 一段或多段短填充。 ——
+  // 只用宽度、高度、包含关系等几何信号；分隔线通常等宽且高度极小，不会形成长短对。
+  const layoutCardWidth = rect(card).width || (spec.size && spec.size.width) || 375
+  const barShapes = shapes.filter((shape) => {
+    const sr = rect(shape)
+    return (sr.height || 0) > 0 && (sr.height || 0) <= 8 &&
+      (sr.width || 0) >= 40 && (sr.width || 0) < layoutCardWidth * 0.98
+  })
+  const progressBars = []
+  for (const track of barShapes) {
+    const tr = rect(track)
+    const trackRight = (tr.x || 0) + (tr.width || 0)
+    const fills = barShapes.filter((shape) => {
+      const sr = rect(shape)
+      if (shape === track || (sr.width || 0) >= (tr.width || 0) * 0.95) return false
+      return Math.abs((sr.y || 0) - (tr.y || 0)) <= 2
+        && Math.abs((sr.height || 0) - (tr.height || 0)) <= 4
+        && (sr.x || 0) >= (tr.x || 0) - 2
+        && ((sr.x || 0) + (sr.width || 0)) <= trackRight + 2
+    }).sort((a, b) => (rect(a).x || 0) - (rect(b).x || 0))
+    if (!fills.length) continue
+    progressBars.push({
+      x: tr.x || 0,
+      y: tr.y || 0,
+      width: tr.width || 0,
+      height: tr.height || 0,
+      trackColor: track.style?.fill?.color,
+      trackEl: track,
+      segmentEls: fills,
+      segments: fills.map((fill) => ({
+        ratio: Math.min(1, Math.max(0, (rect(fill).width || 0) / (tr.width || 1))),
+        color: fill.style?.fill?.color || track.style?.fill?.color,
+      })),
+    })
+  }
+  // 无轨道多段拼接条（如 蓝段+黄段 相邻平铺的比例条）：同 y 同高、横向相邻(≤8px)的
+  // bar 形组以「首左沿→末右沿」为轨道合成多段进度条；否则两段被当孤立色块丢弃。
+  const usedBarEls = new Set()
+  for (const bar of progressBars) {
+    if (bar.trackEl) usedBarEls.add(bar.trackEl)
+    for (const el of (bar.segmentEls || [])) usedBarEls.add(el)
+  }
+  const freeBarShapes = barShapes.filter((shape) => !usedBarEls.has(shape))
+    .sort((a, b) => (rect(a).x || 0) - (rect(b).x || 0))
+  const tiledGroups = []
+  for (const shape of freeBarShapes) {
+    const sr = rect(shape)
+    const group = tiledGroups.find((gg) => Math.abs((gg.y || 0) - (sr.y || 0)) <= 2
+      && Math.abs((gg.h || 0) - (sr.height || 0)) <= 2
+      && (sr.x || 0) - (gg.right || 0) <= 8 && (sr.x || 0) >= (gg.right || 0) - 2)
+    if (group) {
+      group.members.push(shape)
+      group.right = Math.max(group.right, (sr.x || 0) + (sr.width || 0))
+    } else {
+      tiledGroups.push({ y: sr.y || 0, h: sr.height || 0, x: sr.x || 0,
+        right: (sr.x || 0) + (sr.width || 0), members: [shape] })
+    }
+  }
+  for (const group of tiledGroups) {
+    if (group.members.length < 2) continue
+    const span = group.right - group.x
+    if (span < layoutCardWidth * 0.4) continue
+    progressBars.push({
+      x: group.x,
+      y: group.y,
+      width: span,
+      height: group.h,
+      trackColor: null,
+      segments: group.members.map((member) => ({
+        ratio: Math.min(1, Math.max(0, (rect(member).width || 0) / (span || 1))),
+        color: member.style?.fill?.color || null,
+      })),
+    })
+  }
+
+  // —— 内嵌面板行：外层卡内的几何壳（列表项/入口卡/选择行）必须作为整体渲染。 ——
+  // 判定只依赖：宽壳 + 圆角 + 内部堆叠文本 + 可选左右媒体；不识别业务文案。
+  const cardWidth = (spec.size && spec.size.width) || rect(card).width || 375
+  const cardHeight = rect(card).height || (spec.size && spec.size.height) || 600
+  const subAmountElements = subAmounts.flatMap((item) => [item.labelEl, item.valueEl, item.symbolEl]).filter(Boolean)
+  const subAmountElementSet = new Set(subAmountElements)
+  const panelTextConsumed = new Set()
+  const panelCandidates = shapes
+    .filter((shape) => {
+      const sr = rect(shape)
+      const radius = radiusMax(shape.style)
+      const ownsPrimaryAmount = !!primaryAmountEl && overlapRatio(primaryAmountEl, shape) > 0.8
+      const sameFillAsCard = card.cardFill
+        && String(shape.style?.fill?.color || '').toUpperCase() === String(card.cardFill).toUpperCase()
+      // 排除卡片自身底壳：接近全卡尺寸的 shape 是卡片背景（标题/选项都是它的"内容"），
+      // 误当面板会把整卡文本吞成普通行，与选项组/表单重复渲染（曾双份渲染标题+选项）。
+      const coversCard = sr.width >= (rect(card).width || cardWidth) * 0.98 && sr.height >= cardHeight * 0.9
+      // 复合行模式：壳内含重复波段（标签+值行）→ 是列表行容器/卡头壳，不是信息面板
+      const containsRepeatBand = repeatRowMode && _repeatBandTops.some((bt) =>
+        bt >= (sr.y || 0) - 2 && bt <= (sr.y || 0) + (sr.height || 0) + 2)
+      return !coversCard && !containsRepeatBand
+        && sr.width >= cardWidth * 0.6 && sr.height <= Math.max(200, cardHeight * 0.5) && radius >= 6
+        // 入口/链接行（高 36-50）：单条左齐文本 + 右端小亲和件（箭头/勾选切片或矢量形）。
+        // 高度下限原为 50，44px 白底入口行全部漏判 → 整行底色+文本丢失（像素热区整带）。
+        && (sr.height >= 50 || (sr.height >= 36 && (() => {
+          const innerTexts = texts.filter((t2) => {
+            const tr2 = rect(t2)
+            return (tr2.x || 0) >= (sr.x || 0) - 2 && (tr2.y || 0) >= (sr.y || 0) - 2
+              && ((tr2.x || 0) + (tr2.width || 0)) <= (sr.x || 0) + (sr.width || 0) + 2
+              && ((tr2.y || 0) + (tr2.height || 0)) <= (sr.y || 0) + (sr.height || 0) + 2
+          })
+          if (innerTexts.length !== 1) return false
+          const tr2 = rect(innerTexts[0])
+          const leftAligned = ((tr2.x || 0) - (sr.x || 0)) <= (sr.width || 0) * 0.15
+          const affordance = [...shapes, ...(slices || [])].some((e2) => {
+            if (e2 === shape) return false
+            const er2 = rect(e2)
+            const ew = er2.width || 0
+            const eh = er2.height || 0
+            if (ew < 4 || ew > 32 || eh < 4 || eh > 32) return false
+            return (er2.x || 0) + ew >= (sr.x || 0) + (sr.width || 0) - 28
+              && Math.abs(((er2.y || 0) + eh / 2) - ((sr.y || 0) + (sr.height || 0) / 2)) <= (sr.height || 0) / 2
+          })
+          return leftAligned && affordance
+        })()))
+        && !(ownsPrimaryAmount && sameFillAsCard)
+        && !buttonShapes.some((button) => {
+          // 主尺寸按钮（w>=80，CTA/主操作）：壳整体含按钮 → 复合容器（产品卡/CTA 块），
+          // 交还 主按钮/渐变容器 专用路径（min 面积归一，原语义）；小 pill 是行内操作件，
+          // 落在壳内不排除壳（覆盖率归一，[媒体|文本栈|pill] 复合行仍是面板）。
+          // 壳自身落进 buttonShapes（形状级）但未成为按钮（文本非居中，如入口行）时，不得自排除：
+          // 否则入口行壳永远进不了 panelRows，整行底色+文本丢失。
+          if (button === shape) return false
+          const isPrimarySized = (rect(button).width || 0) >= 80
+          return isPrimarySized ? overlapRatio(shape, button) > 0.5 : coverRatio(shape, button) > 0.5
+        })
+        && !symbolMediaRows.some((row) => coverRatio(shape, row.symbolEl) > 0.5)
+    })
+  const panelShapes = panelCandidates.filter((shape) =>
+    // 面板组壳已由面板列表模板接管（panelGroup → ListLayout）；panelRows 再认领同一批壳
+    // 会把列表行再静态渲染一遍（v6 产品 tile 重影，duplicate-content ×23）。与 gradientPanels
+    // 的 _panelGroupShellSet 排除同族。
+    !_panelGroupShellSet.has(shape) &&
+    !panelCandidates.some((other) => other !== shape && containsRect(shape, other)))
+  const panelRows = panelShapes
+    .map((shape) => {
+      const sr = rect(shape)
+      const right = (sr.x || 0) + (sr.width || 0)
+      const bottom = (sr.y || 0) + (sr.height || 0)
+      const inside = (e) => {
+        const er = rect(e)
+        return (er.x || 0) >= (sr.x || 0) - 2 && (er.y || 0) >= (sr.y || 0) - 2
+          && ((er.x || 0) + (er.width || 0)) <= right + 2
+          && ((er.y || 0) + (er.height || 0)) <= bottom + 2
+      }
+      const buttonTextEls = new Set(buttons.map((button) => button.sourceEl).filter(Boolean))
+      const paired = texts.filter((text) => !symbolMediaConsumed.has(text) && !(subAmountElementSet.has(text) && !inside(text))
+        && !optionTextSet.has(text) && !optionLabelSet.has(text)
+        && !buttonTextEls.has(text)).filter(inside).sort((a, b) =>
+        (rect(a).y || 0) - (rect(b).y || 0) || (rect(a).x || 0) - (rect(b).x || 0))
+      // 段落壳归富文本通道：壳内含 richBlock 碎片/容器时 panelRows 再认领会把段落链接行
+      // （查看详细建议）抢成面板行插到段落之前，DOM 顺序颠倒且灰底壳重复归属。
+      const richInside = (richBlocks || []).some((blk) => inside(blk.container)
+        || (blk.fragments || []).some((frag) => inside(frag)))
+      if (!paired.length || richInside) return null
+      const overlapsExisting = paired.some((t) => {
+        const value = textOf(t)
+        return subAmounts.some((item) => item.label === value || item.value === value)
+          || formRows.some((row) => row.label?.text === value
+            || row.value?.text === value
+          || (row.subValues || []).some((sub) => sub.text === value))
+      })
+      const panelSlices = [...slices, ...symbols.filter((sy) =>
+        !symbolMediaRows.some((row) => row.symbolEl === sy))].filter(inside)
+      const firstText = paired[0]
+      const lastText = paired[paired.length - 1]
+      const leftMedia = panelSlices.find((s) => (rect(s).x || 0) < (rect(firstText).x || 0)) || null
+      const rightMedia = panelSlices.find((s) => (rect(s).x || 0) > ((rect(lastText).x || 0) + (rect(lastText).width || 0))) || null
+      // 几何强度：多行文本栈（>=4 文本），或 >=2 文本 + 壳内有媒体/按钮佐证。
+      // 后者覆盖 [媒体|文本栈|操作件] 复合行——壳、媒体、按钮都是几何证据，
+      // 不能因文本被 formRow 先行认领就放弃面板（否则右操作件被甩出面板竖排）。
+      const containsButton = buttons.some((b) => inside({ rect: b.rect || b }))
+      // 放宽分支只认领「单行复合行」：无渐变（渐变壳由 gradientPanels 专用路径接管，
+      // 抢过来会把 名称+口号+金额+按钮 的多块结构压成普通面板）、高度像行（<=120px）。
+      const isGradientShell = !!shape.style?.fill?.gradient
+      const rowLikeShell = (sr.height || 0) <= 120
+      // 与卡同色的壳不是视觉面板（多是卡身背景延续，如白底白壳底部圆角补片）。
+      // 仅当它是「单行复合行」（高度像行、壳内切片全部可作左右媒体）才按面板组织；
+      // 多块内容（图标+文本多行、名称+金额+按钮）走面板会丢行内图标并压平布局。
+      const sameFillShell = card.cardFill
+        && String(shape.style?.fill?.color || '').toUpperCase() === String(card.cardFill).toUpperCase()
+      // 只有「贴满卡左右缘」的同色壳才是卡身延续嫌疑；内缩壳（行卡/选项行）即使同色也是真实面板。
+      const cardRx = rect(card).x || 0
+      const fullWidthShell = Math.abs((sr.x || 0) - cardRx) <= 2
+        && Math.abs((sr.width || 0) - (rect(card).width || 0)) <= 4
+      if (sameFillShell && fullWidthShell) {
+        const mediaSet = new Set([leftMedia, rightMedia].filter(Boolean))
+        const innerSlicesSimple = panelSlices.every((s) => mediaSet.has(s))
+        if (!(rowLikeShell && innerSlicesSimple)) return null
+      }
+      const strongPanel = new Set(paired.map((text) => Math.round((rect(text).y || 0) / 8))).size >= 2
+        && (paired.length >= 4
+          || (paired.length >= 2 && !isGradientShell && rowLikeShell && (leftMedia || rightMedia || containsButton)))
+      if (overlapsExisting && !strongPanel) return null
+      // 通过全部准入门槛后才消费文本：提前消费会让被拒壳内的文本既不渲染又被标记（丢失）。
+      paired.forEach((t) => {
+        formConsumed.add(t)
+        panelTextConsumed.add(t)
+      })
+      const contentLeft = Math.min(...[leftMedia, ...paired].filter(Boolean).map((e) => rect(e).x || 0))
+      const contentRight = Math.max(...[rightMedia, ...paired].filter(Boolean).map((e) => (rect(e).x || 0) + (rect(e).width || 0)))
+      const contentTop = Math.min(...[leftMedia, ...paired].filter(Boolean).map((e) => rect(e).y || 0))
+      const contentBottom = Math.max(...[rightMedia, ...paired].filter(Boolean).map((e) => (rect(e).y || 0) + (rect(e).height || 0)))
+      const pairedSet = new Set(paired)
+      const nextOverlappingTop = Math.min(...[...texts, ...slices, ...symbols]
+        .filter((element) => !pairedSet.has(element))
+        .map((element) => rect(element).y || Number.POSITIVE_INFINITY)
+        .filter((top) => top > (sr.y || 0) + 2 && top < bottom - 2))
+      const overlapTolerance = Math.max(16, (sr.height || 0) * 0.25)
+      const flowBottom = Number.isFinite(nextOverlappingTop)
+        && nextOverlappingTop >= bottom - overlapTolerance
+          ? Math.min(bottom, nextOverlappingTop)
+          : bottom
+      const flowHeight = Math.max(0, Math.round(flowBottom - (sr.y || 0)))
+      return {
+        shapeEl: shape,
+        y: sr.y || 0,
+        x: sr.x || 0,
+        width: sr.width || 0,
+        height: flowHeight,
+        fill: shape.style?.fill?.color || null,
+        gradient: shape.style?.fill?.gradient || null,
+        opacity: shape.style?.opacity ?? 1,
+        radius: radiusMax(shape.style),
+        leftSlice: leftMedia,
+        rightSlice: rightMedia,
+        sourceEls: paired,
+        texts: paired.map((t) => ({
+          text: textOf(t),
+          color: ts(t).color,
+          fontSize: ts(t).fontSize,
+          fontWeight: ts(t).fontWeight,
+          align: ts(t).textAlign,
+          x: rect(t).x || 0,
+          width: rect(t).width || 0,
+          y: rect(t).y || 0,
+          height: rect(t).height || (ts(t).fontSize || 14) * 1.4,
+        })),
+        paddingLeft: Math.max(0, Math.round(contentLeft - (sr.x || 0))),
+        paddingRight: Math.max(0, Math.round(right - contentRight)),
+        paddingTop: Math.max(0, Math.round(contentTop - (sr.y || 0))),
+        paddingBottom: Math.max(0, Math.round(flowBottom - contentBottom)),
+      }
+    })
+    .filter(Boolean).sort((a, b) => a.y - b.y)
+
+  const panelOwnedTexts = new Set(panelRows.flatMap((row) =>
+    (row.sourceEls || []).map((element) => textOf(element))))
+  for (let rowIndex = formRows.length - 1; rowIndex >= 0; rowIndex -= 1) {
+    const row = formRows[rowIndex]
+    const owned = [row.label?.text, row.value?.text, ...(row.subValues || []).map((item) => item.text)]
+      .filter(Boolean)
+    if (owned.some((text) => panelOwnedTexts.has(text))) formRows.splice(rowIndex, 1)
+  }
+
+  // 面板右侧操作件挂接：未消费按钮整体落在面板内、且中心在面板文本右缘之外 → 面板 rightAction。
+  // 按钮独立成行会被甩到面板之下（曾致 [logo|文本栈|修改] 媒体行竖向散架、位置分 0.76）。
+  for (let bi = buttons.length - 1; bi >= 0; bi -= 1) {
+    const btn = buttons[bi]
+    const btnCx = (btn.x || 0) + (btn.width || 0) / 2
+    const btnCy = (btn.y || 0) + (btn.height || 0) / 2
+    const panel = panelRows.find((row) => {
+      const textsRight = Math.max(0, ...(row.texts || []).map((t) => (t.x || 0) + (t.width || 0)))
+      return btnCx > textsRight
+        && btnCx >= (row.x || 0) && btnCx <= (row.x || 0) + (row.width || 0)
+        && btnCy >= (row.y || 0) - 4 && btnCy <= (row.y || 0) + (row.height || 0) + 4
+    })
+    if (!panel) continue
+    panel.rightActionButton = btn
+    // 按钮文本随按钮入面板一并消费：按钮已从 buttons 摘除，postAmountTexts 的
+    // buttons 排除随之失效，不标记会把按钮文案再渲染成游离辅助文本（重影）。
+    if (btn.sourceEl) formConsumed.add(btn.sourceEl)
+    // 右 padding 按按钮右缘重算（按钮入面板，contentRight 覆盖到按钮右沿）
+    panel.paddingRight = Math.max(0, Math.round(
+      ((panel.x || 0) + (panel.width || 0)) - ((btn.x || 0) + (btn.width || 0))))
+    buttons.splice(bi, 1)
+  }
+
+  // 面板夺走的文本从 midCluster 剔除：簇与面板壳同区时两条路径会双份渲染同一文本（重影）。
+  if (midCluster && panelOwnedTexts.size) {
+    midCluster.items = (midCluster.items || []).filter((it) => !panelOwnedTexts.has(it.text))
+  }
+
+  // 副金额组常被外层浅色面板包裹；该壳属于组件结构，不能因文本已被金额语义消费而丢弃。
+  const subAmountPanelShape = panelShapes.find((shape) => subAmountElements.length >= 4
+    && subAmountElements.every((element) => overlapRatio(element, shape) > 0.8)) || null
+  const subAmountPanel = (() => {
+    if (!subAmountPanelShape) return null
+    const sr = rect(subAmountPanelShape)
+    const right = (sr.x || 0) + (sr.width || 0)
+    const bottom = (sr.y || 0) + (sr.height || 0)
+    const left = Math.min(...subAmountElements.map((element) => rect(element).x || 0))
+    const contentRight = Math.max(...subAmountElements.map((element) =>
+      (rect(element).x || 0) + (rect(element).width || 0)))
+    const top = Math.min(...subAmountElements.map((element) => rect(element).y || 0))
+    const contentBottom = Math.max(...subAmountElements.map((element) =>
+      (rect(element).y || 0) + (rect(element).height || 0)))
+    return {
+      y: sr.y || 0,
+      x: sr.x || 0,
+      width: sr.width || 0,
+      height: sr.height || 0,
+      fill: subAmountPanelShape.style?.fill?.color || null,
+      radius: subAmountPanelShape.style?.radius?.borderRadius || 0,
+      paddingTop: Math.max(0, Math.round(top - (sr.y || 0))),
+      paddingBottom: Math.max(0, Math.round(bottom - contentBottom)),
+      paddingLeft: Math.max(0, Math.round(left - (sr.x || 0))),
+      paddingRight: Math.max(0, Math.round(right - contentRight)),
+    }
+  })()
+
+  for (let rowIndex = formRows.length - 1; rowIndex >= 0; rowIndex -= 1) {
+    const row = formRows[rowIndex]
+    const rowEls = [row.labelEl, row.valueEl, ...(row.subEls || [])]
+    if (rowEls.some((el) => el && subAmountEls.has(el))) formRows.splice(rowIndex, 1)
+  }
+
+  // —— 孤立媒体/图形块：无文本配对、不属于按钮/面板/进度条的可见切片或几何图标。 ——
+  // 缺失导出时用近似纯色占位；这属于设计稿标注缺陷的降级，而不是丢弃用户可见结构。
+  const progressShapes = progressBars.flatMap((bar) => [])
+  const formSliceEls = new Set((formRows || []).flatMap((row) => [row.rightAffordanceSlice, row.leftIconSlice, row.trailingIconSlice, row.valueLeadSlice]).filter(Boolean))
+  const auxSliceEls = new Set([
+    ...auxTexts.map((aux) => aux.decoSliceEl),
+    ...auxTexts.map((aux) => aux.sliceEl),
+    // 副金额列标签后缀图标（如币种选择器箭头）：随标签行渲染，不得落入孤立媒体块
+    ...subAmounts.map((sub) => sub.labelSuffixSlice),
+  ].filter(Boolean))
+  const primaryIconEl = primaryAmount?.iconSlice || null
+  const cardRectForAffordance = rect(card)
+  const affordanceCardRight = (cardRectForAffordance.x || 0) + (cardRectForAffordance.width || 0)
+  const affordanceCandidates = [...slices, ...leafSymbols].filter((element) => {
+    const er = rect(element)
+    const width = er.width || 0
+    const height = er.height || 0
+    return width >= 16 && width <= 40 && height >= 16 && height <= 40
+      && (er.x || 0) + width >= affordanceCardRight - Math.max(32, width * 2)
+  })
+  const affordanceGroups = new Map()
+  for (const element of affordanceCandidates) {
+    const er = rect(element)
+    const key = [er.x || 0, er.width || 0, er.height || 0].join(':')
+    if (!affordanceGroups.has(key)) affordanceGroups.set(key, [])
+    affordanceGroups.get(key).push(element)
+  }
+  const repeatedRightAffordanceEls = new Set()
+  for (const group of affordanceGroups.values()) {
+    const sorted = group.sort((a, b) => (rect(a).y || 0) - (rect(b).y || 0))
+    const gaps = sorted.slice(1).map((element, index) =>
+      (rect(element).y || 0) - (rect(sorted[index]).y || 0))
+    const repeated = sorted.length >= 2 && gaps.length && gaps.every((gap) =>
+      gap >= 40 && gap <= 140 && Math.abs(gap - gaps[0]) <= 4)
+    if (repeated) sorted.forEach((element) => repeatedRightAffordanceEls.add(element))
+  }
+  const semanticShapes = [...buttonShapes, ...panelShapes, ...progressShapes]
+  if (subAmountPanelShape) semanticShapes.push(subAmountPanelShape)
+  const hasInsideContent = (shape) => [...texts, ...slices, ...symbols]
+    .some((element) => overlapRatio(element, shape) > 0.5)
+  const isolatedBlocks = [...slices, ...leafSymbols, ...shapes]
+    .filter((el) => !(el.type === 'symbol' && shapeShellDup(el)))
+    .filter((element) => {
+      const er = rect(element)
+      const width = er.width || 0
+      const height = er.height || 0
+      if (width < 20 || height < 20 || width > 220 || height > 220) return false
+      if (Math.max(width, height) / Math.min(width, height) > 5) return false
+      if (semanticShapes.some((shape) => overlapRatio(element, shape) > 0.5)) return false
+      if (symbolMediaRows.some((row) => overlapRatio(element, row.symbolEl) > 0.5)) return false
+      if (element.type !== 'shape' && [...optionShapeSet, ...panelShapes].some((s) => overlapRatio(element, s) > 0.6)) return false
+      if (formSliceEls.has(element) || auxSliceEls.has(element) || element === primaryIconEl) return false
+      // midCluster 行内 logo 由 midCluster 行渲染接管，不得再作孤立媒体块单列渲染（重影）
+      if (midCluster && midCluster.logoSlice === element) return false
+      // 行尾重复 affordance 不再预排除：列表存在时由列表回收（itemMediaEls 之后），
+      // 无列表时挂到对齐语义行右侧渲染，避免「眼睛图标」等行尾控件静默丢失。
+      if (element.type === 'shape' && hasInsideContent(element)) return false
+      return true
+    })
+    .filter((element, index, list) => !list.some((other) =>
+      other !== element && element.type === other.type && containsRect(other, element)))
+    .map((element) => {
+      const er = rect(element)
+      return {
+        element,
+        x: er.x || 0,
+        y: er.y || 0,
+        width: er.width || 0,
+        height: er.height || 0,
+      }
+    })
+    .sort((a, b) => a.y - b.y || a.x - b.x)
+// 浮动装饰切片回收：isolatedBlocks 先于 orphanSlices 消费切片（卡头月亮等贴缘叠装饰），
+// 命中「与文本带竖直重叠 + 贴卡缘」者改走绝对定位叠层，不占流式行高。
+// Chart center media (radar/ring vector group): when vertexClusters exist,
+// pull it from isolatedBlocks into vertexClusters.chartMedia so assemble can
+// render both in the SAME AbsoluteLayout (shared coordinate system).
+if (vertexClusters && vertexClusters.length >= 3) {
+  const vcXs = vertexClusters.map((vc) => vc.x || 0)
+  const vcXRights = vertexClusters.map((vc, i) => (vc.x || 0) + (vc.width || 88))
+  const vcYs = vertexClusters.map((vc) => vc.y || 0)
+  const vcYBottoms = vertexClusters.map((vc, i) => (vc.y || 0) + (vc.height || 30))
+  const vcCx = (Math.min(...vcXs) + Math.max(...vcXRights)) / 2
+  const vcCy = (Math.min(...vcYs) + Math.max(...vcYBottoms)) / 2
+  for (let ib = isolatedBlocks.length - 1; ib >= 0; ib--) {
+    const blk = isolatedBlocks[ib]
+    const bw = blk.width || 0, bh = blk.height || 0
+    if (bw < 50 || bh < 50 || bw > 200 || bh > 200) continue
+    if (Math.abs(bw - bh) > 30) continue
+    const bcx = (blk.x || 0) + bw / 2
+    const bcy = (blk.y || 0) + bh / 2
+    if (Math.hypot(bcx - vcCx, bcy - vcCy) > 80) continue
+    vertexClusters.chartMedia = blk
+    isolatedBlocks.splice(ib, 1)
+    _vertexConsumedEls.add(blk.element)
+    break
+  }
+}
+
+const floatDecos = []
+{
+  const cRd = rect(card)
+  const isFloatDeco = (el) => {
+    const sr = rect(el)
+    const w = sr.width || 0, h = sr.height || 0
+    if (!w || !h || w > (cRd.width || 375) * 0.5) return false
+    const overlapsText = texts.some((t) => {
+      const tr = rect(t)
+      const ov = Math.min((sr.y || 0) + h, (tr.y || 0) + (tr.height || 0)) - Math.max(sr.y || 0, tr.y || 0)
+      return ov >= h * 0.2 && h >= (tr.height || 0) * 2.2
+    })
+    const edgeAnchored = ((sr.x || 0) + w) >= ((cRd.x || 0) + (cRd.width || 0)) - 24
+    return overlapsText && edgeAnchored
+  }
+  for (let k = isolatedBlocks.length - 1; k >= 0; k -= 1) {
+    const el = isolatedBlocks[k].element
+    if (el && (el.type === 'slice') && isFloatDeco(el)) {
+      floatDecos.push(el)
+      isolatedBlocks.splice(k, 1)
+    }
+  }
+}
+
+  // 面板/符号媒体行消费文本后，同步回收先生成的 auxTexts，避免同一标注被重复渲染
+  // （曾仅回收 panelTextConsumed：符号媒体行吞掉的文本又被 auxTexts 渲染一次 → 重影）。
+  for (let index = auxTexts.length - 1; index >= 0; index -= 1) {
+    if (panelTextConsumed.has(auxTexts[index].sourceEl) || symbolMediaConsumed.has(auxTexts[index].sourceEl)) auxTexts.splice(index, 1)
+  }
+
+  // —— 列表标题 ——
+  const buttonY = buttonShapes.length ? Math.max(...buttonShapes.map((s) => (rect(s).y || 0) + (rect(s).height || 0))) : 0
+  // 判定：标题尺寸 + **下方存在 ≥2 个未被表单消费的文本元素（真正列表行特征）**——
+  // 无列表的标题（状态卡"交易正在处理中"）或下方是表单行（反馈卡"还款成功"+字段行）不得误判为列表标题，
+  // 否则丢失 textAlign、挤压 postAmountTexts 上界且渲染位置错（标题应在上方而非表单/按钮后）。
+  const listTitleCands = texts.filter((t) => {
+    const y = rect(t).y || 0
+    const T = ts(t)
+    // 列表标题须在「内容区」（主视觉底沿之后）——不限于按钮下方（本卡列表在按钮上方：
+    // 列表项 464-666、按钮 723）。仅限制 y <= buttonY 会把按钮上方的列表识别全部排除。
+    if (y <= mainBottom || (T.fontSize || 0) < 15 || (T.fontSize || 0) > 18
+    || textOf(t).length > 8 || tabs.some((tab) => tab.value === textOf(t))) return false
+    if (optionTextSet.has(t) || optionLabelSet.has(t)) return false
+    if (buttons.some((button) => button.sourceEl === t)) return false
+    if (formConsumed.has(t) || panelTextConsumed.has(t)) return false
+    if (subAmountEls.has(t)) return false
+    if (_panelGroupMemberEls.has(t)) return false
+    // 复合行模式：行标题判定 = 候选下方 18-110px 有波段，且【另一文本】在相同相对距离(±4px)也有波段
+    // （行结构周期性重复）。卡标题（如「我的账户」距首波段 88px，无周期同伴）不受影响。
+    if (repeatRowMode) {
+      const dyBands = _repeatBandTops.filter((bt) => bt - y >= 18 && bt - y <= 110).map((bt) => bt - y)
+      const isRowTitle = dyBands.some((dy) => texts.some((o) => o !== t
+        && _repeatBandTops.some((bt2) => Math.abs((bt2 - (rect(o).y || 0)) - dy) <= 4)))
+      if (isRowTitle) return false
+    }
+    const belowUnconsumed = texts.filter((o) => o !== t && (rect(o).y || 0) > y + 20
+      && !formConsumed.has(o) && !panelTextConsumed.has(o)
+      && !subAmountEls.has(o))
+    // 复发护栏（对称版）：同一文案在内容区出现 ≥2 次（无论上下方），说明它是重复行内容
+    // 而非列表标题（名册卡「张三」×3：旧单向护栏漏掉最后一个张三 → 误当标题吞掉整个列表）。
+    if (_isRepeatedRowText(t)) return false
+    // 金额值不是列表标题：含货币符号或「数字+千分位/小数」的文本是行右金额/主金额，
+    // 误当标题会把真首行抬成 listTitle（首行 desc/amount 无人消费 → 绑定兜底双渲染重影）。
+    if (/\p{Sc}/u.test(textOf(t))) return false
+    if (/^[-+]?[\d.,\s%]+$/.test(textOf(t)) && /\.\d|,\d{3}/.test(textOf(t))) return false
+    // 周期行护栏（结构版）：候选下方存在 ≥2 个同列、同字号、同色且等距(±10)的同伴 →
+    // 它是重复行的行标题而非区块标题（交易列表首行被抬成标题会让列表少一行）。
+    // 双向护栏：上方+下方合计 ≥2 个同列、同字号、同色且等距(±12)同伴即判定为周期行
+    // （中间行仅有 1 上 1 下同伴，旧单向护栏漏判把它当标题 → 列表被拦腰截断）。
+    const titlePeersAll = texts.filter((o) => o !== t
+      && Math.abs((rect(o).x || 0) - (rect(t).x || 0)) <= 2
+      && (ts(o).fontSize || 0) === (T.fontSize || 0)
+      && String(ts(o).color || '').toLowerCase() === String(T.color || '').toLowerCase()
+      && Math.abs((rect(o).y || 0) - y) >= 20 && Math.abs((rect(o).y || 0) - y) <= 240)
+    if (titlePeersAll.length >= 2) {
+      // 步长投票：取最近同伴距离为候选步长，统计匹配该步长整数倍的同伴数；
+      // ≥2 个匹配即判周期行（非周期同伴如汇总标签混入不影响判定）。
+      const peerDys = titlePeersAll.map((o) => (rect(o).y || 0) - y).sort((a, b) => Math.abs(a) - Math.abs(b))
+      const candSteps = [...new Set([Math.abs(peerDys[0]), Math.abs(peerDys[1] || peerDys[0])])].filter((s) => s >= 20)
+      for (const candStep of candSteps) {
+        const matched = peerDys.filter((g) => {
+          const remainder = Math.abs(g) % candStep
+          return Math.min(remainder, candStep - remainder) <= 12
+        }).length
+        if (matched >= 2) return false
+      }
+    }
+    return belowUnconsumed.length >= 2
+  })
+  const listTitle = listTitleCands.length ? {
+    text: textOf(listTitleCands[0]),
+    color: ts(listTitleCands[0]).color,
+    fontSize: ts(listTitleCands[0]).fontSize,
+    fontWeight: ts(listTitleCands[0]).fontWeight,
+    align: ts(listTitleCands[0]).textAlign, // 必须保留：居中标题（center）在渲染时 respect
+    height: rect(listTitleCands[0]).height || (ts(listTitleCands[0]).fontSize || 16) * 1.4,
+    y: rect(listTitleCands[0]).y || 0,
+    x: rect(listTitleCands[0]).x || 0,
+    width: rect(listTitleCands[0]).width || 0,
+  } : null
+
+  // 列表标题优先于头部 auxText：同一元素被 listTitle 接管后从 auxTexts 移除，避免双渲染
+  if (listTitle) {
+    for (let ai = auxTexts.length - 1; ai >= 0; ai -= 1) {
+      if (auxTexts[ai].sourceEl === listTitleCands[0]) auxTexts.splice(ai, 1)
+    }
+  }
+
+  // —— 环形倒计时（同心圆环 + 中心大数字 + 单位短文本；纯几何/格式信号，泛化）——
+  // 识别信号（不依赖业务词）：
+  //   ① ≥2 个近似正方形（w≈h）的 shape 两两同心（中心距 <10px）→ 圆环组（外环/内环/进度弧）
+  //   ② 环中心 ±(半径+8) 内的独立数字文本（fontSize≥20，1-3 位纯数字）→ 倒计时数值
+  //   ③ 数字附近（±40x/±30y）的单位短文本（S/s/秒/分）→ 单位
+  // 命中后：数字/单位文本从常规渲染排除，改由 Canvas 自绘（环形进度 0%→100% 步进）。
+  const countdown = (() => {
+    const centerOf = (e) => { const r = rect(e); return { x: (r.x || 0) + (r.width || 0) / 2, y: (r.y || 0) + (r.height || 0) / 2 } }
+    const roundShapes = shapes.filter((s) => {
+      const r = rect(s)
+      const w = r.width || 0, h = r.height || 0
+      return w >= 24 && Math.abs(w - h) < 8
+    })
+    const clusters = []
+    const usedS = new Set()
+    for (let i = 0; i < roundShapes.length; i++) {
+      if (usedS.has(i)) continue
+      const c1 = centerOf(roundShapes[i])
+      const grp = [i]
+      usedS.add(i)
+      for (let j = i + 1; j < roundShapes.length; j++) {
+        if (usedS.has(j)) continue
+        const c2 = centerOf(roundShapes[j])
+        if (Math.abs(c1.x - c2.x) < 10 && Math.abs(c1.y - c2.y) < 10) { grp.push(j); usedS.add(j) }
+      }
+      if (grp.length >= 2) clusters.push(grp.map((g) => roundShapes[g]))
+    }
+    if (!clusters.length) return null
+    const ring = clusters[0]
+    const r0 = rect(ring[0])
+    const cx = (r0.x || 0) + (r0.width || 0) / 2
+    const cy = (r0.y || 0) + (r0.height || 0) / 2
+    const size = Math.max(r0.width || 0, r0.height || 0)
+    const half = size / 2 + 8
+    const numEl = texts.find((t) => {
+      const T = ts(t)
+      const r = rect(t)
+      const tx = textOf(t)
+      if ((T.fontSize || 0) < 20 || !/^\d{1,3}$/.test(tx)) return false
+      const tc = centerOf(t)
+      return Math.abs(tc.x - cx) < half && Math.abs(tc.y - cy) < half
+    })
+    if (!numEl) return null
+    const nr = rect(numEl)
+    const unitEl = texts.find((t) => t !== numEl && /^[Ss秒分]$/.test(textOf(t))
+      && Math.abs((rect(t).x || 0) - (nr.x || 0)) < 40 && Math.abs((rect(t).y || 0) - (nr.y || 0)) < 30)
+    // 环形配色：ring 中 border.color 非浅灰描边者 → 进度色；其余 → 背景环色；缺省兜底
+    const ringColors = ring.map((s) => { const b = (s.style || {}).border || {}; return b.isBorder ? String(b.color || '') : '' }).filter((c) => c && c.toUpperCase() !== '#F0F0F0')
+    const progressColor = ringColors[0] || '#00A46D'
+    const bgColor = (() => { const b = ((ring.find((s) => ((s.style || {}).border || {}).isBorder && String(((s.style || {}).border || {}).color || '').toUpperCase() === '#F0F0F0')) || {}).style || {}; const bc = (b.border || {}).color; return bc || '#E6F8F0' })()
+    // 环形线宽：取描边 shape 的 border.width（设计稿环通常 1-2px）；缺省按直径 1.5% 兜底
+    const strokeWidth = (() => {
+      const ws = ring.map((s) => { const b = (s.style || {}).border || {}; return b.isBorder ? (Number(b.width) || 0) : 0 }).filter((w) => w > 0)
+      return (ws.length ? Math.min(...ws) : Math.max(2, Math.round(size * 0.025)))
+    })()
+    return {
+      size: Math.round(size),
+      y: r0.y || 0,
+      strokeWidth,
+      numberText: textOf(numEl),
+      unitText: unitEl ? textOf(unitEl) : 'S',
+      color: ts(numEl).color || '#06AB67',
+      unitColor: unitEl ? (ts(unitEl).color || '#999999') : '#999999',
+      progressColor,
+      bgColor,
+      consumed: [numEl, unitEl].filter(Boolean),
+    }
+  })()
+  const countdownConsumed = new Set((countdown && countdown.consumed) || [])
+
+  // —— 卡片顶部位图装饰层：优先消费上游 segments，否则按素材类型与几何聚类识别。
+  // 位图装饰不可用基础组件复现；必须引用已导出素材，缺失时先画板裁切、再占位图。
+  // 全卡渐变形是卡片背景本身，不属于局部装饰层；映射为 CSS 渐变可避免
+  // 固定高度内容容器裁切下方内容，也能保留标注给出的颜色过渡。
+  const fullCardGradientShape = (card.elements || []).find((element) => {
+    const shapeRect = rect(element)
+    const cardRect = rect(card)
+    const coverageX = Math.min((shapeRect.x || 0) + (shapeRect.width || 0),
+      (cardRect.x || 0) + (cardRect.width || 0)) - Math.max(shapeRect.x || 0, cardRect.x || 0)
+    const coverageY = Math.min((shapeRect.y || 0) + (shapeRect.height || 0),
+      (cardRect.y || 0) + (cardRect.height || 0)) - Math.max(shapeRect.y || 0, cardRect.y || 0)
+    return element.type === 'shape'
+      && !!element.style?.fill?.gradient
+      && coverageX >= (cardRect.width || 0) * 0.9
+      && coverageY >= (cardRect.height || 0) * 0.9
+  }) || null
+  // —— 渐变背景壳（非全卡）：局部渐变色块（如营销卡奶油色渐变区）。 ——
+  // 只作背景包裹，不吞内容：壳内文本/按钮仍由各自语义路径生成（panelRows 路径会丢金额绑定、重复按钮）。
+  const gradientPanels = (card.elements || []).filter((element) => {
+    if (element.type !== 'shape' || !element.style?.fill?.gradient) return false
+    if (_panelGroupShellSet.has(element)) return false // 面板组壳由面板列表接管
+    if (element === fullCardGradientShape) return false
+    const sr = rect(element)
+    const cR = rect(card)
+    const w = sr.width || 0, h = sr.height || 0
+    if (w < (cR.width || 0) * 0.6 || h < 40 || h > (cR.height || 0) * 0.75) return false
+    if ((sr.y || 0) < (cR.y || 0) - 2) return false // 顶部装饰归 topDecoration
+    // 排除「自身就是按钮」的渐变块（壳可以含按钮，但不能是按钮）
+    const area = w * h
+    if (buttonShapes.some((button) => overlapRatio(element, button) > 0.5
+      && area <= 4 * (rect(button).width || 0) * (rect(button).height || 0))) return false
+    return true
+  }).map((shape) => {
+    const sr = rect(shape)
+    return {
+      shapeEl: shape,
+      x: sr.x || 0, y: sr.y || 0, width: sr.width || 0, height: sr.height || 0,
+      gradient: shape.style?.fill?.gradient || null,
+      opacity: shape.style?.opacity ?? 1,
+      radius: shape.style?.radius?.borderRadius || 12,
+    }
+  })
+
+  const topRhythm = (decorationRect, iconSlice) => {
+    if (!iconSlice || !decorationRect) return {}
+    const iconRect = rect(iconSlice)
+    const iconBottom = (iconRect.y || 0) + (iconRect.height || 0)
+    const decorationBottom = (decorationRect.y || 0) + (decorationRect.height || 0)
+    const caption = (card.elements || []).filter((element) => {
+      const textRect = rect(element)
+      const center = (textRect.y || 0) + (textRect.height || 0) / 2
+      return !!textOf(element) && center >= iconBottom && center <= decorationBottom + 40
+    }).sort((left, right) => (rect(left).y || 0) - (rect(right).y || 0))[0]
+    if (!caption) return { iconTop: (iconRect.y || 0) - (decorationRect.y || 0) }
+    const captionRect = rect(caption)
+    return {
+      iconTop: (iconRect.y || 0) - (decorationRect.y || 0),
+      textGap: (captionRect.y || 0) - iconBottom,
+    }
+  }
+  // 顶部半透明大椭圆装饰（弥散底色）：采样硬停色带是矩形平涂，还原不出椭圆曲边，
+  // 像素热带集中在带底沿（实测 y≈106 单带 32%）→ 记 radial-gradient 参数逐颗还原。
+  const topTintBlobs = (() => {
+    const cR = rect(card)
+    return shapes.filter((shape) => {
+      const sr = rect(shape)
+      const opacity = Number(shape.style?.opacity ?? 1)
+      return opacity > 0 && opacity <= 0.5
+        && (sr.width || 0) >= (cR.width || 0) * 0.4 && (sr.height || 0) >= (cR.height || 0) * 0.4
+        && (sr.y || 0) <= (cR.y || 0) + 4
+        && !radiusMax(shape.style)
+    }).map((shape) => {
+      const sr = rect(shape)
+      return {
+        cx: Math.round((sr.x || 0) + (sr.width || 0) / 2 - (cR.x || 0)),
+        cy: Math.round((sr.y || 0) + (sr.height || 0) / 2 - (cR.y || 0)),
+        rx: Math.round((sr.width || 0) / 2),
+        ry: Math.round((sr.height || 0) / 2),
+        // 不透明卡身壳罩在色块之上（磨砂玻璃壳）：设计稿里色块被白壳罩淡一层，
+        // 直接按标注 alpha 平涂会过浓（实测像素差 +5.6pp）→ 罩淡系数 0.5 校准。
+        rgba: hexToRgba(shape.style?.fill?.color || '#FFFFFF', Number(shape.style?.opacity ?? 1) * 0.5),
+      }
+    })
+  })()
+  const topDecoration = (() => {
+    const cr = rect(card)
+    const cardTop = cr.y || 0
+    const cardW = cr.width || 375
+    // ① 上游 segments 优先：decor-bg 且 y（卡内）≤30
+    const segs = (card.segments || [])
+    const bgSeg = segs.find((s) => s.hint === 'decor-bg' && (s.y || 0) <= 30)
+    if (bgSeg) {
+      const absY = cardTop + (bgSeg.y || 0)
+      const sliceEl = (card.elements || []).find((x) => x.type === 'slice'
+        && Math.abs((rect(x).y || 0) - absY) < 25 && (rect(x).width || 0) >= cardW * 0.8) || null
+      const cardH = cr.height || 400
+      const iconSlice = (card.elements || []).find((x) => x.type === 'slice'
+        && (() => { const r = rect(x); const w = r.width || 0, h = r.height || 0
+          return w >= 40 && w <= 130 && h >= 40 && h <= 130 && Math.abs(w - h) <= 30
+            && (r.y || 0) >= (cr.y || 0) && (r.y || 0) < (cr.y || 0) + cardH * 0.45 })()) || null
+      // 无切片时按「首个内容文本在带内垂直居中」估算带高（居中假设：上下 padding 对称），
+      // 避免 140 回退高把后续内容的顶距全吞掉（带边界会盖住列表标题/首行）。
+      const firstContent = texts
+        .filter((t) => (rect(t).y || 0) >= absY - 4)
+        .sort((ta, tb) => (rect(ta).y || 0) - (rect(tb).y || 0))[0]
+      const centeredHeight = firstContent
+        ? Math.round(2 * (((rect(firstContent).y || 0) + (rect(firstContent).height
+          || (ts(firstContent).fontSize || 14) * 1.4) / 2) - absY))
+        : null
+      return {
+        sliceEl,
+        y: absY,
+        height: Math.round(rect(sliceEl).height || bgSeg.height
+          || (centeredHeight != null ? Math.min(160, Math.max(32, centeredHeight)) : 140)),
+        iconSlice,
+        ...topRhythm(sliceEl
+          ? rect(sliceEl)
+          : { x: cr.x, y: absY, width: cardW, height: bgSeg.height || 140 }, iconSlice),
+        fromSegments: true,
+      }
+    }
+  // ② 自算兜底
+    const sliceCands = (card.elements || []).filter((e) => {
+      const r = rect(e)
+      const w = r.width || 0, h = r.height || 0
+      const nearTop = cardTop ? Math.abs((r.y || 0) - cardTop) <= 30 : (r.y || 0) <= 30
+      return e.type === 'slice' && w >= cardW * 0.8 && h >= 60 && h <= 220 && nearTop
+  })
+    const groupCands = (card.elements || []).filter((e) => {
+      const r = rect(e)
+      const w = r.width || 0, h = r.height || 0
+      const nearTop = cardTop ? Math.abs((r.y || 0) - cardTop) <= 30 : (r.y || 0) <= 30
+      return e.type === 'group' && w >= cardW * 0.8 && h >= 60 && h <= 220 && nearTop
+    })
+    const shapeCands = (card.elements || []).filter((e) => {
+      const r = rect(e)
+      const w = r.width || 0
+      const h = r.height || 0
+      const nearTop = cardTop ? Math.abs((r.y || 0) - cardTop) <= 30 : (r.y || 0) <= 30
+      const fill = e.style?.fill || {}
+      const hasVectorFill = !!fill.color || !!fill.image
+      const hasGradientOverlay = (card.elements || []).some((overlay) =>
+        overlay !== e && overlay.type === 'shape' && !!overlay.style?.fill?.gradient
+        && Math.abs((rect(overlay).x || 0) - (r.x || 0)) < 2
+        && Math.abs((rect(overlay).y || 0) - (r.y || 0)) < 2
+        && Math.abs((rect(overlay).width || 0) - w) < 2
+        && (rect(overlay).height || 0) >= h - 2)
+      const overlays = (card.elements || []).filter((candidate) =>
+        candidate.type === 'shape' && !!candidate.style?.fill?.gradient
+        && Math.abs((rect(candidate).x || 0) - (r.x || 0)) < 2
+        && Math.abs((rect(candidate).y || 0) - (r.y || 0)) < 2
+        && Math.abs((rect(candidate).width || 0) - w) < 2
+        && (rect(candidate).height || 0) >= h - 2)
+      const overlay = overlays.sort((left, right) =>
+        (rect(right).height || 0) - (rect(left).height || 0))[0]
+      const gradientStops = [...(overlay?.style?.fill?.gradient || '').matchAll(/rgba\([^)]+\)\s*\d+%\s*\)?/gi)]
+      const gradientTerminus = gradientStops.at(-1)?.[0]
+      const fallbackFill = gradientTerminus?.match(/rgba\(([^)]+)\)/i)?.[1]
+        ?.split(',').slice(0, 3).map(Number).map((value) => value.toString(16).padStart(2, '0')).join('')
+      const decorationFill = fallbackFill ? `#${fallbackFill.toUpperCase()}` : fill.color
+      e.backgroundFallback = { type: 'solid', color: decorationFill }
+      return e.type === 'shape' && (hasVectorFill || fallbackFill) && w >= cardW * 0.9
+        && Math.abs(((r.x || 0) + w / 2) - ((cr.x || 0) + cardW / 2)) <= 4
+        && h >= 60 && h <= 220 && nearTop && hasGradientOverlay
+    })
+    const cands = [...sliceCands, ...shapeCands, ...groupCands]
+      .sort((left, right) => {
+        const priority = { slice: 0, shape: 1, group: 2 }
+        return (priority[left.type] ?? 9) - (priority[right.type] ?? 9)
+      })
+    if (!cands.length) return null
+    // 优先 slice（有导出文件）；group 兜底（同区域匹配 slice 元素）
+    const first = cands[0]
+    const fr = rect(first)
+    const sliceEl = first.type === 'slice' ? first
+      : (card.elements || []).find((x) => x.type === 'slice'
+        && Math.abs((rect(x).y || 0) - (fr.y || 0)) < 20 && Math.abs((rect(x).width || 0) - (fr.width || 0)) < 20) || null
+    const mediaElement = sliceEl || (first.type === 'shape' ? first : null)
+    // 顶部独立图标：卡片顶部 45% 区域内的近似方形独立 slice。
+    const cardH = cr.height || 400
+    const iconSlice = (card.elements || []).find((x) => x.type === 'slice'
+      && (() => { const r = rect(x); const w = r.width || 0, h = r.height || 0
+        return w >= 40 && w <= 130 && h >= 40 && h <= 130 && Math.abs(w - h) <= 30
+          && (r.y || 0) >= (cr.y || 0) && (r.y || 0) < (cr.y || 0) + cardH * 0.45 })()) || null
+    if (!mediaElement) return null
+    return {
+      sliceEl: mediaElement,
+      y: fr.y || 0,
+      height: Math.round(fr.height || 140),
+      iconSlice,
+      ...topRhythm(fr, iconSlice),
+    } // y=装饰层绝对 y（顶部区底沿= y+height）
+  })()
+
+  const postAmountTexts = texts.filter((t) => {
+    const y = rect(t).y || 0
+    const _effectiveBottom = mainVisualEl ? mainBottom : (_formRowTopY != null ? _formRowTopY : mainBottom)
+    return y >= _effectiveBottom && y < (listTitle ? rect(listTitleCands[0] || {}).y || 9999 : 9999)
+      && !tabs.some((tab) => tab.value === textOf(t))
+      && !auxTexts.some((a) => a.text === textOf(t))
+      && !buttons.some((b) => b.text === textOf(t))
+      && !optionTextSet.has(t) && !optionLabelSet.has(t)
+      && !subAmountEls.has(t)
+      && !formConsumed.has(t)
+      && !countdownConsumed.has(t)
+      && !(textOf(t) === (listTitle?.text || ''))
+      && !_panelGroupMemberEls.has(t)
+      && !_badgeRowTextEls.has(t)
+      // 复合行模式：波段区文本由列表项模板整体接管
+      && !(repeatRowMode && _repeatBandTops.some((bt) => y >= bt - 4 && y <= bt + 80))
+  }).map((t) => ({
+    text: textOf(t),
+    color: ts(t).color,
+    fontSize: ts(t).fontSize,
+    fontWeight: ts(t).fontWeight,
+    align: ts(t).textAlign,
+    sourceEl: t,
+    x: rect(t).x || 0,
+    width: rect(t).width || 0,
+    y: rect(t).y || 0,
+    // 多行文案必须携带标注高度：语义边界 bottom 依赖它计算，
+    // 丢失后边界塌缩成单行高（fs*1.5），后续元素顶距被放大（分隔线/按钮整段下漂）。
+    height: rect(t).height || 0,
+    backgroundShell: backgroundShellFor(t),
+    outlineShell: outlineShellFor(t),
+    highlightShell: highlightShellFor(t),
+  }))
+
+  // —— 列表项：检测重复 row（首列左对齐文本）——
+  // 无列表标题时不检测列表项：buttonY=0 时 rowsBelow 会吞掉所有文本，
+  // 导致 formRow/auxText 文本被误收为伪列表项
+  const listTitleY = listTitle ? rect(listTitleCands[0]).y || 0 : Infinity
+  // 无列表标题时也能成列表：名册/账单类卡片的标题是卡头，列表只有行重复结构。
+  // 行候选 = 主视觉之下、未被任何语义路径消费的文本（表单/面板/辅助文案/选项/副金额/按钮）。
+  const auxConsumedEls = new Set(auxTexts.map((aux) => aux.sourceEl).filter(Boolean))
+  const rowsBelow = (listTitle
+    ? texts.filter((t) => (rect(t).y || 0) > listTitleY)
+    : texts.filter((t) => (rect(t).y || 0) > mainBottom
+      && !panelTextConsumed.has(t)
+      && !auxConsumedEls.has(t) && !subAmountEls.has(t)
+      && !buttons.some((button) => button.sourceEl === t)))
+    .filter((t) => !optionTextSet.has(t) && !optionLabelSet.has(t))
+    .filter((t) => !_panelGroupMemberEls.has(t))
+  const aboveMainPeriodic = texts.filter((t) => {
+    const y = rect(t).y || 0
+    const T0 = ts(t)
+    if (y >= mainBottom) return false
+    if ((T0.fontSize || 0) < 13 || T0.textAlign !== 'left' || (rect(t).x || 0) >= 100) return false
+    if (formConsumed.has(t) || panelTextConsumed.has(t) || enumStatConsumed.has(t)) return false
+    const peers = texts.filter((o) => o !== t
+      && Math.abs((rect(o).x || 0) - (rect(t).x || 0)) <= 4
+      && (ts(o).fontSize || 0) === (T0.fontSize || 0)
+      && (rect(o).y || 0) > y && (rect(o).y || 0) - y <= 140)
+    if (peers.length < 1) return false
+    const gaps = peers.map((o) => (rect(o).y || 0) - y)
+    return gaps.every((g) => g >= 40 && g <= 140 && Math.abs(g - gaps[0]) <= 10)
+  })
+  const firstColTexts = [...new Set([...rowsBelow, ...aboveMainPeriodic])]
+    .sort((a, b) => (rect(a).y || 0) - (rect(b).y || 0)).filter((t) => {
+    const T = ts(t)
+    return (T.fontSize || 0) >= 13 && T.textAlign === 'left' && (rect(t).x || 0) < 100
+      // 排除 section header：文本节点以全角冒号结尾，是结构性结束信号。
+      && !/：$/.test(textOf(t))
+      // P1：只排除枚举统计行（enumStatConsumed），不再排除 formConsumed——
+      // P0 已让「标题+描述」文本对不再被 formRow 吞掉（基线同行判定），列表项得以回流识别；
+      // 若仍排除 formConsumed，列表识别会被表单行清空（items=0 → 列表项平铺成 formRow，布局倒退）。
+      && !enumStatConsumed.has(t)
+      && !panelTextConsumed.has(t)
+      && !optionTextSet.has(t) && !optionLabelSet.has(t)
+      // 复合行模式：重复波段内（标签行+其下值行）的文本是列表行成员，不得成为行标题候选
+      && !(repeatRowMode && _repeatBandTops.some((bt) => {
+        const ty = rect(t).y || 0
+        return ty >= bt - 4 && ty <= bt + 80
+      }))
+      // 面板组成员：由面板列表模板整体接管
+      && !_panelGroupMemberEls.has(t)
+  })
+  // 同 y（±10）的 first-col 文本聚合为一项；按 y 排序
+  // P0/P1 升级：列表项必须存在「标题下方 18-36px 的描述文本」（desc）——否则摘要区
+  // 「标题+说明」单组文本（如 重点摘要/按强重要…）会被误收为列表项（无下邻描述 → 跳过）。
+  // 描述文本标记 itemDescConsumed，防止被 viewMore 误捕 / postAmountTexts 重复渲染。
+  const items = []
+  const itemDescConsumed = new Set()
+
+  const itemTextConsumed = new Set()
+  const compositeRowRegions = []
+  let lastY = -100
+  for (const t of firstColTexts) {
+    if (itemDescConsumed.has(t)) continue
+    const y = rect(t).y || 0
+    if (compositeRowRegions.some(([rt, rb]) => y >= rt && y <= rb)) continue
+    if (y - lastY > 30) {
+      // 新起一行：取该行的所有文本（标题/金额/时间）
+      const rowTexts = rowsBelow.filter((r) => Math.abs((rect(r).y || 0) - y) < 30 || Math.abs((rect(r).y || 0) - (y + 24)) < 30)
+      const title = textOf(t)
+      // 描述 = 标题正下方 18-36px 的同列文本（上下两行、左对齐：列表项特征）
+      // 描述行 = 标题正下方 18-36px 且与标题同列（左沿最近）的文本；
+      // 右侧时间行与描述同 y 时按元素序会抢先命中，把时间当描述、真描述被甩到列表外。
+      let descEl = rowTexts
+        .filter((r) => {
+          const ry = rect(r).y || 0
+          // 与标题同列、同字号、同色的「描述」其实是下一条等距单行（选项/清单行）：
+          // 真描述通常更小/更灰或缩进。误认会把下一行吞成描述、再下一行被甩出列表丢失。
+          if (Math.abs((rect(r).x || 0) - (rect(t).x || 0)) <= 2
+            && (ts(r).fontSize || 0) === (ts(t).fontSize || 0)
+            && String(ts(r).color || '').toLowerCase() === String(ts(t).color || '').toLowerCase()) return false
+          return ry - y >= 18 && ry - y <= 36
+        })
+        .sort((a, b) => Math.abs((rect(a).x || 0) - (rect(t).x || 0))
+          - Math.abs((rect(b).x || 0) - (rect(t).x || 0)))[0] || null
+      // —— 复合行（重复波段标签列组）：标题行 + ≥2 组「标签+值」纵列 ——
+      // 触发：repeatRowMode 且（无 desc 或 desc 本身是波段标签）→ 行内容不是「标题+描述」。
+      // 几何驱动：标签在标题下方 18-110px、值在标签正下方 10-50px、x 对齐(±24)。
+      let compositePairs = null
+      let titleRightEl = null
+      if (repeatRowMode && (!descEl || _repeatLabelTexts.has(textOf(descEl)) || _allBandLabelEls.has(descEl))) {
+        const tRect = rect(t)
+        const bandLabels = texts.filter((lab) => {
+          if (!_repeatLabelTexts.has(textOf(lab)) && !_allBandLabelEls.has(lab)) return false
+          const dy = (rect(lab).y || 0) - y
+          return dy >= 18 && dy <= 110
+        }).sort((a, b) => (rect(a).x || 0) - (rect(b).x || 0))
+        const pairs = []
+        for (const lab of bandLabels) {
+          const lr = rect(lab)
+          if (pairs.some((pp) => Math.abs((rect(pp.labelEl).x || 0) - (lr.x || 0)) <= 24)) continue
+          const valueCand = texts.filter((v) => {
+            if (v === lab || !isAmountish(textOf(v))) return false
+            const vr = rect(v)
+            const vdy = (vr.y || 0) - (lr.y || 0)
+            return vdy >= 10 && vdy <= 50 && Math.abs((vr.x || 0) - (lr.x || 0)) <= 24
+          }).sort((a, b) => (rect(b).width || 0) - (rect(a).width || 0))[0]
+          if (valueCand) pairs.push({ labelEl: lab, valueEl: valueCand })
+        }
+        if (pairs.length >= 2) {
+          compositePairs = pairs.slice(0, 4)
+          // 标签行内联 tag 壳（币种选择 pill 类）：贴标签右沿的小填充/描边壳 + 壳内短文本/小切片。
+          // 逐行数据驱动（$amtTagN/$amtTagIconN），无 tag 的行 v-show 隐藏，避免静态模板每行滥发。
+          for (const pp of compositePairs) {
+            const lr2 = rect(pp.labelEl)
+            const labelCY = (lr2.y || 0) + (lr2.height || 0) / 2
+            const shell = (shapes || []).find((sh) => {
+              const r = rect(sh)
+              const w = r.width || 0
+              const h = r.height || 0
+              if (w < 28 || w > 120 || h < 12 || h > 28) return false
+              if (!sh.style?.fill?.color && !sh.style?.border?.isBorder) return false
+              if (Math.abs(((r.y || 0) + h / 2) - labelCY) > 8) return false
+              const gx = (r.x || 0) - ((lr2.x || 0) + (lr2.width || 0))
+              return gx >= -2 && gx <= 16
+            }) || null
+            pp.tagShapeEl = shell
+            if (!shell) continue
+            const sr = rect(shell)
+            const inside = (e) => {
+              const er = rect(e)
+              return (er.x || 0) >= (sr.x || 0) - 2 && (er.y || 0) >= (sr.y || 0) - 2
+                && (er.x || 0) + (er.width || 0) <= (sr.x || 0) + (sr.width || 0) + 2
+                && (er.y || 0) + (er.height || 0) <= (sr.y || 0) + (sr.height || 0) + 2
+            }
+            const tagTextEl = texts.find((tt2) => inside(tt2)) || null
+            const tagIconEl = (slices || []).find((sl) => inside(sl)) || null
+            const tagExp = tagIconEl
+              ? (resolveSliceExport(spec.slices || [], tagIconEl.name) || tagIconEl.annotationDefect?.cropSlice)
+              : null
+            pp.tagText = tagTextEl ? textOf(tagTextEl) : ''
+            pp.tagTextColor = tagTextEl ? ts(tagTextEl).color : undefined
+            pp.tagFontSize = tagTextEl ? ts(tagTextEl).fontSize : undefined
+            pp.tagIcon = tagExp ? sliceRefPath(tagExp) : ''
+            pp.tagFill = shell.style?.fill?.color || null
+            pp.tagOpacity = shell.style?.opacity ?? 1
+            pp.tagBorder = shell.style?.border?.isBorder ? (shell.style?.border?.color || null) : null
+            pp.tagRadius = shell.style?.radius?.borderRadius || 0
+            pp.tagW = Math.round(sr.width || 0)
+            pp.tagH = Math.round(sr.height || 0)
+            pp.tagGap = Math.max(2, Math.round((sr.x || 0) - ((lr2.x || 0) + (lr2.width || 0))))
+            pp.tagPadLeft = Math.max(0, Math.round(((tagTextEl ? rect(tagTextEl).x : sr.x) || 0) - (sr.x || 0)))
+            pp.tagPadRight = Math.max(0, Math.round(((sr.x || 0) + (sr.width || 0))
+              - ((tagIconEl ? (rect(tagIconEl).x || 0) + (rect(tagIconEl).width || 0)
+                : (tagTextEl ? (rect(tagTextEl).x || 0) + (rect(tagTextEl).width || 0)
+                  : (sr.x || 0) + (sr.width || 0))))))
+            pp.tagIconGap = tagIconEl && tagTextEl
+              ? Math.max(0, Math.round((rect(tagIconEl).x || 0) - ((rect(tagTextEl).x || 0) + (rect(tagTextEl).width || 0))))
+              : 2
+            pp.tagIconW = tagIconEl ? Math.round(rect(tagIconEl).width || 16) : 0
+            pp.tagIconH = tagIconEl ? Math.round(rect(tagIconEl).height || 16) : 0
+          }
+          const cardRectC = rect(card)
+          titleRightEl = texts.find((tt) => {
+            if (tt === t || compositePairs.some((pp) => pp.labelEl === tt || pp.valueEl === tt)) return false
+            const tr = rect(tt)
+            return Math.abs((tr.y || 0) - y) <= 6
+              && (tr.x || 0) >= (tRect.x || 0) + (tRect.width || 0) + 8
+              && (tr.x || 0) + (tr.width || 0) <= (cardRectC.x || 0) + (cardRectC.width || 375) - 8
+          }) || null
+        }
+      }
+      if (!descEl && !compositePairs) {
+        // 周期行兜底：无标准 desc（18-36px）但标题存在 ≥2 个同列等距周期同伴时
+        // （支出占比分类行：类别名+金额+百分比+进度条，百分比仅 0-8px 下方而非标准 18-36px），
+        // 取近邻小字号文本（0-16px 下方）作为 desc，使行仍被识别为列表项。
+        // 双向检测：上下方合计 ≥2 个同列等距同伴即判周期行（中间行 1 上 1 下）。
+        const periodicPeersAll = firstColTexts.filter((o) => o !== t
+          && Math.abs((rect(o).x || 0) - (rect(t).x || 0)) <= 4
+          && (ts(o).fontSize || 0) === (ts(t).fontSize || 0)
+          && String(ts(o).color || '').toLowerCase() === String(ts(t).color || '').toLowerCase()
+          && Math.abs((rect(o).y || 0) - y) >= 20 && Math.abs((rect(o).y || 0) - y) <= 200)
+        if (periodicPeersAll.length >= 2) {
+          const peerDys = periodicPeersAll.map((o) => (rect(o).y || 0) - y).sort((a, b) => Math.abs(a) - Math.abs(b))
+          const candSteps = [...new Set([Math.abs(peerDys[0]), Math.abs(peerDys[1] || peerDys[0])])].filter((s) => s >= 20)
+          const hasPeriodic = candSteps.some((candStep) => {
+            const matched = peerDys.filter((g) => {
+              const remainder = Math.abs(g) % candStep
+              return Math.min(remainder, candStep - remainder) <= 12
+            }).length
+            return matched >= 2
+          })
+          if (hasPeriodic) {
+            descEl = rowTexts.find((r) => {
+              const ry = rect(r).y || 0
+              return r !== t && ry >= y && ry - y <= 16
+                && (ts(r).fontSize || 0) < (ts(t).fontSize || 0)
+                && Math.abs((rect(r).x || 0) - (rect(t).x || 0)) <= (rect(t).width || 0) + 40
+            }) || null
+          }
+        }
+        if (!descEl) { lastY = y; continue }
+      }
+      // 时间行：日期分隔符含点/斜杠形态（2025.10.10 14:28:16）。此前只匹配横杠，
+      // 点分时间行永远不被列表行消费，被 auxTexts 当孤立文本甩到卡底重渲染。
+      const time = rowTexts.find((r) => r !== descEl
+        && /\d{4}[-/.]\d{1,2}[-/.]\d{1,2}/.test(textOf(r))) || null
+      // 行右金额候选必须含数字或货币符号：纯币种名（如 pill 标签「美元」）含「元」字但不是金额，误捕会把标签塞进数值表达式（渲染占位文案）并用其右沿算行右内边距挤窄标题行。
+      const isRowAmountText = (v) => /\p{Sc}/u.test(v) || (/\d/.test(v) && /[.元]/.test(v))
+      // 行第二行右侧文本（交易行「余额：¥20,077.00」）：与 desc 行同基线、右半锚定，
+      // 且非 desc/time → 行右列第二行，数据驱动 $descRight（先于 amount 计算，
+      // 否则余额行被 amount 通道抢先造成右列双份）。
+      const descRightEl = rowTexts.find((r) => r !== descEl && r !== time && r !== t
+        && Math.abs((rect(r).y || 0) - (descEl ? (rect(descEl).y || 0) : y + 22)) <= 6
+        && (rect(r).x || 0) >= (rect(card).x || 0) + (rect(card).width || 375) / 2) || null
+      const amount = rowTexts.find((r) => r !== time && r !== descEl && r !== descRightEl && isRowAmountText(textOf(r)))
+      // 标题同行后缀（如「张三」右侧灰色小字「(小张)」）：同基线、紧随标题右沿
+      const titleRightEdge = (rect(t).x || 0) + (rect(t).width || 0)
+      // 行内联 affordance（紧跟账号的行尾眼睛图标）：不锚行右沿而是紧贴标题右沿，
+      // 逐行挂接后由模板按几何在标题行内联渲染（区别于右对齐行尾件）。
+      const inlineAffordEl = [...(slices || []), ...symbols].find((s2) => {
+        const r2 = rect(s2)
+        const w2 = r2.width || 0
+        const h2 = r2.height || 0
+        if (w2 < 14 || w2 > 32 || h2 < 14 || h2 > 32) return false
+        if (Math.abs((r2.y || 0) - y) > 8) return false
+        const gap2 = (r2.x || 0) - titleRightEdge
+        return gap2 >= 2 && gap2 <= 48
+      }) || null
+      if (inlineAffordEl) {
+        const bi2 = isolatedBlocks.findIndex((b) => b.element === inlineAffordEl)
+        if (bi2 >= 0) isolatedBlocks.splice(bi2, 1)
+      }
+      const suffixEl = rowTexts.find((r) => r !== t && r !== descEl
+        && Math.abs((rect(r).y || 0) - y) <= 6
+        && (rect(r).x || 0) >= titleRightEdge - 2 && (rect(r).x || 0) <= titleRightEdge + 16) || null
+      // 标题行同行右侧文本（交易行金额，基线可能比标题高几 px）：非复合行下
+      // rowTexts 带不含它（y 略小于标题），不补 titleRight 通道行右金额就丢失。
+      if (!compositePairs) {
+        titleRightEl = texts.find((tt) => {
+          if (tt === t || tt === descEl || tt === suffixEl || tt === descRightEl) return false
+          const tr = rect(tt)
+          return Math.abs((tr.y || 0) - y) <= 8
+            && (tr.x || 0) >= titleRightEdge + 8
+            && (tr.x || 0) >= (rect(card).x || 0) + (rect(card).width || 375) * 0.5
+        }) || null
+      }
+      // 行图标：标题左侧、行带垂直范围内的切片（逐行不同 → 数据驱动）
+      const rowBandTop = y - 12
+      const rowBandBottom = (rect(descEl).y || 0) + (rect(descEl).height || 0) + 12
+      const iconEl = (slices || []).find((s) => {
+        const r = rect(s)
+        const w = r.width || 0; const h = r.height || 0
+        return w >= 16 && w <= 48 && h >= 16 && h <= 48
+          && (r.x || 0) < (rect(t).x || 0) - 2
+          && (r.y || 0) >= rowBandTop && (r.y || 0) + h <= rowBandBottom
+      }) || null
+      // 行内操作 pill：右侧锚定的描边/填充小壳（宽 40-120 高 22-48）+ 单文本（如「删除」）
+      const cardR0 = rect(card)
+      const cardRight0 = (cardR0.x || 0) + (cardR0.width || 0)
+      // 行右大图标（行壳右沿锚定的 32-72px 切片/符号，如保险产品 48x48）：数据驱动 $rightIcon
+      const rightIconEl = ((content || []).filter((e) => e.type === 'slice' || e.type === 'symbol')).find((s) => {
+        if (s === iconEl) return false
+        const r = rect(s)
+        const w = r.width || 0; const h = r.height || 0
+        if (w < 32 || w > 72 || h < 32 || h > 72) return false
+        if ((r.x || 0) <= (rect(t).x || 0)) return false
+        return (r.x || 0) + w >= cardRight0 - 48
+          && (r.y || 0) >= rowBandTop && (r.y || 0) + h <= rowBandBottom + 8
+      }) || null
+      const actionShapeEl = (shapes || []).find((s) => {
+        if (optionShapeSet.has(s)) return false
+        const r = rect(s)
+        const w = r.width || 0; const h = r.height || 0
+        if (w < 40 || w > 120 || h < 22 || h > 48) return false
+        if (!s.style?.fill?.color && !s.style?.border?.isBorder) return false
+        const vCenter = (r.y || 0) + h / 2
+        return vCenter >= rowBandTop && vCenter <= rowBandBottom
+          && (r.x || 0) + w >= cardRight0 - Math.max(72, (cardR0.width || 375) * 0.2)
+      }) || null
+      const actionTextEl = actionShapeEl ? texts.find((tt) => {
+        const tr = rect(tt)
+        const ar = rect(actionShapeEl)
+        return (tr.x || 0) >= (ar.x || 0) - 2 && (tr.y || 0) >= (ar.y || 0) - 2
+          && (tr.x || 0) + (tr.width || 0) <= (ar.x || 0) + (ar.width || 0) + 2
+          && (tr.y || 0) + (tr.height || 0) <= (ar.y || 0) + (ar.height || 0) + 2
+      }) || null : null
+      // 行内操作 pill 与按钮检测是同一份视觉证据的两条路径：item 模板已渲染该 pill
+      // （actionShapeEl），buttons 中同源按钮必须同步消费，否则通用按钮区把每行 pill
+      // 再渲染一遍（删除×3 → 渲染×6 重影 + 底部多出按钮行撑高卡片）。
+      if (actionTextEl) {
+        const consumedBtnIdx = buttons.findIndex((b) => b.sourceEl === actionTextEl)
+        if (consumedBtnIdx >= 0) buttons.splice(consumedBtnIdx, 1)
+      }
+      items.push({
+        title,
+        // 行内容左右沿（spec 实测）：行横向内边距按此驱动，避免通用 12px 与设计 16px 错位
+        rowLeftEdge: Math.round(Math.min(rect(t).x || 0, iconEl ? (rect(iconEl).x || 0) : Infinity)),
+        // 行内容真实右沿：行壳内边距推导用（全部行文本 + 图标 + 操作件右沿最大值）
+        rowContentRight: Math.round(Math.max(0, ...[...rowTexts, iconEl, rightIconEl, actionShapeEl]
+          .filter(Boolean).map((e) => (rect(e).x || 0) + (rect(e).width || 0)))) || null,
+        // 只统计右栏内容（金额/时间/行内操作）的右沿；标题行后缀/右侧同行文本属于
+        // 左栏标题流，混入会把行右内边距算成巨大值挤窄左栏（名册卡曾因此换行回归）。
+        rowRightEdge: Math.round(Math.max(0, ...[amount, time, actionShapeEl]
+          .filter(Boolean).map((e) => (rect(e).x || 0) + (rect(e).width || 0)))) || null,
+        titleSuffix: suffixEl ? textOf(suffixEl) : '',
+        titleSuffixColor: suffixEl ? ts(suffixEl).color : undefined,
+        titleSuffixFontSize: suffixEl ? ts(suffixEl).fontSize : undefined,
+        icon: iconEl
+          ? ((resolveSliceExport(spec.slices || [], iconEl.name) || iconEl.annotationDefect?.cropSlice)
+            ? sliceRefPath(resolveSliceExport(spec.slices || [], iconEl.name) || iconEl.annotationDefect?.cropSlice)
+            : `http://iph.href.lu/${Math.round(rect(iconEl).width || 32)}x${Math.round(rect(iconEl).height || 32)}?text=${encodeURIComponent('缺素材')}`)
+          : null,
+        iconEl,
+        iconW: iconEl ? Math.round(rect(iconEl).width || 0) : 0,
+        iconH: iconEl ? Math.round(rect(iconEl).height || 0) : 0,
+        rightIcon: rightIconEl
+          ? ((resolveSliceExport(spec.slices || [], rightIconEl.name) || rightIconEl.annotationDefect?.cropSlice)
+            ? sliceRefPath(resolveSliceExport(spec.slices || [], rightIconEl.name) || rightIconEl.annotationDefect?.cropSlice)
+            : `http://iph.href.lu/${Math.round(rect(rightIconEl).width || 48)}x${Math.round(rect(rightIconEl).height || 48)}?text=${encodeURIComponent('缺素材')}`)
+          : null,
+        rightIconEl,
+        rightIconW: rightIconEl ? Math.round(rect(rightIconEl).width || 0) : 0,
+        rightIconH: rightIconEl ? Math.round(rect(rightIconEl).height || 0) : 0,
+        action: actionTextEl ? textOf(actionTextEl) : '',
+        affordInline: !!inlineAffordEl,
+        affordInlineGap: inlineAffordEl
+          ? Math.max(4, Math.round((rect(inlineAffordEl).x || 0) - titleRightEdge))
+          : undefined,
+        affordanceEl: inlineAffordEl || null,
+        affordanceUrl: inlineAffordEl
+          ? ((resolveSliceExport(spec.slices || [], inlineAffordEl.name) || inlineAffordEl.annotationDefect?.cropSlice)
+            ? sliceRefPath(resolveSliceExport(spec.slices || [], inlineAffordEl.name) || inlineAffordEl.annotationDefect?.cropSlice)
+            : `http://iph.href.lu/${Math.round(rect(inlineAffordEl).width || 20)}x${Math.round(rect(inlineAffordEl).height || 20)}?text=${encodeURIComponent('缺素材')}`)
+          : '',
+        actionShapeEl,
+        actionColor: actionTextEl ? ts(actionTextEl).color : undefined,
+        actionFontSize: actionTextEl ? ts(actionTextEl).fontSize : undefined,
+        actionBorderColor: actionShapeEl ? (actionShapeEl.style?.border?.color || null) : null,
+        actionFill: actionShapeEl ? (actionShapeEl.style?.fill?.color || null) : null,
+        actionRadius: actionShapeEl ? (actionShapeEl.style?.radius?.borderRadius || 0) : 0,
+        actionW: actionShapeEl ? Math.round(rect(actionShapeEl).width || 0) : 0,
+        actionH: actionShapeEl ? Math.round(rect(actionShapeEl).height || 0) : 0,
+        desc: compositePairs ? '' : textOf(descEl),
+        descRight: descRightEl ? textOf(descRightEl) : '',
+        descRightColor: descRightEl ? ts(descRightEl).color : undefined,
+        descRightFontSize: descRightEl ? ts(descRightEl).fontSize : undefined,
+        amounts: compositePairs ? compositePairs.map((pp) => ({
+          label: textOf(pp.labelEl), value: textOf(pp.valueEl),
+          tagText: pp.tagText || '', tagIcon: pp.tagIcon || '',
+          tagFill: pp.tagFill || null, tagOpacity: pp.tagOpacity ?? 1, tagBorder: pp.tagBorder || null, tagRadius: pp.tagRadius || 0,
+          tagW: pp.tagW || 0, tagH: pp.tagH || 0, tagGap: pp.tagGap, tagPadLeft: pp.tagPadLeft,
+          tagPadRight: pp.tagPadRight, tagIconGap: pp.tagIconGap, tagIconW: pp.tagIconW, tagIconH: pp.tagIconH,
+          tagTextColor: pp.tagTextColor, tagFontSize: pp.tagFontSize,
+          labelColor: ts(pp.labelEl).color, labelFontSize: ts(pp.labelEl).fontSize,
+          labelFontWeight: ts(pp.labelEl).fontWeight,
+          labelX: Math.round(rect(pp.labelEl).x || 0), labelW: Math.round(rect(pp.labelEl).width || 0),
+          labelY: Math.round(rect(pp.labelEl).y || 0), labelH: Math.round(rect(pp.labelEl).height || 0),
+          valueY: Math.round(rect(pp.valueEl).y || 0),
+          valueColor: ts(pp.valueEl).color, valueFontSize: ts(pp.valueEl).fontSize,
+          valueFontWeight: ts(pp.valueEl).fontWeight, valueW: Math.round(rect(pp.valueEl).width || 0),
+        })) : undefined,
+        titleRight: titleRightEl ? textOf(titleRightEl) : '',
+        titleRightColor: titleRightEl ? ts(titleRightEl).color : undefined,
+        titleRightFontSize: titleRightEl ? ts(titleRightEl).fontSize : undefined,
+        titleRightGap: titleRightEl
+          ? Math.max(4, Math.round((rect(titleRightEl).x || 0) - ((rect(t).x || 0) + (rect(t).width || 0))))
+          : undefined,
+        labelGapTop: compositePairs
+          ? Math.max(0, Math.round((rect(compositePairs[0].labelEl).y || 0) - (y + (rect(t).height || 0))))
+          : undefined,
+        iconGap: iconEl
+          ? Math.max(0, Math.round((rect(t).x || 0) - ((rect(iconEl).x || 0) + (rect(iconEl).width || 0))))
+          : undefined,
+        amount: amount ? textOf(amount) : '',
+        time: time ? textOf(time) : '',
+        timeColor: time ? ts(time).color : undefined,
+        timeFontSize: time ? ts(time).fontSize : undefined,
+        timeFontWeight: time ? ts(time).fontWeight : undefined,
+        titleColor: ts(t).color,
+        titleFontSize: ts(t).fontSize,
+        titleFontWeight: ts(t).fontWeight,
+        descColor: descEl ? ts(descEl).color : undefined,
+        descFontSize: descEl ? ts(descEl).fontSize : undefined,
+        descFontWeight: descEl ? ts(descEl).fontWeight : undefined,
+        descHeight: descEl ? (rect(descEl).height || 0) : 0,
+        descY: descEl ? (rect(descEl).y || 0) : undefined,
+        descX: descEl ? (rect(descEl).x || 0) : undefined,
+        amountColor: amount ? ts(amount).color : undefined,
+        amountFontSize: amount ? ts(amount).fontSize : undefined,
+        amountFontWeight: amount ? ts(amount).fontWeight : undefined,
+        y,
+        titleX: Math.round(rect(t).x || 0),
+        titleW: Math.round(rect(t).width || 0),
+        contentHeight: compositePairs
+          ? Math.round(Math.max(...compositePairs.map((pp) => (rect(pp.valueEl).y || 0) + (rect(pp.valueEl).height || 0))) - y)
+          : Math.round((rect(descEl).y || 0) + (rect(descEl).height || 0) - y),
+      })
+      if (descEl) itemDescConsumed.add(descEl)
+      itemTextConsumed.add(t)
+      if (compositePairs) {
+        for (const pp of compositePairs) { itemTextConsumed.add(pp.labelEl); itemTextConsumed.add(pp.valueEl) }
+        const minLabelY = Math.min(...compositePairs.map((pp) => rect(pp.labelEl).y || 0))
+        const maxValueBottom = Math.max(...compositePairs.map((pp) => (rect(pp.valueEl).y || 0) + (rect(pp.valueEl).height || 0)))
+        compositeRowRegions.push([minLabelY - 4, maxValueBottom + 4])
+      }
+      if (titleRightEl) itemTextConsumed.add(titleRightEl)
+      if (descEl) itemTextConsumed.add(descEl)
+      if (descRightEl) itemTextConsumed.add(descRightEl)
+      if (suffixEl) itemTextConsumed.add(suffixEl)
+      if (actionTextEl) itemTextConsumed.add(actionTextEl)
+      if (amount) itemTextConsumed.add(amount)
+      if (time) itemTextConsumed.add(time)
+      lastY = y
+    }
+  }
+  // 行图标/行内操作壳已被列表项消费：从孤立媒体块中回收，防止二次渲染
+  const itemMediaEls = new Set(items.flatMap((item) => [item.iconEl, item.actionShapeEl]).filter(Boolean))
+  if (itemMediaEls.size) {
+    for (let bi = isolatedBlocks.length - 1; bi >= 0; bi -= 1) {
+      if (itemMediaEls.has(isolatedBlocks[bi].element)) isolatedBlocks.splice(bi, 1)
+    }
+  }
+  // 行尾右侧操作件（眼睛/箭头图标）归属——按「是否被列表接管」分流：
+  //   有列表：重复同名实例由列表项模板逐行渲染（见 listAffordanceSlice），回收防重影；
+  //   无列表：挂到垂直对齐的语义行（aux 文本行 / midCluster 行）右侧渲染；
+  //   无对齐行：留在孤立媒体块按 spec 位置兜底（与旧行为一致）。
+  const panelRowSliceEls = new Set((panelRows || []).flatMap((panel) => [panel.leftSlice, panel.rightSlice]).filter(Boolean))
+  const rightAffordancePool = affordanceCandidates.filter((element) =>
+    !formSliceEls.has(element) && !auxSliceEls.has(element) && element !== primaryIconEl
+    && !(midCluster && midCluster.logoSlice === element) && !panelRowSliceEls.has(element))
+  if (rightAffordancePool.length) {
+    const detachIsolated = (element) => {
+      const bi = isolatedBlocks.findIndex((b) => b.element === element)
+      if (bi >= 0) isolatedBlocks.splice(bi, 1)
+    }
+    // 挂到垂直对齐的文本语义行右侧（listTitle / midCluster / auxTexts），成功返回 true
+    const attachToTextRow = (element) => {
+      const er = rect(element)
+      const tol = Math.max(12, (er.height || 0) * 0.75)
+      let best = null
+      if (midCluster) {
+        const diff = Math.abs((midCluster.y || 0) - (er.y || 0))
+        if (diff <= tol) best = { kind: 'mid', diff }
+      }
+      if (listTitle) {
+        const diff = Math.abs((listTitle.y || 0) - (er.y || 0))
+        if (diff <= tol && (!best || diff < best.diff)) best = { kind: 'title', diff }
+      }
+      for (const aux of auxTexts) {
+        const diff = Math.abs((aux.y || 0) - (er.y || 0))
+        if (diff <= tol && (!best || diff < best.diff)) best = { kind: 'aux', aux, diff }
+      }
+      if (!best) return false
+      if (best.kind === 'mid') midCluster.rightSliceEl = element
+      else if (best.kind === 'title') listTitle.rightSliceEl = element
+      else best.aux.rightSliceEl = element
+      return true
+    }
+    for (const element of rightAffordancePool) {
+      const er = rect(element)
+      const tol = Math.max(12, (er.height || 0) * 0.75)
+      // 1) 列表行归属：行尾 affordance 与行标题同线（顶沿对齐），逐行挂接 → 数据驱动渲染，
+      //    无 affordance 的行（如末行）$afford 为空串由 v-show 隐藏。
+      let hitItem = null
+      if (items.length) {
+        let bestDy = Infinity
+        for (const item of items) {
+          if (item.affordanceEl) continue
+          // 行右大图标内嵌小徽标（如 icon 角上的 ¥ badge）不是行尾 affordance：重叠即跳过，
+          // 否则徽标挤占左栏宽度导致 desc 换行（保险保障行实测）
+          const riR = item.rightIconEl ? rect(item.rightIconEl) : null
+          if (riR && (er.x || 0) >= (riR.x || 0) - 6 && (er.y || 0) >= (riR.y || 0) - 6
+            && (er.x || 0) + (er.width || 0) <= (riR.x || 0) + (riR.width || 0) + 6
+            && (er.y || 0) + (er.height || 0) <= (riR.y || 0) + (riR.height || 0) + 6) continue
+          const dy = Math.abs((item.y || 0) - (er.y || 0))
+          if (dy <= tol && dy < bestDy) { bestDy = dy; hitItem = item }
+        }
+      }
+      if (hitItem) {
+        hitItem.affordanceEl = element
+        const affordExport = resolveSliceExport(spec.slices || [], element.name) || element.annotationDefect?.cropSlice
+        hitItem.affordanceUrl = affordExport
+          ? sliceRefPath(affordExport)
+          : `http://iph.href.lu/${Math.round(er.width || 20)}x${Math.round(er.height || 20)}?text=${encodeURIComponent('缺素材')}`
+        detachIsolated(element)
+        continue
+      }
+      // 2) 文本语义行右侧挂接（标题行的眼睛图标等）
+      if (attachToTextRow(element)) { detachIsolated(element); continue }
+      // 3) 有列表时的旧兜底：重复实例由模板静态渲染（见 listAffordanceSlice），回收防重影
+      if (items.length && repeatedRightAffordanceEls.has(element)) detachIsolated(element)
+      // 4) 其余留在孤立媒体块按 spec 位置兜底渲染
+    }
+  }
+  // 无标题列表时 postAmountTexts 上界为 ∞，会把列表行文本再渲染一遍——
+  // 同步回收被列表项消费的文本（与 auxTexts/isolatedBlocks 回收同构）。
+  if (itemTextConsumed.size && Array.isArray(postAmountTexts)) {
+    for (let pi = postAmountTexts.length - 1; pi >= 0; pi -= 1) {
+      if (itemTextConsumed.has(postAmountTexts[pi].sourceEl)) postAmountTexts.splice(pi, 1)
+    }
+  }
+  // auxTexts 早于列表识别计算：行内时间/描述被列表接管后必须同步回收，
+  // 否则它们在列表之后再渲染一遍（账单卡时间行堆到卡底）。
+  if (itemTextConsumed.size && Array.isArray(auxTexts)) {
+    for (let ai = auxTexts.length - 1; ai >= 0; ai -= 1) {
+      if (itemTextConsumed.has(auxTexts[ai].sourceEl)) auxTexts.splice(ai, 1)
+    }
+  }
+  // 同表模板一致性护栏（纯结构签名，不靠业务词）：签名不同的行并进同一 ListLayout 会让
+  // 模板字段错位（desc 落 title 槽竖排换行、缺键渲染占位文案），且少数行与静态语义块双份渲染。
+  // 保留多数签名行成表；少数签名行退出列表，交还静态语义通道渲染。
+  if (items.length >= 3) {
+    const itemSig = (it) => [
+      it.iconEl ? 1 : 0,
+      (it.amounts && it.amounts.length) ? 1 : 0,
+      it.rowRightEdge != null ? 1 : 0,
+      it.actionShapeEl ? 1 : 0,
+    ].join('')
+    const sigCounts = new Map()
+    for (const it of items) sigCounts.set(itemSig(it), (sigCounts.get(itemSig(it)) || 0) + 1)
+    const majority = [...sigCounts.entries()].sort((a, b) => b[1] - a[1])[0]
+    if (sigCounts.size >= 2 && majority[1] >= 2 && majority[1] < items.length) {
+      const kept = items.filter((it) => itemSig(it) === majority[0])
+      items.splice(0, items.length, ...kept)
+    }
+  }
+  const sampleItems = items.slice(0, 3)
+  // 表单行早于列表识别计算：行内 desc/descRight 被列表接管后必须同步回收，
+  // 否则表单通道把同一批标注再渲染一遍（交易行余额行重影）。
+  if (itemTextConsumed.size && Array.isArray(formRows)) {
+    for (let fi = formRows.length - 1; fi >= 0; fi -= 1) {
+      const ownedEls = [formRows[fi].labelEl, formRows[fi].valueEl, ...(formRows[fi].subEls || [])]
+        .filter(Boolean)
+      if (ownedEls.some((el) => itemTextConsumed.has(el))) formRows.splice(fi, 1)
+    }
+  }
+  // richBlocks 早于列表识别按全量文本计算：tile/段落区域被列表接管后必须同步回收，
+  // 否则富文本段落路径把同一批标注再渲染一遍（v6 产品 tile 重影，duplicate-content ×23）。
+  // 双判据：① 碎片被列表消费覆盖率 ≥80%；② 几何落在列表区（与分隔线列表区护栏同族，
+  //   纯几何不靠业务词）——列表区的富文本块必然与列表迭代双份渲染。
+  // 列表壳 span：item 壳顶（rowTop，缺省退标题 y 上留 24px 壳垫）→ 壳底。
+  // 任何「整块包住列表行」的富文本块/面板壳都是列表壳本体：与列表迭代必然双份渲染，回收。
+  const listItemSpans = sampleItems.map((it) => {
+    const gaps = sampleItems.slice(1).map((other, index) =>
+      ((other.y || 0) - (sampleItems[index].y || 0))).filter((gap) => gap > 0)
+    const fallbackH = gaps.length ? gaps.sort((a, b) => a - b)[Math.floor(gaps.length / 2)] : 40
+    const top = (it.rowTop ?? (it.y || 0) - 24)
+    const bottom = top + (it.shellHeight || it.rowHeight || it.height || fallbackH)
+    return [top, bottom]
+  })
+  const overlapsListRow = (y, height) => listItemSpans.some(([top, bottom]) =>
+    (y || 0) < bottom + 4 && ((y || 0) + (height || 0)) > top - 4)
+  if (Array.isArray(richBlocks) && sampleItems.length >= 2) {
+    for (let ri = richBlocks.length - 1; ri >= 0; ri -= 1) {
+      const block = richBlocks[ri]
+      const frags = block.fragments || []
+      const consumed = frags.filter((f) => itemTextConsumed.has(f)).length
+      const covered = frags.length > 0 && consumed / frags.length >= 0.8
+      if (covered || overlapsListRow(block.y, block.height || 0)) richBlocks.splice(ri, 1)
+    }
+  }
+  // panelRows（面板壳 + 壳内文本，渲染见 emit 段 panelRows 循环）被列表接管后同步回收：
+  // 否则面板路径与列表迭代把同一批标注再渲染一遍（v6 产品 tile 重影，duplicate-content ×23）。
+  // 双判据与 richBlocks 护栏同构：壳内文本被列表消费覆盖率 ≥80%，或几何落在列表区（纯几何）。
+  if (Array.isArray(panelRows) && sampleItems.length >= 2) {
+    for (let pi = panelRows.length - 1; pi >= 0; pi -= 1) {
+      const panel = panelRows[pi]
+      const owned = panel.sourceEls || []
+      const consumed = owned.filter((el) => itemTextConsumed.has(el)).length
+      const covered = owned.length > 0 && consumed / owned.length >= 0.8
+      if (covered || overlapsListRow(panel.y, panel.height || 0)) panelRows.splice(pi, 1)
+    }
+  }
+  // 列表数据记录应覆盖全部检测到的行（采样仅供样式中位数等统计），
+  // 否则设计稿 5 行只渲染 3 行，底部留白塌陷。上限 8 行防止异常检测爆量。
+  const allItems = items.slice(0, 8)
+  const shellCardWidth = (spec.size && spec.size.width) || (card.rect && card.rect.width) || 375
+  for (let index = 0; index < items.length; index += 1) {
+    const next = items[index + 1]
+    items[index].rowHeight = next
+      ? Math.max(0, Math.round(next.y - items[index].y))
+      : (index > 0 ? items[index - 1].rowHeight : items[index].contentHeight)
+    const shellCandidates = content.filter((element) => {
+      const elementRect = rect(element)
+      const width = elementRect.width || 0
+      const height = elementRect.height || 0
+      return ['shape', 'group', 'symbol'].includes(element.type)
+        && width >= shellCardWidth * 0.8 && height >= 32 && height <= 160
+        && (elementRect.y || 0) <= items[index].y
+        && items[index].y < (elementRect.y || 0) + height
+        && (elementRect.y || 0) + height <= items[index].y + items[index].rowHeight + 4
+        && Math.abs(height - items[index].rowHeight) <= Math.max(12, items[index].rowHeight * 0.25)
+    }).sort((left, right) => Math.abs((rect(left).height || 0) - items[index].rowHeight)
+      - Math.abs((rect(right).height || 0) - items[index].rowHeight))
+    // 有填充的壳优先：同尺寸包裹层（group/symbol）无 fill，选中它行底色/圆角恒丢
+    shellCandidates.sort((left, right) => {
+      const lf = left.style?.fill
+      const rf = right.style?.fill
+      const lNo = !(lf && (lf.color || lf.gradient)) ? 1 : 0
+      const rNo = !(rf && (rf.color || rf.gradient)) ? 1 : 0
+      return lNo - rNo
+    })
+    const shell = shellCandidates[0]
+    // 视觉行壳判定：满宽 + 无圆角 + 无渐变 = 分区背景板（非行壳）。误认领会把
+    // 内边距/底色/分割线全搅乱（我的账户卡实测 padRight 303 把左栏压没、pos 崩 0.33）
+    const shellVisual = !!shell && ((radiusMax(shell.style) || 0) >= 4
+      || !!shell.style?.fill?.gradient
+      || (rect(shell).width || 0) <= ((rect(card).width || shellCardWidth) - 8))
+    items[index].rowTop = shell ? (rect(shell).y || 0)
+      : (items[index].iconEl ? Math.min(items[index].y, rect(items[index].iconEl).y || items[index].y) : items[index].y)
+    items[index].shellHeight = shell ? (rect(shell).height || items[index].rowHeight) : items[index].rowHeight
+    // 行壳样式/内边距传给列表模板（emit 读 first.fill/gradient/radius/pad*，此前从未赋值 → 行底色恒丢）
+    if (shell) {
+      const sr2 = rect(shell)
+      items[index].shellEl = shell
+      items[index].shellVisual = shellVisual
+      if (shellVisual) {
+        items[index].fill = shell.style?.fill?.color || null
+        items[index].gradient = shell.style?.fill?.gradient || null
+        items[index].opacity = shell.style?.opacity ?? 1
+        items[index].radius = radiusMax(shell.style)
+        // 行内容真实右沿（全部行文本 + 左右图标 + 操作件）：只按金额/时间右沿会把
+        // 标题行卡的 padRight 算成几百 px 挤垮左栏
+        const contentRight = items[index].rowContentRight || ((sr2.x || 0) + (sr2.width || 0) - 16)
+        items[index].padLeft = Math.max(0, Math.round((items[index].rowLeftEdge || 0) - (sr2.x || 0)))
+        items[index].padRight = Math.min(Math.max(0, Math.round(((sr2.x || 0) + (sr2.width || 0)) - contentRight)), Math.round((sr2.width || 0) / 2))
+        items[index].padTop = Math.max(0, Math.round(((sr2.height || 0) - (items[index].contentHeight || 0)) / 2))
+      }
+      items[index].height = Math.round(sr2.height || items[index].rowHeight)
+    } else {
+      items[index].height = items[index].shellHeight || items[index].rowHeight
+      items[index].padLeft = 16
+      items[index].padRight = 16
+      items[index].padTop = 8
+    }
+  // 进度条归属列表行：进度条 y 落在列表行带内时挂到该列表项（逐行渲染），
+  // 否则作为独立语义块渲染（insertSemantic 全堆在卡底/同一 y 位→重叠）。
+  const _listBarEls = new Set()
+  if (items.length && progressBars.length) {
+    for (const bar of progressBars) {
+      const by = bar.y ?? 0
+      const matched = items.find((item) => {
+        const top = item.rowTop ?? item.y ?? 0
+        const bottom = top + (item.shellHeight || item.rowHeight || item.height || 0)
+        return by >= top && by < bottom
+      })
+      if (matched) {
+        if (!matched.bars) matched.bars = []
+        matched.bars.push(bar)
+        if (bar.trackEl) _listBarEls.add(bar.trackEl)
+        for (const el of (bar.segmentEls || [])) _listBarEls.add(el)
+      }
+    }
+    if (_listBarEls.size) {
+      for (let bi = progressBars.length - 1; bi >= 0; bi -= 1) {
+        const bar = progressBars[bi]
+        if ((bar.trackEl && _listBarEls.has(bar.trackEl))
+          || (bar.segmentEls || []).some((el) => _listBarEls.has(el))) {
+          progressBars.splice(bi, 1)
+        }
+      }
+    }
+  }
+  }
+
+  // —— 查看更多 ——
+  const lastItemY = items.length ? lastY + 80 : 0
+  const viewMoreCand = texts.find((t) => {
+    const y = rect(t).y || 0
+    const T = ts(t)
+    const tr = rect(t)
+    const textRight = (tr.x || 0) + (tr.width || 0)
+    const nearRight = textRight >= ((card.rect?.x || 0) + shellCardWidth) - Math.max(64, shellCardWidth * 0.25)
+    const centeredAction = Math.abs(((tr.x || 0) + (tr.width || 0) / 2) -
+      ((card.rect?.x || 0) + shellCardWidth / 2)) <= shellCardWidth * 0.2
+    return items.length > 0 && y > lastY + 40 && (T.color || '').toLowerCase() !== '#000000'
+      && (tr.width || 0) <= shellCardWidth * 0.5 && (nearRight || centeredAction)
+      // 排除已被列表项消费的描述文本（如「可能涉及…请查看确认」含"查看"，不得误当查看更多）
+      && !itemDescConsumed.has(t)
+      // 排除按钮文本（如「全部设为已读」含"全部"，按钮已有独立语义块）
+      && !buttons.some((b) => b.text === textOf(t))
+      && !optionTextSet.has(t) && !optionLabelSet.has(t)
+      && !auxTexts.some((aux) => aux.sourceEl === t)
+      && !postAmountTexts.some((aux) => aux.sourceEl === t)
+      && !itemTextConsumed.has(t)
+      && !panelTextConsumed.has(t) && !formConsumed.has(t)
+  })
+  // 推导"查看更多"与正上方元素的上下间距：从 spec 几何坐标算，不要硬编码
+  // 正上方最近元素底沿（排除全屏背景容器 top<=0/height 接近画板高）与 viewMore.y 之差
+  let viewMoreGapTop = null
+  if (viewMoreCand) {
+    const vmY = rect(viewMoreCand).y || 0
+    const ch = (spec.size && spec.size.height) || 812
+    const allEls = []
+    const collect = (o) => {
+      if (Array.isArray(o)) { o.forEach(collect); return }
+      if (o && typeof o === 'object') {
+        if (o.rect && typeof o.rect.y === 'number') allEls.push(o)
+        for (const k in o) collect(o[k])
+      }
+    }
+    collect(spec)
+    const above = allEls.filter((e) => {
+      const r = e.rect
+      const bottom = (r.y || 0) + (r.height || 0)
+      return bottom <= vmY && (r.y || 0) > 2 && (r.height || 0) < ch * 0.9
+    })
+    if (above.length) {
+      const prevBottom = Math.max(...above.map((e) => (e.rect.y || 0) + (e.rect.height || 0)))
+      viewMoreGapTop = Math.round(vmY - prevBottom)
+    }
+  }
+  const viewMore = viewMoreCand ? {
+    text: textOf(viewMoreCand),
+    color: ts(viewMoreCand).color,
+    fontSize: ts(viewMoreCand).fontSize,
+    height: rect(viewMoreCand).height || (ts(viewMoreCand).fontSize || 14) * 1.4,
+    gapTop: viewMoreGapTop,
+    y: rect(viewMoreCand).y || 0,
+  } : null
+
+  // —— 底部控制件：只用“按钮区下方 + 居中 + 小尺寸近似方形媒体”判定；低置信度的纯文本不建模。
+  const collapseBtn = (() => {
+    const btnRegionBottom = buttonShapes.length
+      ? Math.max(...buttonShapes.map((s) => (rect(s).y || 0) + (rect(s).height || 0)))
+      : 0
+    const mediaSlice = slices.find((s) => {
+      const sr = rect(s)
+      const width = sr.width || 0
+      const height = sr.height || 0
+      const center = (sr.x || 0) + width / 2
+      const cardCenter = (rect(card).x || 0) + ((rect(card).width || 0) / 2)
+      return width >= 12 && width <= 36 && height >= 12 && height <= 36
+        && Math.abs(width - height) <= Math.max(10, width * 0.5)
+        && (sr.y || 0) > btnRegionBottom
+        && Math.abs(center - cardCenter) <= Math.max(24, (rect(card).width || 0) * 0.12)
+    })
+    const textEl = null
+    if (!mediaSlice) return null
+    return {
+      text: textEl ? textOf(textEl) : null,
+      mediaSlice: mediaSlice || null,
+      y: (mediaSlice ? rect(mediaSlice).y : rect(textEl).y) || 0,
+      color: textEl ? ts(textEl).color : '#999999',
+      fontSize: textEl ? ts(textEl).fontSize : 12,
+    }
+  })()
+
+  // —— 通用值绑定扫描器（format + geometry，语义化命名）——
+  // ★ 命名铁律（泛化，非业务硬编码）：
+  //  1. 只认两类信号：① 值「格式」(amount/cardNumber/phone/code/date/name) → 决定绑定表达式；② 空间「共簇」→ 决定哪些值合并为同一对象参数。
+  //  2. 绝不做「这是转账卡的收款人/转出账户」之类业务判定；也不依赖「转账给/收款人/转出/银行/余额」等业务词做识别。
+  //  3. 字段命名双层机制：① 标签词典（references/field_name_dict.json，**领域通用词表**，非卡片硬编码）→ 语义化英文驼峰 key；
+  //     ② 值格式角色兜底（cardNumber/amount/phone/name/date/code）→ 词典未命中时按值格式命名，
+  //     保证永不出现 obj_N / amount_0 序号名。卡片 id 永不进入命名。
+  //  4. 脱敏是「展示层表达式」关注点：数据层只存完整值（* 占位由 unmask 还原），脱敏表达式仅在源文本含 * 时启用，保证展示态=设计态；不另存脱敏字段。
+  const BINDABLE = new Set(['amount', 'cardNumber', 'phone', 'code', 'date'])
+  const bindings = { entities: [], literalBind: {}, multiToken: {} }
+  const _usedKeys = new Set()
+  // 对象级 key：label 命中词典 → entityKey（「转出账号」→ outAccount）；未命中 → 对象内主字段角色名兜底
+  function addObj(labelHint, roles = []) {
+    const ek = entityKeyFor(labelHint)
+    let base = ek
+    if (!base) {
+      // 兜底：按对象内字段角色命名（单角色 → 角色名；多角色 → 主角色+Item，如 amountItem）
+      const rn = [...new Set(roles.filter((r) => ROLE_BASE_NAME[r]))].map((r) => ROLE_BASE_NAME[r])
+      base = rn.length === 1 ? rn[0] : (rn.length > 1 ? rn[0] + 'Item' : 'field')
+    }
+    const k = uniqueKey(base, _usedKeys)
+    bindings.entities.push({ key: k, fields: {} })
+    return k
+  }
+  // 把一个值文本登记为「容器 objKey 下某个格式角色字段」的绑定；label 为字段级语义线索（如子值左侧的「可用余额：」）
+  function bindValue(text, role, containerKey, num, label) {
+    const fk = roleFieldKey(role, label)
+    const v = containerKey + '.' + fk
+    bindings.literalBind[text] = { var: v, expr: valueExpr(role, v, text), default: text, role }
+    const ent = bindings.entities.find((e) => e.key === containerKey)
+    const store = role === 'cardNumber' ? unmask(text)
+      : (role === 'amount' ? (num !== undefined && num !== null ? num : text) : text)
+    let fkey = fk
+    while (Object.prototype.hasOwnProperty.call(ent.fields, fkey)) fkey = fk + '_' + Object.keys(ent.fields).length
+    ent.fields[fkey] = store
+  }
+
+  // 4a. 多值文本行（如「张三 13800138000」单元素含多值）：按 SHAPE 拆分 token，值段绑定，整行归一个 obj。
+  //     前缀剥离词典（仅展示层，不影响识别）：设计稿里联系人/收款人文本常带动词前缀（转账给/收款人 等），
+  //     这些前缀会被 splitValueTokens 的中文 2-4 模式贪婪吃入，导致动词混进 name token。
+  //     词典只负责把这些前缀从 name 中剥出来作字面量展示，**不参与识别**——
+  //     识别完全靠 SHAPE（人名格式+手机号格式），词典增删不影响绑定结果。
+  const verbRe = displayPrefixRe()
+  for (const t of texts) {
+    const raw = (textOf(t) || '').trim()
+    if (!raw) continue
+    const verb = (raw.match(verbRe) || [''])[0] || ''
+    const core = verb ? raw.replace(verbRe, '').trim() : raw
+    // 日期区间/点分单日（2025.11.28-2025.12.04）：整串是单一展示期间，splitValueTokens 会把它
+    // 切成「2025.11」等数字段误绑金额表达式（渲染出千分号）。保持字面量。
+    if (/^\d{4}[-./]\d{1,2}[-./]\d{1,2}(\s*[-~—至]\s*\d{4}[-./]\d{1,2}[-./]\d{1,2})?$/.test(core)) continue
+    const segs = splitValueTokens(core)
+    // 绑定条件（满足其一）：
+    //  ① 含「强值信号」(phone/cardNumber/amount/code/date) —— 实体行（张三 13800138000）；
+    //  ② 「动词前缀 + 纯姓名」（转账给张三）——收款/付款动词后的 2-4 字姓名是明显运行期数据，必须绑定为参数，
+    //     不得留成常量字符串（用户姓名/卡号等动态字段的确定性兜底；智能体复核仍可增补）。
+    //  纯中文句（如"30字以内，默认为转账"，无动词前缀）不得被 2-4 字硬切成 name 字段。
+    const hasStrong = segs.some((s) => BINDABLE.has(s.role))
+    const pureName = verb && segs.length === 1 && segs[0].role === 'name'
+    if ((hasStrong && segs.length > 1) || pureName) {
+      // 对象级命名：原始文本（含动词前缀「转账给」）命中词典 → payee；未命中 → 字段角色兜底
+      const key = addObj(raw, segs.map((s) => s.role))
+      const renderSegs = []
+      if (verb) renderSegs.push({ text: verb.trim(), role: null })
+      for (const s of segs) {
+        if (s.role && (BINDABLE.has(s.role) || s.role === 'name')) {
+          const num = s.role === 'amount' ? parseAmount(s.text) : undefined
+          bindValue(s.text, s.role, key, num)
+          const fk = roleFieldKey(s.role)
+          renderSegs.push({ text: s.text, role: s.role, expr: valueExpr(s.role, key + '.' + fk, s.text), default: s.text })
+        } else {
+          renderSegs.push({ text: s.text, role: null })
+        }
+      }
+      bindings.multiToken[raw] = renderSegs
+    }
+  }
+
+  // 4b. 标题与主金额之间的同 y 文本簇（几何聚类，不暗示任何业务含义）：仅绑定格式值（code 等），其余按字面量。
+  if (midCluster) {
+    const roles = midCluster.items.map((it) => classifyValue(it.text)).filter((r) => BINDABLE.has(r))
+    const key = addObj(null, roles)
+    for (const it of midCluster.items) {
+      const role = classifyValue(it.text)
+      if (BINDABLE.has(role)) bindValue(it.text, role, key)
+    }
+  }
+
+  // 4c. 表单行右簇：值 + 子值共簇 → 一个 obj（如 卡号 + 同簇金额）。几何共簇 + 值格式信号，不靠「转出/余额」等业务词。
+  //     字段级语义：对象 key 用左标签词典（转出账号→outAccount）；子值字段用其同行左侧文本词典（可用余额：→availableBalance）。
+  for (const fr of formRows) {
+    const cands = []
+    if (fr.value) cands.push({ text: fr.value.text, role: classifyValue(fr.value.text), label: fr.label.text })
+    for (const sv of (fr.subValues || [])) {
+      // 子值字段级语义线索：同行（±12px）x 更小的文本（如「可用余额：」）作为 labelHint
+      const leftLabel = (fr.subValues || []).filter((o) => o !== sv && (o.x || 0) < (sv.x || 0) && Math.abs((o.y || 0) - (sv.y || 0)) <= 12)
+        .sort((a, b) => (b.x || 0) - (a.x || 0))[0]
+      cands.push({ text: sv.text, role: classifyValue(sv.text), label: leftLabel ? leftLabel.text : null })
+    }
+    const bindable = cands.filter((c) => BINDABLE.has(c.role))
+    if (!bindable.length) continue
+    const key = addObj(fr.label.text, bindable.map((c) => c.role))
+    for (const c of bindable) bindValue(c.text, c.role, key, c.role === 'amount' ? parseAmount(c.text) : undefined, c.label)
+  }
+
+  // 4d. 通栏分隔线：细长几何壳/符号是显式结构边界，不能因宽度阈值被孤立块过滤丢弃。
+  const dividerElements = [...shapes, ...symbols].filter((element) => {
+    const er = rect(element)
+    return (er.width || 0) >= cardWidth * 0.6 && (er.height || 0) <= 2
+      && (er.y || 0) >= ((rect(card).y || 0) + 8)
+      && ((er.y || 0) + (er.height || 0)) <= (((rect(card).y || 0) + (rect(card).height || 0)) - 8)
+      && !buttonShapes.some((button) => overlapRatio(element, button) > 0.5)
+      && !(symbolMediaRows.length >= 2 && (() => {
+        const top = Math.min(...symbolMediaRows.map((row) => row.y || 0))
+        const bottom = Math.max(...symbolMediaRows.map((row) => (row.y || 0) + (row.height || 0)))
+        const y = rect(element).y || 0
+        return y > top && y < bottom && symbolMediaRows.every((row) => y !== (row.y || 0) + (row.height || 0))
+      })())
+      && !(sampleItems.length >= 2 && (() => {
+        const top = Math.min(...sampleItems.map((item) => item.y || 0))
+        const itemGaps = sampleItems.slice(1).map((item, index) =>
+          (item.y || 0) - (sampleItems[index].y || 0)).filter((gap) => gap > 0)
+        const itemHeight = itemGaps.length ? itemGaps.sort((a, b) => a - b)[Math.floor(itemGaps.length / 2)] : 40
+        const bottom = Math.max(...sampleItems.map((item) =>
+          (item.y || 0) + (item.height || itemHeight)))
+        const y = rect(element).y || 0
+        return y > top && y < bottom && sampleItems.every((item) => y !== (item.rowTop ?? item.y) + (item.shellHeight || item.rowHeight || 0))
+      })())
+  })
+  const dividerCandidates = dividerElements.map((element) => ({
+    element,
+    x: rect(element).x || 0,
+    y: rect(element).y || 0,
+    width: rect(element).width || 0,
+    height: rect(element).height || 1,
+    color: element.style?.fill?.color || element.style?.background?.color || null,
+  })).sort((a, b) => Number(!!b.color) - Number(!!a.color))
+  const dividers = []
+  for (const candidate of dividerCandidates) {
+    if (!dividers.some((existing) => overlapRatio(candidate.element, existing.element) >= 0.4)) dividers.push(candidate)
+  }
+
+  // Reclassify small action buttons (e.g., verification code resend) as form row affordances
+  // instead of primary buttons. Small buttons that overlap with form rows by Y range
+  // and have width < 50% of card width are action buttons, not primary buttons.
+  const _cardWidth = rect(card).width || spec.size?.width || 375
+  for (let bi = buttons.length - 1; bi >= 0; bi--) {
+    const btn = buttons[bi]
+    const btnY = btn.y || 0
+    const btnHeight = btn.height || 0
+    const btnWidth = btn.sourceEl ? (() => {
+      const btnText = btn.text
+      const txt = texts.find((t) => textOf(t) === btnText)
+      if (!txt) return _cardWidth
+      const tr = rect(txt)
+      // Find the SMALLEST shape that contains the button text (not the card panel)
+      const containingShapes = shapes.filter((s) => {
+        const sr = rect(s)
+        return (tr.x || 0) >= (sr.x || 0) && (tr.x || 0) + (tr.width || 0) <= (sr.x || 0) + (sr.width || 0)
+          && (tr.y || 0) >= (sr.y || 0) && (tr.y || 0) + (tr.height || 0) <= (sr.y || 0) + (sr.height || 0)
+      }).sort((a, b) => (rect(a).width || 0) * (rect(a).height || 0) - (rect(b).width || 0) * (rect(b).height || 0))
+      return containingShapes[0] ? rect(containingShapes[0]).width || 0 : _cardWidth
+    })() : _cardWidth
+    if (btnWidth < _cardWidth * 0.5) {
+      const matchingFormRow = formRows.find((fr) => {
+        const frTop = fr.label?.y || 0
+        const frBottom = Math.max(...[fr.value, ...(fr.subValues || []), fr.label]
+          .filter(Boolean).map((item) => (item.y || 0) + (item.height || (item.fontSize || 14) * 1.4)))
+        return btnY >= frTop - 10 && btnY <= frBottom + 10
+      })
+      if (matchingFormRow) {
+        matchingFormRow.rightActionButton = btn
+        // 同面板挂接：按钮文本随按钮消费，防 buttons 摘除后被辅助文案路径重渲染
+        if (btn.sourceEl) formConsumed.add(btn.sourceEl)
+        buttons.splice(bi, 1)
+     }
+   }
+ }
+
+  // 小 pill 挂接到垂直重叠的辅助文案行（标题行右侧操作件）。
+  // 独立成行会在标题与下一行之间撑出一段行高把下方内容压下去（曾致标题行下方整段下漂）。
+  // 只认领：小尺寸（w<80）+ 中心在卡中线右侧 + 中心落在 aux 行竖直带内 + 在 aux 文本右侧。
+  for (let bi = buttons.length - 1; bi >= 0; bi -= 1) {
+    const btn = buttons[bi]
+    if ((btn.width || 0) >= 80) continue
+    const btnCy = (btn.y || 0) + (btn.height || 0) / 2
+    const btnCx = (btn.x || 0) + (btn.width || 0) / 2
+    const cardCx = (rect(card).x || 0) + (rect(card).width || 375) / 2
+    if (btnCx <= cardCx) continue
+    const aux = (auxTexts || []).find((a) => {
+      if (a.rightActionButton) return false
+      const bandTop = (a.y || 0) - 8
+      const bandBottom = (a.y || 0) + Math.max(a.height || 0, (a.fontSize || 14) * 1.5) + 8
+      return btnCy >= bandTop && btnCy <= bandBottom
+        && (btn.x || 0) >= (a.x || 0) + (a.width || 0)
+    })
+    if (!aux) continue
+    aux.rightActionButton = btn
+    if (btn.sourceEl) formConsumed.add(btn.sourceEl)
+    buttons.splice(bi, 1)
+  }
+
+  // —— 标题下划线（accent underline）：标题文本正下方的彩色窄矩形 ——
+  // 检测条件：shape，高度 2-15px，非白/非透明背景色，位于某个文本元素正下方（间距 ≤16px，x 对齐）
+  const NEUTRAL_COLORS = new Set(['#FFFFFF', '#FFF', '#000000', '#000', '#FAFAFA', '#F5F5F5',
+    '#F8F8F8', '#F0F0F0', '#EEEEEE', '#E9ECF2', '#E5E5E5', '#CCCCCC', '#DDDDDD', 'NONE', ''])
+  const titleUnderlines = []
+  for (const shape of shapes) {
+    if (dividerElements.includes(shape) || buttonShapes.includes(shape)) continue
+    const sr = rect(shape)
+    const sh = sr.height || 0
+    const sw = sr.width || 0
+    if (sh < 2 || sh > 15) continue
+    if (sw < 16) continue
+    const bgRaw = shape.style?.background?.color || shape.style?.fill?.color || ''
+    const bg = (bgRaw || '').toUpperCase()
+    if (!bg || NEUTRAL_COLORS.has(bg)) continue
+    const matchingText = texts.find((t) => {
+      // 数值文本（汇总区金额）不与下划/高亮带配对：比例条(h=4)曾被误认为金额层下划，
+      // 吞掉汇总区次列值（300.00 丢失）。
+      if (isAmountish(textOf(t))) return false
+      const tr = rect(t)
+      const tBottom = (tr.y || 0) + (tr.height || 0)
+     const gap = (sr.y || 0) - tBottom
+      // 允许部分重叠（下划线可能在文本底边之上几像素开始）
+      if (gap < -16 || gap > 16) return false
+     const tLeft = tr.x || 0
+      const tRight = (tr.x || 0) + (tr.width || 0)
+      const overlap = Math.min((sr.x || 0) + sw, tRight) - Math.max(sr.x || 0, tLeft)
+      if (overlap < Math.min(sw, (tr.width || 0)) * 0.3) return false
+      return true
+    })
+    if (matchingText) {
+      const tr = rect(matchingText)
+      titleUnderlines.push({
+        textEl: matchingText,
+        text: textOf(matchingText),
+        color: bgRaw,
+        y: sr.y || 0,
+        x: sr.x || 0,
+        width: sw,
+        height: Math.max(sh, 4),
+        opacity: shape.style?.opacity ?? 1,
+        textBottom: (tr.y || 0) + (tr.height || 0),
+        gap: (sr.y || 0) - ((tr.y || 0) + (tr.height || 0)),
+      })
+    }
+  }
+
+  // —— 孤儿大切片：未被任何语义结构消费、且无导出素材/裁切的大块切片（典型：烘焙成图的按钮/横幅）——
+  // 不渲染会整块丢失（如底部主按钮）。纯色采样近似由 generate() 在有设计稿时补色。
+  const orphanConsumed = new Set([
+    ...formSliceEls, ...auxSliceEls, ...repeatedRightAffordanceEls,
+    ...symbolMediaRows.map((row) => row.symbolEl),
+    ...isolatedBlocks.map((block) => block.element),
+    ...(panelRows || []).flatMap((panel) => [panel.leftSlice, panel.rightSlice]),
+    topDecoration?.sliceEl, topDecoration?.iconSlice,
+    midCluster?.logoSlice,
+    primaryAmount?.iconSlice,
+  ].filter(Boolean))
+const orphanSlices = slices.filter((s) => {
+  if (orphanConsumed.has(s)) return false
+  if (floatDecos.includes(s)) return false
+  const sr = rect(s)
+  const w = sr.width || 0, h = sr.height || 0
+  const cRf = rect(card)
+  // 浮动装饰切片（卡头月亮/吉祥物光晕等）：竖直方向与文本带重叠、水平贴卡缘 →
+  // 不能占流式行高（否则整卡内容被顶下一个装饰高度），改由绝对定位叠层渲染。
+  const overlapsText = texts.some((t) => {
+    const tr = rect(t)
+    const ov = Math.min((sr.y || 0) + h, (tr.y || 0) + (tr.height || 0)) - Math.max(sr.y || 0, tr.y || 0)
+    return ov >= h * 0.2 && h >= (tr.height || 0) * 2.2
+  })
+  const edgeAnchored = ((sr.x || 0) + w) >= ((cRf.x || 0) + (cRf.width || 0)) - 24
+  if (overlapsText && edgeAnchored && w <= (cRf.width || 375) * 0.5
+    && !buttonShapes.some((b) => coverRatio(s, b) > 0.5)
+    && !panelCandidates.some((p) => coverRatio(s, p) > 0.5)) {
+    floatDecos.push(s)
+    return false
+  }
+  return w >= 60 && h >= 24 && h <= 140 && w <= (rect(card).width || 375) + 40
+})
+
+  // —— 背景壳层（section/行/面板壳）：带圆角填充的中型 shape，供列表行样式、表单行包裹、段落底色认领 ——
+  // 此前卡宽壳被 isBg 排除、行壳因「壳高 vs 行 pitch 差 12px」超容差漏配，列表行/面板/段落全部丢底色。
+  const shellLayers = (card.elements || []).filter((e) => {
+    if (e.type !== 'shape') return false
+    const f = e.style?.fill
+    if (!f || (!f.color && !f.gradient)) return false
+    if (radiusMax(e.style) < 4) return false
+    const r = rect(e)
+    const cR = rect(card)
+    const w = r.width || 0
+    const h = r.height || 0
+    if (w < (cR.width || 0) * 0.4 || w > (cR.width || 0) + 4) return false
+    if (h < 40 || h > (cR.height || 0) * 0.6) return false
+    return true
+  }).map((e) => ({
+    el: e,
+    x: rect(e).x || 0, y: rect(e).y || 0, width: rect(e).width || 0, height: rect(e).height || 0,
+    fill: e.style?.fill?.color || null,
+    gradient: e.style?.fill?.gradient || null,
+    radius: radiusMax(e.style),
+    opacity: e.style?.opacity ?? 1,
+  }))
+
+  // —— 薄壳通道（行级描边/浅填充窄矩形）——
+  // 容器级壳由 panelRows / gradientPanels 认领，壳层背景由 shellLayers 认领（要求 h>=40 且 radius>=4）；
+  // 行级薄壳（h 18..48、radius<=6、带描边或填充）两头落空 → 描边与底色整体丢失：
+  // 表格行只剩裸文本，无文本的分段壳被当孤立媒体块渲染成「缺素材」占位图。
+  const thinShellStyle = (shape) => {
+    const sr = rect(shape)
+    const border = shape.style?.border || {}
+    const fill = shape.style?.fill || {}
+    return {
+      shapeEl: shape,
+      x: sr.x || 0, y: sr.y || 0, width: sr.width || 0, height: sr.height || 0,
+      fill: fill.color || null,
+      gradient: fill.gradient || null,
+      opacity: shape.style?.opacity ?? 1,
+      radius: radiusMax(shape.style),
+      isBorder: !!border.isBorder,
+      borderWidth: Number(border.width) || 0,
+      borderColor: border.color || null,
+    }
+  }
+  const thinInside = (element, shape) => {
+    const er = rect(element)
+    const sr = rect(shape)
+    return (er.x || 0) >= (sr.x || 0) - 2 && (er.y || 0) >= (sr.y || 0) - 2
+      && ((er.x || 0) + (er.width || 0)) <= ((sr.x || 0) + (sr.width || 0)) + 2
+      && ((er.y || 0) + (er.height || 0)) <= ((sr.y || 0) + (sr.height || 0)) + 2
+  }
+  const thinShellShapes = (card.elements || []).filter((element) => {
+    if (element.type !== 'shape') return false
+    const sr = rect(element)
+    const cR = rect(card)
+    const w = sr.width || 0
+    const h = sr.height || 0
+    if (h < 18 || h > 48) return false
+    if (w < (cR.width || 0) * 0.2 || w > (cR.width || 0) + 4) return false
+    if (radiusMax(element.style) > 6) return false
+    const border = element.style?.border || {}
+    const fill = element.style?.fill || {}
+    if (!border.isBorder && !fill.color && !fill.gradient) return false
+    if (panelShapes.includes(element) || optionShapeSet.has(element)) return false
+    if (gradientPanels.some((gp) => gp.shapeEl === element)) return false
+    // 与卡身同色且无描边/渐变 = 卡底延续补片，不是行壳
+    if (!border.isBorder && !fill.gradient
+      && String(fill.color || '').toUpperCase() === String(card.cardFill || '').toUpperCase()) return false
+    return true
+  })
+  const thinShellRows = []
+  const thinShellStrips = []
+  {
+    const freeShells = []
+    for (const shape of thinShellShapes) {
+      const inner = texts.filter((t) => thinInside(t, shape))
+      if (inner.length) thinShellRows.push({ ...thinShellStyle(shape), texts: inner })
+      else freeShells.push(shape)
+    }
+    // 无文本薄壳按「同 y 带 + 首尾相接（间隙 <=8）」聚成分段横条（时间轴/进度分段）；
+    // 单壳不成条，保持原孤立媒体块兜底，>=2 段才按几何分段还原。
+    const ordered = freeShells.slice().sort((a, b) =>
+      (rect(a).y || 0) - (rect(b).y || 0) || (rect(a).x || 0) - (rect(b).x || 0))
+    const claimed = new Set()
+    for (const shape of ordered) {
+      if (claimed.has(shape)) continue
+      const sr = rect(shape)
+      const members = [shape]
+      claimed.add(shape)
+      let cursor = (sr.x || 0) + (sr.width || 0)
+      for (const other of ordered) {
+        if (claimed.has(other)) continue
+        const or = rect(other)
+        if (Math.abs((or.y || 0) - (sr.y || 0)) > 4) continue
+        if ((or.x || 0) < cursor - 2 || (or.x || 0) - cursor > 8) continue
+        members.push(other)
+        claimed.add(other)
+        cursor = (or.x || 0) + (or.width || 0)
+      }
+      if (members.length < 2) continue
+      members.sort((a, b) => (rect(a).x || 0) - (rect(b).x || 0))
+      const boxes = members.map(thinShellStyle)
+      const left = Math.min(...boxes.map((box) => box.x))
+      const right = Math.max(...boxes.map((box) => box.x + box.width))
+      thinShellStrips.push({
+        x: left,
+        y: Math.min(...boxes.map((box) => box.y)),
+        width: right - left,
+        height: Math.max(...boxes.map((box) => box.height)),
+        boxes,
+      })
+    }
+  }
+  // 分段横条认领的壳不再作孤立媒体块（否则同一几何渲染成「缺素材」占位图）
+  const thinStripEls = new Set(thinShellStrips.flatMap((strip) => strip.boxes.map((box) => box.shapeEl)))
+  for (let index = isolatedBlocks.length - 1; index >= 0; index -= 1) {
+    if (thinStripEls.has(isolatedBlocks[index].element)) isolatedBlocks.splice(index, 1)
+  }
+
+  // —— 壳内右列文本（两列拓扑）——
+  // 内容壳（面板壳/渐变壳）右半区独立成列的文本：>=2 个文本左边界落在壳宽 45% 之后且互相成列
+  // （x 差 <=8、分属不同行），壳内左侧另有 >=2 个文本 → 该壳是「左列 + 右列」拓扑而非竖排单列。
+  // 此前右列文本或被压成竖排堆叠（panelRows 路径），或整段落进主视觉死区不渲染（渐变壳路径）。
+  const shellButtonTextEls = new Set(buttons.map((button) => button.sourceEl).filter(Boolean))
+  const shellRightColumns = []
+  for (const shape of [...new Set([...panelShapes, ...gradientPanels.map((gp) => gp.shapeEl)])]) {
+    const sr = rect(shape)
+    const inner = texts.filter((t) => thinInside(t, shape) && !shellButtonTextEls.has(t))
+    if (inner.length < 4) continue
+    const topY = Math.min(...inner.map((t) => rect(t).y || 0))
+    // 标题行（与壳内首个文本同 band）整体保留为整行：名称 + 紧邻短标签不是右列成员
+    const headerEls = inner.filter((t) => Math.abs((rect(t).y || 0) - topY) <= 8)
+    const headerSet = new Set(headerEls)
+    const splitX = (sr.x || 0) + (sr.width || 0) * 0.45
+    const columns = []
+    for (const t of inner.filter((item) => !headerSet.has(item) && (rect(item).x || 0) >= splitX)
+      .slice().sort((a, b) => (rect(a).x || 0) - (rect(b).x || 0))) {
+      const tx = rect(t).x || 0
+      const column = columns.find((c) => Math.abs(c.x - tx) <= 8)
+      if (column) column.items.push(t)
+      else columns.push({ x: tx, items: [t] })
+    }
+    const best = columns
+      .filter((column) => column.items.length >= 2
+        && new Set(column.items.map((t) => Math.round(rect(t).y || 0))).size >= 2)
+      .sort((a, b) => b.items.length - a.items.length)[0]
+    if (!best) continue
+    const bestSet = new Set(best.items)
+    const left = inner.filter((t) => !headerSet.has(t) && !bestSet.has(t) && (rect(t).x || 0) < splitX)
+    if (left.length < 2) continue
+    shellRightColumns.push({
+      shapeEl: shape,
+      x: sr.x || 0, y: sr.y || 0, width: sr.width || 0, height: sr.height || 0,
+      splitX: best.x,
+      headerEls,
+      texts: best.items.slice().sort((a, b) => (rect(a).y || 0) - (rect(b).y || 0)).map((t) => ({
+        text: textOf(t),
+        color: ts(t).color,
+        fontSize: ts(t).fontSize,
+        fontWeight: ts(t).fontWeight,
+        align: ts(t).textAlign,
+        sourceEl: t,
+        x: rect(t).x || 0, y: rect(t).y || 0,
+        width: rect(t).width || 0, height: rect(t).height || 0,
+      })),
+    })
+  }
+  const shellRightColEls = new Set(shellRightColumns.flatMap((column) => column.texts.map((t) => t.sourceEl)))
+  // 右列文本改由两列拓扑通道渲染：从辅助文案 / 副金额对中回收，避免竖排重影或甩到壳外
+  for (let index = auxTexts.length - 1; index >= 0; index -= 1) {
+    if (shellRightColEls.has(auxTexts[index].sourceEl)) auxTexts.splice(index, 1)
+  }
+ for (let index = subAmounts.length - 1; index >= 0; index -= 1) {
+   const item = subAmounts[index]
+   if (shellRightColEls.has(item.labelEl) || shellRightColEls.has(item.valueEl)) subAmounts.splice(index, 1)
+ }
+ // 右列文本 / 面板成员文本不得经 postAmountTexts 双份渲染（面板两列拓扑已整块接管）。
+ // postAmountTexts 早于 shellRightColumns 计算，此前只从 auxTexts 回收——
+ // listTitle 为 null 时 postAmountTexts 上界=∞，面板内文本漏入独立文本行→重影。
+ for (let index = postAmountTexts.length - 1; index >= 0; index -= 1) {
+   if (shellRightColEls.has(postAmountTexts[index].sourceEl)
+     || panelTextConsumed.has(postAmountTexts[index].sourceEl)) postAmountTexts.splice(index, 1)
+ }
+
+// 选项组文本字符串集：midCluster 与选项组命中同一批文本时（图标+标签 chip 行），
+// midCluster 再渲染一遍即重影（chip 行双份）→ 选项组优先，midCluster 让位。
+const optionTextStrings = new Set([...optionTextSet].map((t) => textOf(t)))
+ return {
+   canvas: spec.size || { width: 375, height: 812 },
+    artboardType: spec.artboardType || 'card',
+    cardRect: rect(card), // 卡片容器几何（用于底部留白/顶部留白几何推导）
+    cardFill: card.cardFill || null,
+    // 契约 skills/shared/spec-contract.md §cards[].mask.radius：
+    //   null = 上游没找到带圆角的卡壳（_card_mask_info 返回 (None, fill)），
+    //   下游兜底点在 v3_assemble.mjs 的 `sem.cardRadius || T.radius('card')`（契约规定的默认圆角）。
+    // 取用必须用 ?? 而非 ||：`radius[0] === 0` 是合法值（真·直角卡），用 || 会被吞成 null
+    // 从而错误地套上默认圆角。（存量数据无此值，属防御性修正。）
+    cardRadius: card.mask?.radius?.[0] ?? null,
+    tabs, buttons, optionGroups, primaryAmount, subAmounts, auxTexts, postAmountTexts, tabY, badgeRows,
+    topTintBlobs,
+    listTitle, sampleItems, allItems, viewMore, collapseBtn, countdown, topDecoration, formRows, midCluster: midCluster && (midCluster.items || []).length >= 2 && !(midCluster.items || []).every((it) => optionTextStrings.has(it.text)) ? midCluster : null, bindings,
+    enumStatMap, // 枚举统计行预扫描结果（raw 文本 → {items, sep}）
+    cardBackgroundGradient: fullCardGradientShape?.style?.fill?.gradient || null,
+    symbolMediaRows,
+    isolatedBlocks,
+    progressBars,
+   dividers,
+   panelRows,
+    titleUnderlines,
+   subAmountPanel,
+    orphanSlices: (orphanSlices || []).filter((s) => !_vertexConsumedEls.has(s)),
+    floatDecos: (floatDecos || []).filter((fd) => !_vertexConsumedEls.has(fd)),
+    thinShellRows, thinShellStrips, shellRightColumns,
+    gradientPanels, panelGroup,
+    richBlocks,
+    chartClusters,
+    vertexClusters,
+    shellLayers,
+   contentBounds: (() => {
+     const cardWidth = rect(card).width || 0
+     const cardHeight = rect(card).height || 0
+     const leaves = content.filter((element) => {
+       const er = rect(element)
+        const hasText = !!textOf(element)
+        return hasText || !((er.width || 0) >= cardWidth * 0.95)
+     })
+     // bottom 仅取文本元素（shapes/slices 可能延伸到文本之下，导致底部留白被低估）
+     const textLeaves = leaves.filter((e) => !!textOf(e))
+     const bottomLeaves = textLeaves.length ? textLeaves : leaves
+     // 例外：语义壳（渐变壳/面板组成员）会作为流内内容块真实渲染，壳底沿即内容底沿。
+     // 壳内文本距壳底常有内边距——只看文本底会把底 padding 高估（卡片被撑高，如喜豆惠选
+     // 产品卡文本底 1192 vs 壳底 1212 → 底距被算成 36 而非 16）。
+     const shellBottoms = [
+       ...(gradientPanels || []),
+       ...((panelGroup && panelGroup.items) || []),
+     ].filter((p) => bottomLeaves.some((el) => {
+       const ey = rect(el).y || 0
+       return ey >= (p.y || 0) - 2 && ey < (p.y || 0) + (p.height || 0) - 2
+     })).map((p) => (p.y || 0) + (p.height || 0))
+      return {
+        top: leaves.length ? Math.min(...leaves.map((element) => rect(element).y || 0)) : rect(card).y || 0,
+        bottom: bottomLeaves.length ? Math.max(
+          ...bottomLeaves.map((element) => (rect(element).y || 0) + (rect(element).height || 0)),
+          ...shellBottoms,
+        ) :
+          (rect(card).y || 0) + (rect(card).height || 0),
+        left: textLeaves.length ? Math.min(...textLeaves.map((element) => rect(element).x || 0)) : rect(card).x || 0,
+        right: textLeaves.length ? Math.max(...textLeaves.map((element) =>
+          (rect(element).x || 0) + (rect(element).width || 0))) :
+          (rect(card).x || 0) + (rect(card).width || 0),
+      }
+    })(),
+    slices: slices.filter((s) => !_vertexConsumedEls.has(s)).map((s) => s),
+    slicesExports: spec.slices || [],
+    allTexts: texts.map((t) => ({ text: textOf(t), ...ts(t), sourceEl: t })),
+  }
+}
+
+/* ============================== 1.5 语义决策层（Phase 2：启发式提名，AI 终审） ============================== */
+// 原则：sem 里的元素引用（sourceEl）参与同一性排除（shell.texts.includes / rendered.has），
+// JSON 全量往返会破坏身份 → **禁止**把整份 sem 序列化后回灌。
+// 决策层只开放「与元素身份无关」的裁决字段；含元素引用的字段只允许 null（禁用提名）或经 relink 重建。
+
+// 决策视图：sem 中可被 AI 审阅/修改的字段投影（元素引用全部剥离，JSON 安全）。
+export function semDecisionsView(sem) {
+  const strip = (v) => JSON.parse(JSON.stringify(v, (k, val) => (k === 'sourceEl' ? undefined : val)))
+  const textish = (e) => (e ? { text: textOf(e) } : null)
+  return {
+    artboardType: sem.artboardType || 'card',
+    bindings: strip(sem.bindings || { entities: [], literalBind: {}, multiToken: {} }),
+    countdown: sem.countdown
+      ? strip({ ...sem.countdown, consumed: undefined })
+      : null,
+    cardFill: sem.cardFill || null,
+    cardBackgroundGradient: sem.cardBackgroundGradient || null,
+    listTitle: textish(sem.listTitle),
+    viewMore: textish(sem.viewMore),
+    collapseBtn: textish(sem.collapseBtn),
+    primaryAmount: sem.primaryAmount ? { text: sem.primaryAmount.text } : null,
+    formRows: (sem.formRows || []).map((f) => ({
+      label: f.label ? (f.label.text || textOf(f.label)) : '',
+      value: f.value ? (f.value.text || textOf(f.value)) : null,
+      isPlaceholder: !!f.isPlaceholder,
+    })),
+    // 可禁用的提名字段（decisions.disable 数组里的名字会把 sem[k] 置 null）
+    disableable: ['listTitle', 'viewMore', 'collapseBtn', 'countdown', 'topDecoration', 'midCluster'],
+  }
+}
+
+// countdown 决策回灌：AI 只给纯数据（numberText/unitText/几何/配色），
+// consumed（参与渲染排除的元素引用）按文本+几何从 spec 重链，否则数字与单位会双重渲染。
+function relinkCountdownConsumed(spec, cardIndex, cd) {
+  const card = (spec.cards || [])[Number(cardIndex) || 0] || {}
+  const all = (card.elements || []).length ? card.elements : (spec.elements || [])
+  const texts = all.filter((e) => e.type === 'text' && textOf(e))
+  const numEl = texts.find((t) => textOf(t) === String(cd.numberText))
+  if (!numEl) return null // 无法定位数字元素 → 提名不可重建，按无倒计时处理
+  const unitEl = texts.find((t) => t !== numEl && /^[Ss秒分]$/.test(textOf(t))
+    && Math.abs((rect(t).x || 0) - (rect(numEl).x || 0)) < 40
+    && Math.abs((rect(t).y || 0) - (rect(numEl).y || 0)) < 30)
+  return { ...cd, consumed: [numEl, unitEl].filter(Boolean) }
+}
+
+// 白名单覆盖：decisions 之外的字段一律忽略（几何证据保持脚本所有，AI 只改裁决）。
+export function applySemDecisions(sem, spec, cardIndex, decisions) {
+  const d = decisions || {}
+  if (typeof d.artboardType === 'string' && d.artboardType) sem.artboardType = d.artboardType
+  if (d.bindings && typeof d.bindings === 'object') sem.bindings = d.bindings
+  if ('countdown' in d) sem.countdown = d.countdown ? relinkCountdownConsumed(spec, cardIndex, d.countdown) : null
+  if ('cardFill' in d) sem.cardFill = d.cardFill
+  if ('cardBackgroundGradient' in d) sem.cardBackgroundGradient = d.cardBackgroundGradient
+  for (const k of d.disable || []) { if (k in sem) sem[k] = null }
+  return sem
+}