cardbuddy 0.15.0 → 0.16.0

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

@@ -0,0 +1,315 @@
+/**
+ * component_contract.mjs — 组件契约（className 白名单 + 属性键白名单 + 样式组/子键白名单）单一来源。
+ *
+ * 为什么需要它（2026-09-24 gen-1 实测事故）：
+ *   模型给 Image 节点写了 `itemKey: "image"`，而 Image 组件元数据里**只有一个属性键 `value`**
+ *   （itemName「图片地址」，itemTypeRange "image,var"）。运行时按 itemKey 绑定组件 props，
+ *   不存在的键**被整条静默丢弃** ⇒ value 为空 ⇒ 图片走 DEFAULT_IMAGE_URL ⇒ 渲染成破图。
+ *   而当时的四道闸**全部放行**：
+ *     - validate_schema.py：只查结构，属性键不是它的管辖范围
+ *     - lint_card.mjs：没有属性键规则
+ *     - preflight.mjs：Check 3 / Check 5 都用 `getProp(n,'value')`，取不到就直接 `continue`
+ *       —— 键名写错反而把整条检查链**短路**了
+ *     - iterate 的 elements.missing：只比对文本，不比对图片
+ *   全仓 82 处 Image 里 81 处写 `value`，唯一写 `image` 的就是这一处 ⇒ 这是模型偶发编造键名，
+ *   必须有机械兜底，不能指望它每次都对。
+ *
+ * 口径同源：preflight / lint_card / readiness / gate 一律 import 本模块，
+ * **禁止各写一份白名单**（否则出现「文档教 A、门禁判 A 违规」的死结）。
+ */
+import fs from 'node:fs'
+import path from 'node:path'
+
+/**
+ * 渲染器内建、但不在 component-meta.json 里的类。
+ *
+ * `Root` = 卡片根容器。card-editor/runtime/node-model.js 明写：
+ *   「根节点 className "Root" 不在组件 meta 里，这里合成一份：无属性、无插槽、样式全开」。
+ * 所以：className 合法、样式组照常校验、**属性键不校验**（ROOT_META 里根本没有 properties 概念，
+ * 也就不存在「非法属性键」）。全仓 75 张卡的根节点实测 0 张带 properties。
+ */
+const BUILTIN_CLASSES = new Set(['Root'])
+
+/** 不做属性键校验的类（见 BUILTIN_CLASSES 说明）。 */
+const NO_PROP_CHECK = new Set(['Root'])
+
+/**
+ * 复现器（repeater）判定：**由元数据推导，不写类名**。
+ *
+ * 为什么需要：`slots[].slotKey` 实测**恒为 `default`**（全仓 1010 个 slot 无一例外，
+ * Row 597 / Column 328 / ListLayout 54 / AbsoluteLayout 20 / GridLayout 11），
+ * 所以「子节点存在 slot.components 里」**不等于**「处在列表项作用域里」——
+ * 按 slotKey 或按「有没有 slot」判断会把整棵树的引用都当成列表项字段（实测 gen-1 21 条引用
+ * 被全部误判进槽位，变量绑定门禁因此整条失效）。
+ *
+ * 判据 = 同时满足两条：① 元数据声明了 `value` 属性（数组数据源）；② 有 `default` 插槽。
+ * 命中者即「按数据源循环渲染子节点」的容器，其插槽内的 `$field` 才是 item 字段。
+ */
+function deriveRepeaterClasses(cm) {
+  const out = new Set()
+  for (const [cls, def] of Object.entries(cm?.components || {})) {
+    const hasValueProp = (def?.properties || []).some((p) => p && p.itemKey === 'value')
+    const slots = def?.slots || def?.slotList || []
+    const hasDefaultSlot = slots.some((s) => String(s?.slotKey || s?.key || s) === 'default')
+    if (hasValueProp && hasDefaultSlot) out.add(cls)
+  }
+  return out
+}
+
+/**
+ * 读取并编译契约。
+ *
+ * @param {object} opts
+ * @param {string} opts.metaDir 元数据目录（含 component-meta.json / style-meta.json）
+ * @returns {{
+ *   classes: Set<string>,
+ *   propKeys: Map<string, Set<string>>,
+ *   propMeta: Map<string, Map<string, object>>,
+ *   styleGroups: Map<string, Set<string>>,
+ *   repeaterClasses: Set<string>,
+ *   loaded: { components: boolean, styles: boolean },
+ * }}
+ */
+export function loadContract({ metaDir }) {
+  const out = {
+    classes: new Set(BUILTIN_CLASSES),
+    propKeys: new Map(),
+    propMeta: new Map(),
+    styleGroups: new Map(),
+    repeaterClasses: new Set(),
+    loaded: { components: false, styles: false },
+  }
+
+  // ── 组件契约 ──
+  const cmPath = path.join(metaDir, 'component-meta.json')
+  try {
+    const cm = JSON.parse(fs.readFileSync(cmPath, 'utf8'))
+    for (const [cls, def] of Object.entries(cm?.components || {})) {
+      out.classes.add(cls)
+      const keys = new Set()
+      const metaByKey = new Map()
+      for (const p of def?.properties || []) {
+        const k = p?.itemKey
+        // 关键：**跳过没有 itemKey 的属性项**。
+        // Text / Button 的元数据里有「常用样式」这类 UI 预置项，只有 itemId + itemType，没有 itemKey
+        // —— 它们不参与运行时绑定。全仓实测 443(Text) + 21(Button) 条这种键，若不跳过会造成大面积误报。
+        if (typeof k !== 'string' || !k) continue
+        keys.add(k)
+        metaByKey.set(k, p)
+      }
+      out.propKeys.set(cls, keys)
+      out.propMeta.set(cls, metaByKey)
+    }
+    out.repeaterClasses = deriveRepeaterClasses(cm)
+    out.loaded.components = out.classes.size > 0
+  } catch {
+    /* 拿不到组件元数据：契约退化为「空」，调用方据此跳过检查而不是误报 */
+  }
+
+  // ── 样式契约（13 组 + 每组合法子键）──
+  const smPath = path.join(metaDir, 'style-meta.json')
+  try {
+    const sm = JSON.parse(fs.readFileSync(smPath, 'utf8'))
+    for (const g of sm?.properties || []) {
+      const gk = g?.itemKey
+      if (typeof gk !== 'string' || !gk) continue
+      const childKeys = new Set()
+      for (const c of g?.itemChildren || []) {
+        const ck = c?.itemKey
+        if (typeof ck === 'string' && ck) childKeys.add(ck)
+      }
+      out.styleGroups.set(gk, childKeys)
+    }
+    out.loaded.styles = out.styleGroups.size > 0
+  } catch {
+    /* 同上 */
+  }
+
+  return out
+}
+
+/** 该组件的合法属性键集合（未知组件返回 null，表示「无从判断」而非「全部非法」）。 */
+export function legalPropKeys(contract, className) {
+  if (NO_PROP_CHECK.has(className)) return null
+  return contract.propKeys.has(className) ? contract.propKeys.get(className) : null
+}
+
+/**
+ * 编辑距离（只用于给「你是不是想写 X」的建议，不是判定依据）。
+ * 上限 2：键名普遍很短，距离 >2 的建议没有参考价值。
+ */
+function nearestKey(target, candidates) {
+  const t = String(target || '')
+  let best = null
+  let bestD = Infinity
+  for (const c of candidates) {
+    const d = levenshtein(t, c)
+    if (d < bestD) {
+      bestD = d
+      best = c
+    }
+  }
+  return bestD <= 2 ? best : null
+}
+
+function levenshtein(a, b) {
+  if (a === b) return 0
+  const m = a.length
+  const n = b.length
+  if (!m) return n
+  if (!n) return m
+  let prev = Array.from({ length: n + 1 }, (_, j) => j)
+  for (let i = 1; i <= m; i++) {
+    const cur = [i]
+    for (let j = 1; j <= n; j++) {
+      cur[j] = Math.min(prev[j] + 1, cur[j - 1] + 1, prev[j - 1] + (a[i - 1] === b[j - 1] ? 0 : 1))
+    }
+    prev = cur
+  }
+  return prev[n]
+}
+
+/**
+ * 遍历 schema 里所有节点（含 slots 子树，与渲染器一致）。
+ *
+ * @param {object} schema 卡片 schema
+ * @param {(node: object, where: string, parent: object|null) => void} cb
+ */
+export function walkSchemaNodes(schema, cb) {
+  const visit = (node, where, parent) => {
+    if (!node || typeof node !== 'object') return
+    cb(node, where, parent)
+    const kids = node.components || []
+    kids.forEach((c, i) => visit(c, `${where}>c${i}`, node))
+    ;(node.slots || []).forEach((s, si) => {
+      ;(s?.components || []).forEach((c, ci) => visit(c, `${where}>slot:${s?.slotKey || si}[${ci}]`, node))
+    })
+  }
+  if (schema?.view) visit(schema.view, 'view', null)
+}
+
+/**
+ * 采集组件契约违规。
+ *
+ * 返回项字段：
+ *   code        'unknown-class' | 'unknown-prop-key' | 'unknown-style-group' | 'unknown-style-key'
+ *   severity    'error' | 'warn'
+ *   componentId 节点 id（缺省 '(root)'）
+ *   className   节点类型
+ *   where       节点在树中的路径（定位用）
+ *   key         违规键名
+ *   legal       该处合法键数组（供调用方直接展示）
+ *   suggestion  近似合法键（编辑距离 ≤2 才有；用于「你是不是想写 value」）
+ *
+ * @param {object} schema
+ * @param {ReturnType<typeof loadContract>} contract
+ * @returns {Array<object>}
+ */
+export function collectContractViolations(schema, contract) {
+  const out = []
+  if (!contract || !contract.loaded.components) return out
+
+  walkSchemaNodes(schema, (node, where) => {
+    const cls = node.className
+    if (!cls) return
+    const cid = node.componentId || '(root)'
+
+    // 1) className 本身不在元数据里（渲染空白）——与 preflight Check 2 同源，这里也给一份，
+    //    让 readiness 能独立跑出完整结论。
+    if (!contract.classes.has(cls)) {
+      out.push({ code: 'unknown-class', severity: 'error', componentId: cid, className: cls, where, key: cls, legal: [...contract.classes].sort() })
+      return
+    }
+
+    // 2) 属性键白名单 —— 本次事故的正主
+    const legal = legalPropKeys(contract, cls)
+    if (legal) {
+      for (const p of node.properties || []) {
+        const k = p?.itemKey
+        // 无 itemKey 的属性项是「样式预置」类 UI 载体，不参与绑定，跳过（全仓实测 464 条）
+        if (typeof k !== 'string' || !k) continue
+        if (legal.has(k)) continue
+        out.push({
+          code: 'unknown-prop-key',
+          severity: 'error',
+          componentId: cid,
+          className: cls,
+          where,
+          key: k,
+          legal: [...legal].sort(),
+          suggestion: nearestKey(k, legal),
+        })
+      }
+    }
+
+    // 3) 样式组 / 组内子键白名单
+    if (contract.loaded.styles) {
+      for (const g of node.style?.properties || []) {
+        const gk = g?.itemKey
+        if (typeof gk !== 'string' || !gk) continue
+        if (!contract.styleGroups.has(gk)) {
+          // 空组（没有任何带值的子键）运行时本来就什么也不做 ⇒ 只是噪音，报 warn；
+          // 带值的未知组才是真丢样式，报 error。这条区分避免「模型随手写错一个空组」也把门禁打红。
+          const carrying = (g?.itemChildren?.properties || []).filter((c) => {
+            const v = c?.itemValue
+            if (v === undefined || v === null || v === '') return false
+            if (typeof v === 'object' && !Array.isArray(v)) return Object.keys(v).length > 0
+            return true
+          })
+          out.push({
+            code: 'unknown-style-group',
+            severity: carrying.length ? 'error' : 'warn',
+            componentId: cid,
+            className: cls,
+            where,
+            key: gk,
+            legal: [...contract.styleGroups.keys()].sort(),
+            suggestion: nearestKey(gk, [...contract.styleGroups.keys()]),
+            carrying: carrying.length,
+          })
+          continue
+        }
+        const childLegal = contract.styleGroups.get(gk)
+        for (const c of g?.itemChildren?.properties || []) {
+          const ck = c?.itemKey
+          if (typeof ck !== 'string' || !ck) continue
+          if (childLegal.has(ck)) continue
+          out.push({
+            code: 'unknown-style-key',
+            severity: 'error',
+            componentId: cid,
+            className: cls,
+            where: `${where}>style.${gk}`,
+            key: ck,
+            legal: [...childLegal].sort(),
+            suggestion: nearestKey(ck, childLegal),
+          })
+        }
+      }
+    }
+  })
+
+  return out
+}
+
+/** 把一条违规渲染成一行可执行的中文说明（脚本输出是程序文本，不放具体卡片/业务字段名）。 */
+export function describeViolation(v) {
+  const at = v.where ? `${v.where} ` : ''
+  const suffix = v.suggestion ? `（是不是想写 "${v.suggestion}"？）` : ''
+  switch (v.code) {
+    case 'unknown-class':
+      return `${at}${v.className} "${v.componentId}" 不在组件元数据白名单里 → 渲染空白。合法类型：${v.legal.join(' / ')}`
+    case 'unknown-prop-key':
+      return (
+        `${at}${v.className} "${v.componentId}" 的属性键 "${v.key}" 不在该组件的合法键里 → ` +
+        `运行时按 itemKey 绑定，**不存在的键被整条静默丢弃**，组件拿到空值（如 Image 会渲染成破图）。` +
+        `该组件合法键：${v.legal.length ? v.legal.join(' / ') : '（无：该组件不接受任何属性）'}${suffix}`
+      )
+    case 'unknown-style-group':
+      return `${at}${v.className} "${v.componentId}" 的样式组 "${v.key}" 不是 13 个合法组名之一 → 整组被丢弃。合法组：${v.legal.join(' / ')}${suffix}`
+    case 'unknown-style-key':
+      return `${at}${v.className} "${v.componentId}" 在样式组 "${String(v.where).split('.').pop()}" 下写了非法子键 "${v.key}" → 该条属性被静默丢弃。该组合法子键：${v.legal.join(' / ')}${suffix}`
+    default:
+      return `${at}${v.className} "${v.componentId}" 契约违规：${v.key}`
+  }
+}

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

