@lark-apaas/coding-miaoda-sandbox-skills 0.1.0-dev.6f4e4bc → 0.1.0-dev.72ac425

package/miaoda-modern/lark-design-prototype/scripts/icon-query.mjs

@@ -0,0 +1,272 @@
+#!/usr/bin/env node
+import fs from 'node:fs/promises';
+import { createHash } from 'node:crypto';
+import path from 'node:path';
+
+const SVG_BASE = 'https://cdn-tos-cn.bytedance.net/obj/archi/ee/es-design-base/svgs';
+const REMOTE_CATALOG =
+  'https://lf3-static.bytednsdoc.com/obj/eden-cn/pshi/lark-design-prototype/1.0.4/db71a6cd-33f97519-0d446cd5/icons.catalog.json';
+const REMOTE_CATALOG_SHA256 = 'db71a6cd6ac90c77629e8ce0fc0905ca1488a6601800ff7533385490b10eac9d';
+
+function usage() {
+  return `Usage:
+  node icon-query.mjs [--catalog <remote|catalog.json|url>] --query "<keywords>" [--family outlined] [--style v2-outlined|source-outlined|source-filled|source-colorful] [--shape normal|round] [--prefer-v2] [--require-v2] [--limit 5]
+
+Returns a compact JSON array with name, hash, family, version, shape, score, description, and final svgUrl.
+Never print the raw icon catalog during page generation.`;
+}
+
+function argValue(name, fallback = '') {
+  const index = process.argv.indexOf(name);
+  return index === -1 ? fallback : process.argv[index + 1] || fallback;
+}
+
+function argFlag(name) {
+  return process.argv.includes(name);
+}
+
+function tokenize(text) {
+  const rawTokens = String(text || '')
+    .toLowerCase()
+    .split(/[\s,，、:：;；/|()（）\[\]{}'"`<>.!?？。_-]+/)
+    .map((item) => item.trim())
+    .filter(Boolean);
+  const aliases = {
+    搜索: ['search'],
+    查找: ['search'],
+    通知: ['notification', 'bell'],
+    提醒: ['reminder', 'bell'],
+    主页: ['home'],
+    首页: ['home'],
+    模板: ['template'],
+    文档: ['doc', 'document', 'file'],
+    document: ['doc'],
+    文件: ['file'],
+    文件夹: ['folder'],
+    表格: ['sheet', 'table', 'bitable'],
+    spreadsheet: ['sheet'],
+    table: ['sheet'],
+    图表: ['chart'],
+    看板: ['dashboard', 'chart'],
+    帮助: ['help', 'faq'],
+    指南: ['guide', 'info'],
+    飞书: ['feishu', 'lark', 'logo', 'logotype'],
+    品牌: ['brand', 'logo', 'logotype'],
+    标识: ['logo', 'logotype'],
+    logo: ['brand', 'logotype'],
+  };
+  const expanded = new Set(rawTokens);
+  for (const token of rawTokens) {
+    for (const alias of aliases[token] || []) {
+      expanded.add(alias);
+    }
+  }
+  return [...expanded];
+}
+
+async function readJsonFile(filePath) {
+  const text = await fs.readFile(filePath, 'utf8');
+  return JSON.parse(text);
+}
+
+async function readCatalog(source) {
+  const resolved = !source || source === 'remote' ? REMOTE_CATALOG : source;
+  if (/^https?:\/\//.test(resolved)) {
+    const response = await fetch(resolved);
+    if (!response.ok) {
+      throw new Error(`Catalog request failed with HTTP ${response.status}`);
+    }
+    const text = await response.text();
+    if (resolved === REMOTE_CATALOG) {
+      const actualHash = createHash('sha256').update(text).digest('hex');
+      if (actualHash !== REMOTE_CATALOG_SHA256) {
+        throw new Error(
+          `Catalog integrity check failed: expected ${REMOTE_CATALOG_SHA256}, got ${actualHash}`,
+        );
+      }
+    }
+    return { catalog: JSON.parse(text), catalogSource: resolved };
+  }
+  const filePath = path.resolve(resolved);
+  return { catalog: await readJsonFile(filePath), catalogSource: filePath };
+}
+
+function detectVersion(name) {
+  return /(?:^|[-_])v2(?:[-_]|$)/i.test(name) ? 'v2' : 'non-v2';
+}
+
+function detectShape(icon) {
+  const name = icon.name.toLowerCase();
+  if (name.includes('file-round-') || name.includes('wiki-round-')) return 'round';
+  if (icon.family === 'colorful' && /(?:icon_|wiki-)?file[-_]/.test(name)) return 'normal';
+  return 'none';
+}
+
+function detectStyleType(icon) {
+  const version = detectVersion(icon.name);
+  const shape = detectShape(icon);
+  if (icon.family === 'outlined') {
+    return version === 'v2' ? 'v2-outlined' : 'non-v2-outlined';
+  }
+  if (icon.family === 'filled') {
+    return 'source-filled';
+  }
+  if (icon.family === 'colorful' && /(?:feishu|lark).*logo|logotype|logo/i.test(icon.name)) {
+    return 'brand-colorful';
+  }
+  if (icon.family === 'colorful' && version === 'v2' && shape === 'round') {
+    return 'file-v2-colorful-round';
+  }
+  if (icon.family === 'colorful' && version === 'v2' && shape === 'normal') {
+    return 'file-v2-colorful-normal';
+  }
+  return icon.family;
+}
+
+function normalizeOptions() {
+  const style = argValue('--style');
+  const options = {
+    family: argValue('--family', 'outlined'),
+    style,
+    shape: argValue('--shape'),
+    preferV2: argFlag('--prefer-v2'),
+    requireV2: argFlag('--require-v2'),
+    requireNonV2: argFlag('--require-non-v2'),
+    include: argValue('--name-include'),
+    exclude: argValue('--name-exclude'),
+  };
+
+  if (style === 'v2-outlined') {
+    options.family = 'outlined';
+    options.requireV2 = true;
+  } else if (style === 'non-v2-outlined') {
+    options.family = 'outlined';
+    options.requireNonV2 = true;
+  } else if (style === 'file-v2-colorful-normal') {
+    options.family = 'colorful';
+    options.requireV2 = true;
+    options.shape = 'normal';
+    options.include ||= 'file';
+  } else if (style === 'file-v2-colorful-round') {
+    options.family = 'colorful';
+    options.requireV2 = true;
+    options.shape = 'round';
+    options.include ||= 'file-round';
+  } else if (style === 'source-outlined') {
+    options.family = 'outlined';
+    options.preferV2 = true;
+  } else if (style === 'source-filled') {
+    options.family = 'filled';
+  } else if (style === 'brand-colorful' || style === 'source-colorful') {
+    options.family = 'colorful';
+    if (style === 'source-colorful') {
+      options.preferV2 = true;
+    }
+  }
+  return options;
+}
+
+function flattenCatalog(catalog, options) {
+  const rows = [];
+  for (const category of catalog) {
+    for (const [family, icons] of Object.entries(category.icons || {})) {
+      if (options.family && family !== options.family) {
+        continue;
+      }
+      for (const icon of icons || []) {
+        const row = {
+          category: category.id || '',
+          family,
+          name: icon.name,
+          hash: icon.hash,
+          darkHash: icon.darkHash,
+          description: icon.description || '',
+        };
+        row.version = detectVersion(row.name);
+        row.shape = detectShape(row);
+        row.styleType = detectStyleType(row);
+        rows.push(row);
+      }
+    }
+  }
+  return rows;
+}
+
+function passesFilters(icon, options) {
+  const name = icon.name.toLowerCase();
+  if (options.requireV2 && icon.version !== 'v2') return false;
+  if (options.requireNonV2 && icon.version !== 'non-v2') return false;
+  if (options.shape && icon.shape !== options.shape) return false;
+  if (options.include && !name.includes(options.include.toLowerCase())) return false;
+  if (options.exclude && name.includes(options.exclude.toLowerCase())) return false;
+  const sourceStyles = new Set(['source-outlined', 'source-filled', 'source-colorful']);
+  if (options.style && !sourceStyles.has(options.style) && icon.styleType !== options.style)
+    return false;
+  return true;
+}
+
+function scoreIcon(icon, queryTokens, options) {
+  const name = icon.name.toLowerCase();
+  const description = icon.description.toLowerCase();
+  let score = 0;
+  for (const token of queryTokens) {
+    if (name.includes(token)) score += 5;
+    if (description.includes(token)) score += 3;
+    if (name === `icon_${token}_outlined`) score += 8;
+    if (name === `icon_${token}-v2_outlined`) score += 8;
+    if (name === `icon_${token}_filled`) score += 8;
+    if (name === `icon_file-${token}-v2_colorful`) score += 8;
+  }
+  if (score === 0) return 0;
+  if (icon.family === 'outlined') score += 1;
+  if ((options.preferV2 || options.style?.includes('v2')) && icon.version === 'v2') score += 4;
+  if (
+    options.style === 'brand-colorful' &&
+    /feishu|lark|logotype|logo/i.test(`${name} ${description}`)
+  )
+    score += 10;
+
+  const objectTokens = ['doc', 'document', 'file', 'card', 'sheet', 'bitable', 'ai'];
+  const queryHasObject = objectTokens.some((token) => queryTokens.includes(token));
+  if (
+    !queryHasObject &&
+    objectTokens.some((token) => name.includes(`_${token}`) || name.includes(`-${token}`))
+  ) {
+    score -= 3;
+  }
+  return score;
+}
+
+const catalogSource = argValue('--catalog', 'remote');
+const query = argValue('--query');
+const limit = Math.max(1, Number.parseInt(argValue('--limit', '5'), 10) || 5);
+
+if (!query) {
+  console.error(usage());
+  process.exit(2);
+}
+
+const options = normalizeOptions();
+const queryTokens = tokenize(query);
+const { catalog, catalogSource: usedCatalogSource } = await readCatalog(catalogSource);
+const matches = flattenCatalog(catalog, options)
+  .filter((icon) => passesFilters(icon, options))
+  .map((icon) => ({ ...icon, score: scoreIcon(icon, queryTokens, options) }))
+  .filter((icon) => icon.score > 0)
+  .sort((a, b) => b.score - a.score || a.name.localeCompare(b.name))
+  .slice(0, limit)
+  .map((icon) => ({
+    name: icon.name,
+    hash: icon.hash,
+    darkHash: icon.darkHash || undefined,
+    family: icon.family,
+    version: icon.version,
+    shape: icon.shape,
+    styleType: icon.styleType,
+    score: icon.score,
+    description: icon.description.slice(0, 180),
+    svgUrl: `${SVG_BASE}/${icon.name}.${icon.hash}.svg`,
+    catalogSource: usedCatalogSource,
+  }));
+
+console.log(JSON.stringify(matches, null, 2));

package/miaoda-modern/lark-design-prototype/scripts/token-query.mjs

@@ -0,0 +1,76 @@
+#!/usr/bin/env node
+import { createHash } from 'node:crypto';
+
+const SOURCES = {
+  semantic: {
+    url: 'https://lf3-static.bytednsdoc.com/obj/eden-cn/pshi/lark-design-prototype/1.0.4/db71a6cd-33f97519-0d446cd5/semantic.json',
+    sha256: '33f975193bcd0b5b12df9003e6f8586bf4662336e0bd5cf73ea1f362cfa4eb50',
+  },
+  keys: {
+    url: 'https://lf3-static.bytednsdoc.com/obj/eden-cn/pshi/lark-design-prototype/1.0.4/db71a6cd-33f97519-0d446cd5/keys.json',
+    sha256: '0d446cd57b0beaaaa9ba485009b31a73be77d5f87a8481ec032c54f33b3bb471',
+  },
+};
+
+function usage() {
+  return `Usage:
+  node token-query.mjs --query "<token name or intent>" [--source semantic|keys] [--limit 5]
+
+Fetches the versioned public token resource, verifies SHA-256, and returns compact matches.`;
+}
+
+function argValue(name, fallback = '') {
+  const index = process.argv.indexOf(name);
+  return index === -1 ? fallback : process.argv[index + 1] || fallback;
+}
+
+function tokenize(value) {
+  return String(value || '')
+    .toLowerCase()
+    .split(/[\s,，、:：;；/|()（）\[\]{}'"`<>.!?？。_-]+/)
+    .map((item) => item.trim())
+    .filter(Boolean);
+}
+
+function scoreEntry([key, value], query, queryTokens) {
+  const normalizedKey = key.toLowerCase();
+  const searchText = `${key} ${value?.$description || ''} ${value?.$extensions?.id || ''} ${
+    value?.$extensions?.name || ''
+  }`.toLowerCase();
+  let score = normalizedKey === query ? 100 : normalizedKey.includes(query) ? 40 : 0;
+  for (const token of queryTokens) {
+    if (normalizedKey.includes(token)) score += 10;
+    if (searchText.includes(token)) score += 3;
+  }
+  return score;
+}
+
+const sourceName = argValue('--source', 'semantic');
+const source = SOURCES[sourceName];
+const query = argValue('--query').trim().toLowerCase();
+const limit = Math.max(1, Number.parseInt(argValue('--limit', '5'), 10) || 5);
+
+if (!source || !query) {
+  console.error(usage());
+  process.exit(2);
+}
+
+const response = await fetch(source.url);
+if (!response.ok) {
+  throw new Error(`Token request failed with HTTP ${response.status}`);
+}
+const text = await response.text();
+const actualHash = createHash('sha256').update(text).digest('hex');
+if (actualHash !== source.sha256) {
+  throw new Error(`Token integrity check failed: expected ${source.sha256}, got ${actualHash}`);
+}
+
+const queryTokens = tokenize(query);
+const matches = Object.entries(JSON.parse(text))
+  .map((entry) => ({ entry, score: scoreEntry(entry, query, queryTokens) }))
+  .filter(({ score }) => score > 0)
+  .sort((a, b) => b.score - a.score || a.entry[0].localeCompare(b.entry[0]))
+  .slice(0, limit)
+  .map(({ entry: [key, value] }) => ({ key, ...value, source: source.url }));
+
+console.log(JSON.stringify(matches, null, 2));

package/miaoda-modern/lark-design-prototype/scripts/verify-static-html.mjs

@@ -0,0 +1,117 @@
+#!/usr/bin/env node
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { pathToFileURL } from 'node:url';
+
+function usage() {
+  return `Usage:
+  node verify-static-html.mjs <file.html> [--sidebar]
+
+Runs token-light pre-browser checks for Lark-style static HTML deliverables.
+Use --sidebar only when the page contains a navigation sidebar. Shadow declarations are reported for contextual review.`;
+}
+
+const htmlPath = process.argv[2];
+if (!htmlPath) {
+  console.error(usage());
+  process.exit(2);
+}
+
+const absoluteHtmlPath = path.resolve(htmlPath);
+const html = await fs.readFile(absoluteHtmlPath, 'utf8');
+
+const hardFailures = [];
+const warnings = [];
+const passed = [];
+
+function pass(name, ok, failMessage, warn = false) {
+  if (ok) {
+    passed.push(name);
+  } else if (warn) {
+    warnings.push(failMessage);
+  } else {
+    hardFailures.push(failMessage);
+  }
+}
+
+pass(
+  'no gradients',
+  !/(linear-gradient|radial-gradient|conic-gradient)/i.test(html),
+  'Page UI contains gradients.',
+);
+const shadows = [...html.matchAll(/box-shadow\s*:\s*([^;}"'<>]+)/gi)]
+  .map((match) => match[1].trim())
+  .filter((value) => !/^none(?:\s*!important)?$/i.test(value));
+pass(
+  'no shadows requiring contextual review',
+  shadows.length === 0,
+  'Shadow declarations found; verify they belong to permitted floating layers, not ordinary cards.',
+  true,
+);
+if (process.argv.includes('--sidebar')) {
+  pass(
+    'fixed sidebar background',
+    html.includes('#f9f9f9'),
+    'Sidebar background #f9f9f9 is missing.',
+  );
+  pass(
+    'fixed selected sidebar state',
+    html.includes('#1f23290d'),
+    'Selected sidebar state #1f23290d is missing.',
+  );
+}
+pass('has table', /<table[\s>]/i.test(html), 'No table found.', true);
+pass('has search input', /type=["']search["']/i.test(html), 'No search input found.', true);
+pass(
+  'has local responsive CSS',
+  /@media\s*\(/i.test(html),
+  'No responsive media query found.',
+  true,
+);
+
+const imageRefs = [...html.matchAll(/<img\b[^>]*\bsrc=["']([^"']+)["']/gi)].map(
+  (match) => match[1],
+);
+const localImageRefs = imageRefs.filter(
+  (src) => !/^(https?:)?\/\//.test(src) && !src.startsWith('data:'),
+);
+const missingImages = [];
+for (const src of localImageRefs) {
+  try {
+    await fs.access(new URL(src, pathToFileURL(absoluteHtmlPath)));
+  } catch {
+    missingImages.push(src);
+  }
+}
+
+pass(
+  'all local images exist',
+  missingImages.length === 0,
+  `Missing local image assets: ${missingImages.join(', ')}`,
+);
+
+const tableHeaders = [...html.matchAll(/<th\b[^>]*>([\s\S]*?)<\/th>/gi)]
+  .map((match) => match[1].replace(/<[^>]+>/g, '').trim())
+  .filter(Boolean);
+
+console.log(
+  JSON.stringify(
+    {
+      file: absoluteHtmlPath,
+      passed,
+      warnings,
+      hardFailures,
+      stats: {
+        images: imageRefs.length,
+        localImages: localImageRefs.length,
+        tableHeaders,
+      },
+    },
+    null,
+    2,
+  ),
+);
+
+if (hardFailures.length > 0) {
+  process.exit(1);
+}

package/miaoda-modern/performance-review/SKILL.md

@@ -59,11 +59,11 @@ const userMap = new Map(users.map(u => [u.id, u]));
 - N+1 queries: per-item DB calls inside loops — use batch or JOIN
 - List endpoints without pagination — will break as data grows
 - OFFSET pagination on large datasets — use cursor pagination (WHERE id > cursor)
-- Multiple independent DB queries running serially — use Promise.all
+- Multiple independent DB queries running serially — use Promise.all. The platform connection pool caps real concurrency at **7**; beyond that queries queue. It only pays off for IO-bound queries — CPU-heavy ones (large aggregations, big `generate_series`) still take the same total time, so for those the only fix is fewer/cheaper queries
 - External API calls without timeout
-- WHERE/ORDER BY columns missing indexes — **cross-check with schema definition: for every ORDER BY or WHERE column in service queries, verify a matching index exists in schema.ts**
+- WHERE/ORDER BY columns missing indexes — **cross-check against the live DDL: for every ORDER BY or WHERE column in service queries, verify a matching index exists via `npx -y @lark-apaas/miaoda-data-cli db schema <table>`. Do NOT use `schema.ts` for this — it is a generated mirror that silently drops partial-index `WHERE` clauses and CHECK constraints, so an existing partial index reads as missing (and a partial unique index reads as full-table unique)**
 - Aggregation done in JS instead of SQL layer — fetch all rows then compute in app is a common anti-pattern
-- **Sorting fields used in list/ranking endpoints must have database indexes — read schema.ts and verify**
+- **Sorting fields used in list/ranking endpoints must have database indexes — verify with `db schema <table>` (the live DDL), not `schema.ts`**
 - **Date-range loop expansion in JS (CRITICAL)**: code shaped like `for (let d = new Date(start); d <= end; d.setDate(d.getDate()+1)) for (item of items) ...` is O(N×days). For 1000 records over 90 days = 90,000 ops per request. Must be pushed to SQL using `generate_series(start, end, '1 day') + unnest(array_field) + GROUP BY ... HAVING COUNT(*) > N` — let the database do the date×row cross product
 - **Multiple endpoints sharing the same base data should be merged**: e.g. Dashboard frontend calling 4 separate stats endpoints, each internally re-querying the full teacher table to build a lookup map. Merge into a single overview endpoint that runs the 4 stats in parallel internally and shares one base-data query.
 - **Stats / Dashboard endpoints must have a default time window**: any query that scans the entire fact table for aggregation (`select ... from coursePlan` with no `where`) will degrade as data grows. Add a default `where startDate >= now() - interval '90 day'` (or business-appropriate window) so it can hit `idx_*_start_date`. Without a time window, even with indexes the planner may still seq-scan. If "all history" is required, use a materialized view or pre-aggregated table refreshed on schedule, never a live full-table scan.

package/miaoda-modern/reviewer-usage/SKILL.md

@@ -3,6 +3,7 @@ name: reviewer-usage
 description: "Reviewer SubAgent dispatch & post-return protocol — required reading BEFORE invoking Reviewer. Covers when you MUST escalate to Reviewer after repeated self-fix failures, how many Reviewers to dispatch, how to split scopes, what the prompt must contain, and how to act on the per-issue policy tags Reviewer returns. 触发词：派 Reviewer、code review、审查、排查、review and fix、反复失败、修不好、repeated-fix"
 available-agents:
   - Code
+  - DesignModern
 ---
 
 # Reviewer Usage Guide
@@ -92,6 +93,7 @@ No AskUser, no confirmation, no asking the user.
 - **STEP 3a (echo)**: emit a short user-facing summary listing the `policy: AskUser` issues, grouped by 🔴 Critical / 🟠 Bug / 🟡 Suggestion, with file:line. ≤25 lines (collapse the rest as `... (其余 N 项见下方表单)`). The user cannot see Reviewer's report directly — without this echo they cannot decide.
 - **STEP 3b (call ask_user_question)**: in the same turn, immediately call `ask_user_question` — `header`: `Review 确认`; `description`: paste the same list as STEP 3a; ONE Radio `question`: "Reviewer 另发现以下超出本次任务范围的问题，是否一并处理？"; use the exact `options` and `recommended` label that the ACTION header specified.
 - No FINAL reply between 3a and 3b.
+- **STEP 3b applies only if `ask_user_question` is in your tool list.** Some chains deliberately omit it (no confirmation step by design). If you do not have that tool: do STEP 3a only and stop there — this bucket degrades to report-only, and Step 4 does not apply. Do NOT seek confirmation by any other means (no free-text question, no other tool), and do NOT promote these issues to auto-fix. State plainly which issues were reported but not acted on; never present "not confirmed" as "no problem".
 
 ### Step 4 — Act on the user's choice
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lark-apaas/coding-miaoda-sandbox-skills",
-  "version": "0.1.0-dev.6f4e4bc",
+  "version": "0.1.0-dev.72ac425",
   "description": "Miaoda 合并沙箱 skills 包（包含原 miaoda-skills 的 miaoda / miaoda-modern / miaoda-design / shared 四条业务线）；发布公网 npm，随沙箱运行时经 update-skills 同步到 .agent/skills/",
   "type": "module",
   "files": [

package/shared/attachment/SKILL.md

@@ -1,6 +1,10 @@
 ---
 name: attachment
-description: "Use when user mentions attachments, uploaded files, or shared files. Handles preprocessing: listing, extracting archives, and reading files in .agent/{conversation_id}/attachments directory."
+description: "附件预处理 / Attachment Preprocessing. Use when user mentions attachments, uploaded files, or shared files. 当用户提到附件、上传文件或共享文件时使用；仅负责列出、解压和读取 .agent/{conversation_id}/attachments 下的文件，后续处理由文件内容和用户意图决定。"
+metadata:
+  display-names:
+    zh-CN: 附件预处理
+    en-US: Attachment Preprocessing
 ---
 
 # Attachment Preprocessing

package/miaoda/creative-to-fullstack/references/artifact-signals.md

@@ -1,46 +0,0 @@
-# 创意产物类型信号表与分类型拆分细则
-
-创意模式产物是 design-html 技术栈的静态工程：`index.html` 为入口，可能带 `components/` 或 `screens/` 目录（`.jsx` 经 `<script type="text/babel">` 在浏览器内编译）。先读 `index.html` 全文 + 目录清单，再按下表判类型。**支持生成的只有前三行**（产品设计=多屏设计稿/移动端 mockup、可交互原型）；报表/deck/动画为产品范围外，判中即停止并告知用户（入口层正常会拦截，此为防御兜底）。若会话上下文提供了「当前选中的设计稿文件」路径，判型与拆分优先以该文件为主入口。
-
-## 类型判定信号表
-
-| 类型 | 判定信号（任一命中） | 实现形态 |
-|------|---------------------|----------|
-| 演示稿（deck） | `<deck-stage>` / 翻页控件 / 每屏是「第 N 页」式幻灯结构 | **范围外，停止并告知** |
-| 多屏设计稿（artboard） | `<DCArtboard>` / `design-canvas` 缩放壳 / 多画板平铺 + 画板 label | 每画板 → 路由页 |
-| 移动端 mockup | 设备框组件（iOS/Android 壳：`width:390` + 圆角 + 状态栏/灵动岛） + `screens/` 或 `screen-*.jsx` 多屏 | 每屏 → 路由页；框内 tab → 应用导航 |
-| 交互原型 | `useState` / 事件处理驱动页面切换，无画布壳，本身像单页应用 | 按其内部「视图状态」拆路由页 |
-| 报表看板 | echarts / 图表库 + 指标卡片布局 | **范围外，停止并告知** |
-| 纯动画/视觉演示 | 大量 keyframes/canvas 动画、无业务 UI | **范围外，停止并告知** |
-
-混合信号时以「业务 UI 占比」为准：有表单/列表/详情等业务界面 → 按设计稿/原型类正常生成（防止 deck 里嵌了真实业务界面设计被误杀）；纯展示 → 判为范围外。
-
-## 分类型拆分细则
-
-### 多屏设计稿 / 移动端 mockup
-
-1. 枚举所有屏：`data-screen-label` 属性、画板 label、`screen-*.jsx` 文件名，三者取有值的作为页面名与路由名来源。
-2. 稿内导航（底部 tab / 侧边栏 / 顶部菜单）转为工程导航结构；未出现在导航里的屏（如详情页、由弹层提级的独立页）按从属关系挂到父页面路由下。
-3. 导航项逐项承接源稿：数量、文案、顺序与源稿一致。源稿导航中没有对应画板的项不得删除，也不得添加源稿没有的导航项；这类项的点击去向在方案中写明（例如指向相关页面的对应区块，或在方案的未决事项中说明），不得静默决定。
-4. 设备框（手机壳、浏览器壳、`IOSFrame` 这类组件）是预览容器：取 `children` 内容做响应式页面；状态栏、灵动岛、Home 指示条随壳丢弃。
-5. 稿内固定尺寸（390×844、1920×1080 加 scale 缩放）改为真响应式：内容宽度用容器约束（如 `max-width` + 居中），移动优先或桌面优先取决于原稿形态。
-
-### 交互原型
-
-1. 找出所有「视图状态」：`useState` 切换的 tab/step/modal 中承载独立业务界面的 → 路由页；纯交互细节（折叠、hover）→ 保留为组件内交互。
-2. 原型里已经写了的交互逻辑（校验提示、乐观更新、步骤流转）是功能需求的最强信号，逐条纳入第 2 步的可见功能清单。
-
-### 报表看板
-
-范围外类型，不做生成。若混合产物中局部包含图表且整体被判为设计稿/原型类，图表部分按 `ui-to-function.md` 的"统计卡片/图表"映射行处理。
-
-## 稿内机制识别速查
-
-| 稿内出现 | 含义 | 处置 |
-|----------|------|------|
-| `<script type="text/babel">` + `@babel/standalone` | 浏览器内编译 JSX 的预览机制 | 内容重写为工程组件，机制丢弃 |
-| `unpkg-sdk/react@*/umd/*.js`（miaoda.feishu.cn 镜像） | CDN React 运行时 | 丢弃，用工程自带 React |
-| `Object.assign(window, { Xxx })` | 组件挂全局供跨 `<script>` 引用 | 转译为模块 import/export |
-| `data-miaoda-*` / `data-screen-label` | 创意平台标注属性 | 属性丢弃；label 值用作路由/导航命名后即弃 |
-| `miaoda.feishu.cn/fonts/css2?family=...` | 字体镜像 | 保留，生产可用 |
-| tweaks / EDITMODE 面板 | 设计期调参 | 当前参数值固化进主题 token，面板删除 |