@@ -54,7 +54,7 @@ export const TOKEN = {
   COLOR: {
     pageBg: '#F5F6F8',        // 页面/画布背景
     cardBg: '#FFFFFF',        // 卡片背景
-    primary: '#00B578',       // 品牌主色（绿，geo/v3）
+    primary: '#00B578',       // 品牌主色（绿，v3）
     primaryBlue: '#0079F2',  // legacy 生成器历史主色（蓝）
     fallbackBg: '#F5F5F5',   // pickBg 兜底色
     danger: '#F6434F',        // 危险/未读红点

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

@@ -49,6 +49,29 @@ export const slicesDir =
 export const baselinesDir =
   process.env.DSL_CARD_BASELINES_DIR || path.join(projectRoot, '.card-baselines')
 
+/**
+ * 机器产物目录 —— **门禁只认这里的落盘产物，不认模型自述**。
+ *
+ * 三类文件同住于此，路径必须单源（历史事故：`check_fidelity` 自己拼了
+ * `<cardDir>/.audit.json`，而真实位置是 `.cache/ai-scratch/<id>.audit.json` ⇒
+ * 切图覆盖数恒为 null，`.audit.json` 从未存在过却没人发现）：
+ *   - `.cache/ai-scratch/<id>.audit.json`    S2 审计全文（crop_slices --from-audit 与 readiness 都吃它）
+ *   - `.cache/ai-scratch/<id>.iterate.json`  最近一轮迭代报告（--gate 的唯一依据）
+ *   - `.cache/ai-scratch/<id>.ir.rNN.json`   每轮 IR 快照（回退用）
+ */
+export const scratchDir =
+  process.env.DSL_CARD_SCRATCH_DIR || path.join(projectRoot, '.cache', 'ai-scratch')
+
+/** S2 审计落盘路径（spec_audit.mjs --save 的默认目标）。 */
+export function cardAuditPath(id) {
+  return path.join(scratchDir, `${id}.audit.json`)
+}
+
+/** 最近一轮迭代报告路径。 */
+export function cardIteratePath(id) {
+  return path.join(scratchDir, `${id}.iterate.json`)
+}
+
 /** 兼容旧脚本的别名：宿主项目根目录。 */
 export const repoRoot = projectRoot
 

package/dist/vendored/skills/dsl-card-generator/scripts/lib/paths.py

@@ -15,15 +15,11 @@ paths.py — skill 内部路径与宿主项目路径单一来源（Python 侧）
   DSL_CARD_PREVIEW_DIR   自包含预览目录（默认 <skill>/vendor/preview）
   DSL_CARD_BASELINES_DIR 渲染基线目录（默认 <project>/.card-baselines）
 """
-import json
 import os
 from pathlib import Path
 
 _HERE = Path(__file__).resolve().parent
 
-# 占位 sentinel：与任何用户传入的 fallback 都不会相同的内部对象。
-_MISSING = object()
-
 # 当前 skill 根目录：scripts/lib -> scripts -> dsl-card-generator
 skill_root = _HERE.parent.parent
 
@@ -93,36 +89,3 @@ host_skills_dir = _host_skills_dir()
 def card_dir(card_id: str) -> Path:
     """解析卡片目录的绝对路径：`<cards_dir>/<id>`。"""
     return cards_dir / card_id
-
-
-def card_schema_path(card_id: str) -> Path:
-    """解析卡片 schema.json 的绝对路径。"""
-    return cards_dir / card_id / "schema.json"
-
-
-def card_data_path(card_id: str) -> Path:
-    """解析卡片 data.json 的绝对路径。"""
-    return cards_dir / card_id / "data.json"
-
-
-def read_json(p: Path, fallback=_MISSING):
-    """
-    安全读取 JSON（不存在或解析失败时返回 fallback）。
-
-    Args:
-        p: 路径
-        fallback: 不存在/解析失败时的返回值。默认抛错。
-    Returns:
-        解析后的 Python 值
-    """
-    p = Path(p)
-    if not p.is_file():
-        if fallback is _MISSING:
-            raise FileNotFoundError(f"File not found: {p}")
-        return fallback
-    try:
-        return json.loads(p.read_text(encoding="utf-8"))
-    except Exception as e:
-        if fallback is _MISSING:
-            raise RuntimeError(f"Cannot parse JSON {p}: {e}") from e
-        return fallback

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

@@ -0,0 +1,99 @@
+/**
+ * python.mjs — 跨平台 Python 解释器解析的**单一来源**（Node 侧）。
+ *
+ * 为什么必须真跑一次 `--version`（而不是只看「能不能 spawn」）：Windows 上 `python3` 常是
+ * Microsoft Store 的**应用执行别名** —— 进程能启动，却立刻以 9009 退出，这不是 ENOENT。
+ * 只按 spawn 异常判断就会钉死这个假解释器，autofix / validate 全部静默不执行，调用方
+ * 收到的是一个**永远修不好**的 validate error（实测模型为它空转 20 轮，每轮重跑 iterate）。
+ *
+ * 为什么集中到本文件：同一件事此前在 5 个脚本里各写一遍，能力互不相同 ——
+ *   · `expand_ir.mjs`          真探测 + `py`（原本最完整，本文件的基准）
+ *   · `route_input.mjs`        真探测 + `py`，但不认 `WORKBUDDY_PYTHON`
+ *   · `add_component.mjs`      不真探测、不认 `py`
+ *   · `gate.mjs` / `v3_regression.mjs`  只读 `process.env.PYTHON || 'python3'`（**完全不探测**）
+ *   · `register_card_template.mjs`      只读 `DSL_PYTHON`、不认 `py`
+ * 后果：同一台机器上 `gate.mjs` 判定「没有 Python」而 `expand_ir.mjs` 跑得通。
+ *
+ * 环境变量链（前者优先，命中即停止回退到自动探测）：
+ *   `DSL_CARD_PYTHON`（权威）> `WORKBUDDY_PYTHON` > `DSL_PYTHON` > `PYTHON`
+ * 后两项为历史兼容（分别在 register_card_template / gate / v3_regression 里出现过），
+ * **新代码一律用 `DSL_CARD_PYTHON`**。
+ */
+import { spawnSync } from 'node:child_process'
+
+/** 显式指定的解释器，按优先级排列；命中即不再做自动探测。 */
+export const PYTHON_ENV_KEYS = ['DSL_CARD_PYTHON', 'WORKBUDDY_PYTHON', 'DSL_PYTHON', 'PYTHON']
+
+/** 权威环境变量名（文档 / 报错提示里要用户设置的那个）。 */
+export const PYTHON_ENV_PRIMARY = 'DSL_CARD_PYTHON'
+
+/** 自动探测顺序：`py` 是 Windows 官方启动器，`python3` 可能是 Store 假别名故不设优先级。 */
+export const PYTHON_AUTO_BINS = ['python3', 'python', 'py']
+
+/**
+ * 真跑一次 `--version` 判断解释器可用（识别 Windows Store 假别名）。
+ * @param {string} bin
+ * @returns {boolean}
+ */
+export function probePython(bin) {
+  const b = String(bin || '').trim()
+  if (!b) return false
+  try {
+    const r = spawnSync(b, ['--version'], {
+      encoding: 'utf8',
+      stdio: ['ignore', 'pipe', 'pipe'],
+      timeout: 5000,
+    })
+    if (r.status !== 0) return false
+    return /Python \d/i.test(`${r.stdout || ''}${r.stderr || ''}`)
+  } catch {
+    return false
+  }
+}
+
+/**
+ * 候选解释器列表（去重、保持优先级）。
+ *
+ * 语义与 `expand_ir.mjs` 原实现一致：显式指定且探测通过 → 只返回它；显式指定但探测不过
+ * → 仍保留一次机会（可能是带参数的包装器）；全探测失败 → 回落到常见名字，让报错里能带出
+ * 真实 stderr，而不是一句笼统的「python 不可用」。
+ *
+ * @returns {string[]}
+ */
+export function pythonCandidates() {
+  const out = []
+  const seen = new Set()
+  const push = (bin) => {
+    const b = String(bin || '').trim()
+    if (!b || seen.has(b)) return
+    seen.add(b)
+    out.push(b)
+  }
+
+  for (const key of PYTHON_ENV_KEYS) {
+    const val = process.env[key]
+    if (!val) continue
+    if (probePython(val)) {
+      push(val)
+      return out // 显式指定且可用：不再回退到其它解释器
+    }
+    push(val) // 探测不过也留一次机会（包装器 / 路径含参数）
+  }
+
+  for (const bin of PYTHON_AUTO_BINS) if (probePython(bin)) push(bin)
+  for (const bin of ['python3', 'python']) push(bin)
+  return out
+}
+
+/**
+ * 最优先的可用解释器（总是返回可用的命令名，探测全失败时返回 `python3` 以便报错原样带出）。
+ * @returns {string}
+ */
+export function resolvePython() {
+  return pythonCandidates()[0] || 'python3'
+}
+
+/** 当前环境是否**有**可用 Python（供「没装就别跑」的早退分支用）。 */
+export function hasPython() {
+  return probePython(resolvePython())
+}

package/dist/vendored/skills/dsl-card-generator/scripts/lib/rules/adaptive-width.mjs

@@ -0,0 +1,105 @@
+/**
+ * rules/adaptive-width.mjs —— 宽度自适应契约的机械判据（ir-format.md §2f）。
+ *
+ * 背景（2026-09-25 汇率卡事故）：容器类节点把「设计稿测量宽」写死成 px
+ * （如第一层主容器 rect.width="343"），卡片在非设计宽度的宿主容器里
+ * 无法自适应——Root 撑满了，内容层却锁死在 343px。
+ *
+ * 渲染契约（component-meta.json / components.css 实证）：
+ *   - 全部容器组件的 meta 默认 rect.width 就是 "100%"（覆盖默认 = 显式声明固定）；
+ *   - adapter.doSize 对 '%' 值原样透传（不做 px 换算）；
+ *   - 纵向流（Root/Column/AbsoluteLayout）里子项交叉轴默认 stretch。
+ * 因此「占满语义」永远不该写成 px：写 100%（显式）或不写（默认）都自适应，
+ * 且在以卡面宽为基准的渲染/截图环境下与原 px 值逐像素等价（父内容盒宽 == 原 px）。
+ *
+ * 判定口径（全部是格式/几何/结构特征，与任何业务无关）：
+ *   1. 节点类型 ∈ 容器白名单（meta 默认 100% 的那批）；
+ *   2. rect.width 是纯数字（px 字面量；'100%'/'auto'/表达式不在此列）；
+ *   3. 父内容盒宽可计算（Root 直系 = view.width；父定宽 = 父宽 − 父水平 padding；
+ *      父 100%/无宽则透传，透传链不可达时跳过）；
+ *   4. 宽度占满父内容盒（98% ~ 103%，容差 2px 量级的标注/取整误差）；
+ *      **超出型不报**（ratio > 1.03：绝对层故意越出卡面的形态，属另一话题）；
+ *   5. 父为纵向流（Root/Column/AbsoluteLayout 或显式 flexDirection=column）——
+ *      Row/MultiColumn 主轴语境里并列子项定宽是 space-between 等范式的合法组成
+ *      （ir-format.md R-FIXEDW / R-COMPARE），不在此规则射程。
+ */
+import { hit } from './walk.mjs'
+
+const FULLWIDTH_CONTAINERS = new Set([
+  'Row', 'Column', 'MultiColumn', 'ListLayout', 'GridLayout', 'ViewContainer',
+])
+
+/** 纵向流父级：显式 flexDirection=column 优先，否则按渲染器默认方向推断。 */
+function isColumnAxis(node) {
+  const fl = (node?.style?.properties || []).find((g) => g.itemKey === 'flex')
+  const dir = (fl?.itemChildren?.properties || []).find((c) => c.itemKey === 'flexDirection')?.itemValue
+  if (dir === 'column') return true
+  if (dir === 'row') return false
+  const cls = node?.className
+  return cls === 'Root' || cls === 'Column' || cls === 'AbsoluteLayout'
+}
+
+/** rect.width 纯数字（px 字面量）→ 数值；无/百分比/auto/表达式 → null。 */
+function fixedPxWidth(node) {
+  const rect = (node?.style?.properties || []).find((g) => g.itemKey === 'rect')
+  const child = (rect?.itemChildren?.properties || []).find((c) => c.itemKey === 'width')
+  if (!child) return null
+  const raw = String(child.itemValue ?? '').trim()
+  if (!/^-?\d+(\.\d+)?$/.test(raw)) return null
+  const n = Number(raw)
+  return Number.isFinite(n) && n > 0 ? n : null
+}
+
+/** 水平 padding 合计（单值 padding 或 paddingLeft+paddingRight）。 */
+function horizontalPadding(node) {
+  const g = (node?.style?.properties || []).find((x) => x.itemKey === 'padding')
+  let all = 0
+  let left = 0
+  let right = 0
+  for (const c of g?.itemChildren?.properties || []) {
+    if (c.itemKey === 'padding') all = Number(c.itemValue) || 0
+    if (c.itemKey === 'paddingLeft') left = Number(c.itemValue) || 0
+    if (c.itemKey === 'paddingRight') right = Number(c.itemValue) || 0
+  }
+  return (left || all) + (right || all)
+}
+
+export function collectFullwidthFixedPx(view) {
+  const out = []
+  if (!view || typeof view !== 'object') return out
+  const viewW = Number(String(view.width ?? '').replace(/[^0-9.\-]/g, '')) || 0
+
+  /**
+   * @param node 当前节点
+   * @param parentContent 父节点的内容盒宽（父解析宽 − 父水平 padding；Root = view.width − Root padding）
+   *   —— 子节点 rect.width:"100%" 的解析基准就是这个值（doSize 对 % 原样透传）。
+   *   父为 '100%'/无宽时解析宽 = 透传 parentContent；父定宽 px 时 = 定宽值。
+   */
+  const walk = (node, parentContent, isRoot) => {
+    if (!node || typeof node !== 'object') return
+    const selfResolved = isRoot ? viewW : (() => {
+      const w = fixedPxWidth(node)
+      return w !== null ? w : parentContent
+    })()
+    const selfContent = Math.max(0, selfResolved - horizontalPadding(node))
+    const kids = [
+      ...(node.components || []),
+      ...((node.slots || []).flatMap((s) => (s && s.components) || [])),
+    ]
+    for (const child of kids) {
+      if (!child || typeof child !== 'object') continue
+      const w = fixedPxWidth(child)
+      if (selfContent > 0 && w !== null && FULLWIDTH_CONTAINERS.has(child.className)
+        && isColumnAxis(node)) {
+        const ratio = w / selfContent
+        if (ratio >= 0.98 && ratio <= 1.03) {
+          out.push(hit('r66-fullwidth-px', 'error', child.componentId || '',
+            `${child.className} "${child.componentId || child.name || ''}" 在纵向流父级里把占满语义写死成 rect.width="${w}"（父内容盒宽 ≈ ${Math.round(selfContent)}）——宿主容器宽度一旦偏离设计基准，内容层锁死不自适应（ir-format.md §2f）。修法：改 width:"100%"（或不写 width，meta 默认即 100%），与设计宽逐像素等价且随容器自适应；真固定宽元素（图标/头像/徽章/图表画布）保留 px。注意 100% 节点禁叠水平 margin（rules.md §十六 R63），水平内缩写父容器 padding。`))
+        }
+      }
+      walk(child, selfContent, false)
+    }
+  }
+  walk(view, 0, true)
+  return out
+}