sketch-design-mcp 3.0.0

package/dist/index.js

@@ -0,0 +1,2642 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { readFileSync as readFileSync3 } from "fs";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
+
+// src/engine/core.ts
+import { createHash } from "crypto";
+import { existsSync as existsSync2, mkdirSync, readFileSync as readFileSync2, writeFileSync } from "fs";
+import { tmpdir } from "os";
+import { join } from "path";
+
+// src/rules.ts
+import { existsSync, readFileSync } from "fs";
+var SHADOW_ZH_RULE_SET = {
+  noiseNumberFonts: ["DIN Alternate"],
+  annotationNamePrefixes: ["0.\u4EA4\u4E92", "0.\u4EA4\u4E92\u6807\u8BB0"],
+  annotationFontIncludes: ["FZLanTingHeiS"],
+  anchorNamePrefixes: ["0.\u4EA4\u4E92\u6807\u8BB0"],
+  specFontIncludes: ["FZLanTingHeiS"],
+  marginNumberedItemPattern: "^[\\d\u2460\u2461\u2462\u2463\u2464\u2465\u2466\u2467\u2468\u2469\u4E00\u4E8C\u4E09\u56DB\u4E94\u516D\u4E03\u516B\u4E5D\u5341]+[.\u3001\\s\uFF09)]",
+  marginSpecPatterns: [
+    "^\u652F\u6301",
+    "^\u4E0D\u652F\u6301",
+    "^\u672C\u671F\u4EC5",
+    "^\u9ED8\u8BA4",
+    "^\u7EC4\u4EF6\u5E93",
+    "\u70B9\u51FB\u540E",
+    "\u5F39\u7A97\u9AD8\u5EA6",
+    "\u52A8\u6001\u9002\u914D",
+    "\u5185\u5BB9\u4E3A\u540E\u7AEF",
+    "\u5EFA\u8BAE\u63A7\u5236",
+    "\u60AC\u6D6E\u4E0D\u5C55\u793A",
+    "\u8D85\u51FA\u663E\u793A",
+    "\u5173\u952E\u8BCD\u6A21\u7CCA",
+    "\u65B0\u5F00\u9875\u9762",
+    "\u6D4B\u8BD5\u73AF\u5883",
+    "^\u9009\u586B",
+    "^\u5FC5\u586B",
+    "\u7B49\u957F\u6587\u672C"
+  ],
+  interactionStepPatterns: {
+    trigger: [
+      "\u70B9\u51FB",
+      "\u5355\u51FB",
+      "\u5207\u6362",
+      "\u9009\u62E9",
+      "\u8F93\u5165",
+      "\u641C\u7D22",
+      "hover",
+      "\u60AC\u6D6E",
+      "\u5C55\u5F00",
+      "\u6536\u8D77",
+      "\u62D6\u62FD",
+      "\u63D0\u4EA4",
+      "\u5220\u9664",
+      "\u65B0\u589E"
+    ],
+    condition: [
+      "\u5982\u679C",
+      "\u82E5",
+      "\u5F53",
+      "\u4EC5",
+      "\u9ED8\u8BA4",
+      "\u4E3A\u7A7A",
+      "\u65E0\u6743\u9650",
+      "\u5DF2",
+      "\u672A",
+      "\u6210\u529F",
+      "\u5931\u8D25",
+      "\u8D85\u8FC7",
+      "\u5927\u4E8E",
+      "\u5C0F\u4E8E",
+      "\u5FC5\u586B",
+      "\u9009\u586B"
+    ],
+    action: [
+      "\u5C55\u793A",
+      "\u663E\u793A",
+      "\u9690\u85CF",
+      "\u5237\u65B0",
+      "\u66F4\u65B0",
+      "\u8DF3\u8F6C",
+      "\u6253\u5F00",
+      "\u5173\u95ED",
+      "\u8BF7\u6C42",
+      "\u56DE\u663E",
+      "\u8FC7\u6EE4",
+      "\u6392\u5E8F",
+      "\u5206\u9875",
+      "\u6821\u9A8C",
+      "\u63D0\u793A",
+      "\u5F39\u7A97",
+      "\u4E0B\u8F7D",
+      "\u4E0A\u4F20",
+      "\u6267\u884C",
+      "\u521B\u5EFA",
+      "\u4FDD\u5B58"
+    ]
+  }
+};
+var GENERIC_RULE_SET = {
+  noiseNumberFonts: ["DIN Alternate", "DIN"],
+  annotationNamePrefixes: [
+    "0.\u4EA4\u4E92",
+    "0.\u4EA4\u4E92\u6807\u8BB0",
+    "interaction",
+    "annot",
+    "annotation",
+    "hotspot",
+    "flow"
+  ],
+  annotationFontIncludes: ["FZLanTingHeiS", "Annotation", "Comment"],
+  anchorNamePrefixes: ["0.\u4EA4\u4E92\u6807\u8BB0", "interaction", "hotspot", "anchor", "flow"],
+  specFontIncludes: ["FZLanTingHeiS", "Annotation", "Comment"],
+  marginNumberedItemPattern: "^[\\d\u2460\u2461\u2462\u2463\u2464\u2465\u2466\u2467\u2468\u2469\u4E00\u4E8C\u4E09\u56DB\u4E94\u516D\u4E03\u516B\u4E5D\u5341ivxIVX]+[.\u3001\\s\uFF09)]",
+  marginSpecPatterns: [
+    "^\u652F\u6301",
+    "^\u4E0D\u652F\u6301",
+    "^\u672C\u671F\u4EC5",
+    "^\u9ED8\u8BA4",
+    "^\u7EC4\u4EF6\u5E93",
+    "\u70B9\u51FB\u540E",
+    "\u5F39\u7A97\u9AD8\u5EA6",
+    "\u52A8\u6001\u9002\u914D",
+    "\u5185\u5BB9\u4E3A\u540E\u7AEF",
+    "\u5EFA\u8BAE\u63A7\u5236",
+    "\u60AC\u6D6E\u4E0D\u5C55\u793A",
+    "\u8D85\u51FA\u663E\u793A",
+    "\u5173\u952E\u8BCD\u6A21\u7CCA",
+    "\u65B0\u5F00\u9875\u9762",
+    "\u6D4B\u8BD5\u73AF\u5883",
+    "^\u9009\u586B",
+    "^\u5FC5\u586B",
+    "\u7B49\u957F\u6587\u672C",
+    "^support",
+    "^does not support",
+    "^default",
+    "^optional",
+    "^required",
+    "after click",
+    "click to",
+    "modal",
+    "dialog",
+    "dynamic",
+    "backend",
+    "open in new",
+    "test env",
+    "ellipsis"
+  ],
+  interactionStepPatterns: {
+    trigger: [
+      "\u70B9\u51FB",
+      "\u5355\u51FB",
+      "\u5207\u6362",
+      "\u9009\u62E9",
+      "\u8F93\u5165",
+      "\u641C\u7D22",
+      "hover",
+      "\u60AC\u6D6E",
+      "\u5C55\u5F00",
+      "\u6536\u8D77",
+      "\u62D6\u62FD",
+      "\u63D0\u4EA4",
+      "\u5220\u9664",
+      "\u65B0\u589E",
+      "click",
+      "tap",
+      "toggle",
+      "type",
+      "input",
+      "search",
+      "select",
+      "submit",
+      "remove",
+      "create",
+      "open",
+      "close"
+    ],
+    condition: [
+      "\u5982\u679C",
+      "\u82E5",
+      "\u5F53",
+      "\u4EC5",
+      "\u9ED8\u8BA4",
+      "\u4E3A\u7A7A",
+      "\u65E0\u6743\u9650",
+      "\u5DF2",
+      "\u672A",
+      "\u6210\u529F",
+      "\u5931\u8D25",
+      "\u8D85\u8FC7",
+      "\u5927\u4E8E",
+      "\u5C0F\u4E8E",
+      "\u5FC5\u586B",
+      "\u9009\u586B",
+      "if",
+      "when",
+      "only",
+      "default",
+      "empty",
+      "without permission",
+      "with permission",
+      "success",
+      "failed",
+      "greater than",
+      "less than",
+      "required",
+      "optional"
+    ],
+    action: [
+      "\u5C55\u793A",
+      "\u663E\u793A",
+      "\u9690\u85CF",
+      "\u5237\u65B0",
+      "\u66F4\u65B0",
+      "\u8DF3\u8F6C",
+      "\u6253\u5F00",
+      "\u5173\u95ED",
+      "\u8BF7\u6C42",
+      "\u56DE\u663E",
+      "\u8FC7\u6EE4",
+      "\u6392\u5E8F",
+      "\u5206\u9875",
+      "\u6821\u9A8C",
+      "\u63D0\u793A",
+      "\u5F39\u7A97",
+      "\u4E0B\u8F7D",
+      "\u4E0A\u4F20",
+      "\u6267\u884C",
+      "\u521B\u5EFA",
+      "\u4FDD\u5B58",
+      "show",
+      "hide",
+      "refresh",
+      "update",
+      "navigate",
+      "redirect",
+      "request",
+      "render",
+      "filter",
+      "sort",
+      "paginate",
+      "validate",
+      "toast",
+      "download",
+      "upload",
+      "execute",
+      "save"
+    ]
+  }
+};
+var BUILTIN_RULESETS = {
+  generic: GENERIC_RULE_SET,
+  shadow_zh: SHADOW_ZH_RULE_SET
+};
+function toArray(v) {
+  if (!Array.isArray(v)) return void 0;
+  const items = v.filter((x) => typeof x === "string").map((x) => x.trim());
+  return items.length > 0 ? items : [];
+}
+function toStringOrUndefined(v) {
+  if (typeof v !== "string") return void 0;
+  const s = v.trim();
+  return s.length > 0 ? s : "";
+}
+function mergeRuleSet(base, patch) {
+  return {
+    noiseNumberFonts: toArray(patch.noiseNumberFonts) ?? base.noiseNumberFonts,
+    annotationNamePrefixes: toArray(patch.annotationNamePrefixes) ?? base.annotationNamePrefixes,
+    annotationFontIncludes: toArray(patch.annotationFontIncludes) ?? base.annotationFontIncludes,
+    anchorNamePrefixes: toArray(patch.anchorNamePrefixes) ?? base.anchorNamePrefixes,
+    specFontIncludes: toArray(patch.specFontIncludes) ?? base.specFontIncludes,
+    marginNumberedItemPattern: toStringOrUndefined(patch.marginNumberedItemPattern) ?? base.marginNumberedItemPattern,
+    marginSpecPatterns: toArray(patch.marginSpecPatterns) ?? base.marginSpecPatterns,
+    interactionStepPatterns: {
+      trigger: toArray(patch.interactionStepPatterns?.trigger) ?? base.interactionStepPatterns.trigger,
+      condition: toArray(patch.interactionStepPatterns?.condition) ?? base.interactionStepPatterns.condition,
+      action: toArray(patch.interactionStepPatterns?.action) ?? base.interactionStepPatterns.action
+    }
+  };
+}
+function buildKeywordRegex(keywords) {
+  const escaped = keywords.map((k) => k.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"));
+  if (escaped.length === 0) return /^$/;
+  return new RegExp(escaped.join("|"), "i");
+}
+function compileRules(raw) {
+  return {
+    raw,
+    profileName: "custom",
+    marginNumberedItemRegex: new RegExp(raw.marginNumberedItemPattern),
+    marginSpecRegexes: raw.marginSpecPatterns.map((s) => new RegExp(s)),
+    interactionTriggerRegex: buildKeywordRegex(raw.interactionStepPatterns.trigger),
+    interactionConditionRegex: buildKeywordRegex(raw.interactionStepPatterns.condition),
+    interactionActionRegex: buildKeywordRegex(raw.interactionStepPatterns.action)
+  };
+}
+function loadPatchFromEnv() {
+  const path = process.env.SKETCH_MCP_RULESET_PATH;
+  if (!path) return {};
+  if (!existsSync(path)) {
+    throw new Error(`SKETCH_MCP_RULESET_PATH \u6587\u4EF6\u4E0D\u5B58\u5728: ${path}`);
+  }
+  const raw = readFileSync(path, "utf-8");
+  const parsed = JSON.parse(raw);
+  return parsed ?? {};
+}
+var cachedPath;
+var cachedProfileKey;
+var cachedRules = null;
+var runtimeProfileOverride = null;
+var runtimeProfileConfidence = 0.5;
+function getBaseRuleSet(profile) {
+  return BUILTIN_RULESETS[profile] ?? BUILTIN_RULESETS.shadow_zh;
+}
+function containsCJK(text) {
+  return /[\u4e00-\u9fff]/.test(text);
+}
+function normalizeForProfileCompare(value) {
+  return value.trim().toLowerCase();
+}
+function detectRuleProfile(layers) {
+  let zhScore = 0;
+  let genericScore = 0;
+  const sample = layers.slice(0, 1800);
+  for (const l of sample) {
+    const name = normalizeForProfileCompare(l.name ?? "");
+    const ff = normalizeForProfileCompare(l.fontFace ?? l.fontFamily ?? "");
+    const content = normalizeForProfileCompare(l.content ?? "");
+    if (name.startsWith("0.\u4EA4\u4E92\u6807\u8BB0") || name.startsWith("0.\u4EA4\u4E92")) zhScore += 4;
+    if (ff.includes("fzlantingheis")) zhScore += 3;
+    if (ff.includes("din alternate") && /^\d+$/.test(content)) zhScore += 1;
+    if (containsCJK(content) || containsCJK(name)) zhScore += 0.4;
+    if (name.includes("interaction") || name.includes("annot") || name.includes("hotspot") || name.includes("flow")) {
+      genericScore += 2;
+    }
+    if (/\b(click|tap|hover|select|input|search)\b/.test(content)) genericScore += 1;
+  }
+  const profile = zhScore >= 6 && zhScore >= genericScore * 1.2 ? "shadow_zh" : "generic";
+  const maxScore = Math.max(zhScore, genericScore, 1);
+  const delta = Math.abs(zhScore - genericScore);
+  const confidence = Math.max(
+    0.5,
+    Math.min(0.99, 0.5 + delta / (maxScore + 6) * 0.49)
+  );
+  return {
+    profile,
+    confidence: Number(confidence.toFixed(2)),
+    zhScore: Number(zhScore.toFixed(2)),
+    genericScore: Number(genericScore.toFixed(2))
+  };
+}
+function applyAutoRuleProfile(layers) {
+  const detection = detectRuleProfile(layers);
+  runtimeProfileOverride = detection.profile;
+  runtimeProfileConfidence = detection.confidence;
+  return detection;
+}
+function getEffectiveRuleProfileName() {
+  return process.env.SKETCH_MCP_RULESET_PROFILE ?? runtimeProfileOverride ?? "shadow_zh";
+}
+function getRuleRuntimeMeta() {
+  const forced = process.env.SKETCH_MCP_RULESET_PROFILE;
+  if (forced) {
+    const resolved = BUILTIN_RULESETS[forced] ? forced : "shadow_zh";
+    return {
+      profile: resolved,
+      confidence: 1,
+      source: "forced_env"
+    };
+  }
+  if (runtimeProfileOverride) {
+    return {
+      profile: runtimeProfileOverride,
+      confidence: runtimeProfileConfidence,
+      source: "auto"
+    };
+  }
+  return {
+    profile: "shadow_zh",
+    confidence: 0.5,
+    source: "default"
+  };
+}
+function getCompiledRules() {
+  const profile = getEffectiveRuleProfileName();
+  const path = process.env.SKETCH_MCP_RULESET_PATH;
+  if (cachedRules && cachedPath === path && cachedProfileKey === profile) return cachedRules;
+  const patch = loadPatchFromEnv();
+  const merged = mergeRuleSet(getBaseRuleSet(profile), patch);
+  cachedPath = path;
+  cachedProfileKey = profile;
+  cachedRules = {
+    ...compileRules(merged),
+    profileName: profile
+  };
+  return cachedRules;
+}
+function startsWithAny(value, prefixes) {
+  const left = normalizeForProfileCompare(value);
+  return prefixes.some((p) => {
+    const right = normalizeForProfileCompare(p);
+    return right.length > 0 && left.startsWith(right);
+  });
+}
+function includesAny(value, fragments) {
+  const left = normalizeForProfileCompare(value);
+  return fragments.some((f) => {
+    const right = normalizeForProfileCompare(f);
+    return right.length > 0 && left.includes(right);
+  });
+}
+
+// src/engine/core.ts
+process.env.NODE_TLS_REJECT_UNAUTHORIZED = "0";
+var CACHE_DIR = join(tmpdir(), "sketch_design_cache");
+mkdirSync(CACHE_DIR, { recursive: true });
+function cachePath(url) {
+  const h = createHash("md5").update(url).digest("hex");
+  return join(CACHE_DIR, `${h}.json`);
+}
+async function download(url) {
+  const cp = cachePath(url);
+  if (existsSync2(cp)) {
+    return readFileSync2(cp, "utf-8");
+  }
+  const resp = await fetch(url, {
+    signal: AbortSignal.timeout(3e4)
+  });
+  if (!resp.ok) {
+    throw new Error(`HTTP ${resp.status}: ${resp.statusText}`);
+  }
+  const html = await resp.text();
+  writeFileSync(cp, html, "utf-8");
+  return html;
+}
+function parseWudiApp(html) {
+  const marker = 'WudiApp({"';
+  const pos = html.lastIndexOf(marker);
+  if (pos === -1) {
+    throw new Error("\u672A\u627E\u5230 WudiApp \u6570\u636E\uFF0C\u8BF7\u68C0\u67E5 URL \u662F\u5426\u6B63\u786E");
+  }
+  const start = pos + "WudiApp(".length;
+  let depth = 0;
+  let i = start;
+  while (i < html.length) {
+    const c = html[i];
+    if (c === "\\" && i + 1 < html.length) {
+      i += 2;
+      continue;
+    }
+    if (c === '"') {
+      let j = i + 1;
+      while (j < html.length) {
+        if (html[j] === "\\" && j + 1 < html.length) {
+          j += 2;
+          continue;
+        }
+        if (html[j] === '"') break;
+        j++;
+      }
+      i = j + 1;
+      continue;
+    }
+    if (c === "{") depth++;
+    else if (c === "}") {
+      depth--;
+      if (depth === 0) break;
+    }
+    i++;
+  }
+  const jsonStr = html.substring(start, i + 1);
+  return JSON.parse(jsonStr);
+}
+var wudiCache = /* @__PURE__ */ new Map();
+var htmlOverride = null;
+function setHtmlOverride(filePath) {
+  htmlOverride = filePath;
+}
+async function getWudi(url) {
+  const cached = wudiCache.get(url);
+  if (cached) return cached;
+  const html = htmlOverride ? readFileSync2(htmlOverride, "utf-8") : await download(url);
+  const wudi = parseWudiApp(html);
+  const profileProbe = [...wudi.artboards].sort((a, b) => b.layers.length - a.layers.length)[0];
+  if (profileProbe) {
+    applyAutoRuleProfile(profileProbe.layers);
+  }
+  wudiCache.set(url, wudi);
+  return wudi;
+}
+function findArtboard(wudi, name = "") {
+  const query = (name ?? "").trim();
+  if (!query) {
+    const first = wudi.artboards[0];
+    if (!first) throw new Error("\u5F53\u524D\u9875\u9762\u6CA1\u6709\u53EF\u7528\u7684 artboard");
+    applyAutoRuleProfile(first.layers);
+    return first;
+  }
+  for (const ab of wudi.artboards) {
+    if (ab.name.includes(query) || query.includes(ab.name)) {
+      applyAutoRuleProfile(ab.layers);
+      return ab;
+    }
+  }
+  for (const ab of wudi.artboards) {
+    if (ab.slug && ab.slug.includes(query)) {
+      applyAutoRuleProfile(ab.layers);
+      return ab;
+    }
+  }
+  const available = wudi.artboards.map((a) => a.name);
+  throw new Error(`\u672A\u627E\u5230 artboard: ${query}\uFF0C\u53EF\u7528: ${JSON.stringify(available)}`);
+}
+
+// src/aggregator/base.ts
+function rect(l) {
+  const r = l.rect;
+  if (!r) return { x: 0, y: 0, width: 0, height: 0 };
+  return r;
+}
+function colorHex(colorDict) {
+  if (!colorDict) return "";
+  const val = colorDict["color-hex"] ?? "";
+  return val ? val.split(" ")[0] : "";
+}
+function bgColor(l) {
+  const fills = l.fills ?? [];
+  for (const fill of fills) {
+    const c = colorHex(fill.color);
+    if (c && c !== "#FFFFFF") return c;
+  }
+  for (const fill of fills) {
+    const c = colorHex(fill.color);
+    if (c) return c;
+  }
+  return "";
+}
+function borderInfo(l) {
+  const borders = l.borders ?? [];
+  if (borders.length === 0) return null;
+  const b = borders[0];
+  return {
+    color: colorHex(b.color),
+    width: b.thickness,
+    style: "solid"
+  };
+}
+function radius(l) {
+  const r = l.radius;
+  if (Array.isArray(r) && r.length > 0) return Math.floor(r[0]);
+  if (typeof r === "number") return Math.floor(r);
+  return 0;
+}
+function shadowInfo(l) {
+  const shadows = l.shadows ?? [];
+  if (shadows.length === 0) return null;
+  const s = shadows[0];
+  return {
+    color: colorHex(s.color),
+    x: s.x,
+    y: s.y,
+    blur: s.blur,
+    spread: s.spread
+  };
+}
+
+// src/aggregator/color.ts
+function hexToRgb(hex) {
+  const h = hex.replace("#", "");
+  return [
+    parseInt(h.substring(0, 2), 16),
+    parseInt(h.substring(2, 4), 16),
+    parseInt(h.substring(4, 6), 16)
+  ];
+}
+function luminance(hex) {
+  if (!hex || !hex.startsWith("#") || hex.length < 7) return -1;
+  const [r, g, b] = hexToRgb(hex);
+  const [rs, gs, bs] = [r / 255, g / 255, b / 255].map(
+    (c) => c <= 0.03928 ? c / 12.92 : Math.pow((c + 0.055) / 1.055, 2.4)
+  );
+  return 0.2126 * rs + 0.7152 * gs + 0.0722 * bs;
+}
+function isWhite(hex) {
+  if (!hex) return false;
+  const h = hex.toUpperCase();
+  return h === "#FFFFFF" || h === "#FFF" || luminance(h) > 0.95;
+}
+
+// src/aggregator/filters.ts
+function isNoise(l) {
+  const rules = getCompiledRules();
+  const name = l.name ?? "";
+  if (rules.raw.noiseNumberFonts.includes(l.fontFace ?? "")) {
+    const hex = l.color?.["color-hex"] ?? "";
+    if (isWhite(hex.replace(/ .*/, ""))) return true;
+  }
+  if (/^\d+$/.test(name)) return true;
+  return false;
+}
+function isAnnotation(l) {
+  const rules = getCompiledRules();
+  const name = l.name ?? "";
+  if (startsWithAny(name, rules.raw.annotationNamePrefixes)) return true;
+  if (includesAny(l.fontFace ?? "", rules.raw.annotationFontIncludes)) return true;
+  return false;
+}
+function detectDesignViewportWidth(layers) {
+  if (!layers || layers.length < 20) return 1440;
+  const rightEdges = [];
+  for (const l of layers) {
+    if (isNoise(l) || isAnnotation(l)) continue;
+    if (l.type !== "shape" && l.type !== "symbol" && l.type !== "group") continue;
+    const r = rect(l);
+    const w = r.width;
+    const h = r.height;
+    if (w >= 300 && h >= 100 && w <= 2e3 && h <= 5e3) {
+      rightEdges.push(Math.round(r.x + w));
+    }
+  }
+  if (rightEdges.length < 3) return 1440;
+  rightEdges.sort((a, b) => a - b);
+  let bestCenter = 1440;
+  let bestCount = 0;
+  for (let i = 0; i < rightEdges.length; i++) {
+    const center = rightEdges[i];
+    let count = 0;
+    for (let j = 0; j < rightEdges.length; j++) {
+      if (Math.abs(rightEdges[j] - center) <= 25) count++;
+    }
+    if (count > bestCount) {
+      bestCount = count;
+      bestCenter = center;
+    }
+  }
+  if (bestCount < rightEdges.length * 0.3) return 1440;
+  return Math.round(bestCenter / 10) * 10;
+}
+function isMarginSpecText(l, designWidth) {
+  const rules = getCompiledRules();
+  if (l.type !== "text") return false;
+  const r = rect(l);
+  if (r.x < designWidth) return false;
+  const content = (l.content ?? "").trim();
+  if (!content) return false;
+  if (rules.marginNumberedItemRegex.test(content)) {
+    return true;
+  }
+  for (const p of rules.marginSpecRegexes) {
+    if (p.test(content)) return true;
+  }
+  return false;
+}
+
+// src/v3/manifest.ts
+function scoreRecommended(name, width, height, layers) {
+  const normalized = name.toLowerCase();
+  let score = 0;
+  if (width >= 1200 && height >= 900) score += 0.5;
+  if (layers >= 80) score += Math.min(0.35, layers / 2200);
+  if (/工作空间|应用|知识库|评测|管理|列表|页面|主界面|问答|结果|发送|导航|菜单|配置|设置|编辑|创建|详情|消息|对话|聊天|参数|切片|prompt|检索|知识/i.test(
+    normalized
+  )) {
+    score += 0.5;
+  }
+  if (/封面|修订记录|说明|示例|规范|目录/.test(normalized)) score -= 0.4;
+  return score;
+}
+function buildArtboardManifest(artboards) {
+  return artboards.map((ab) => {
+    let textLayers = 0;
+    let shapeLikeLayers = 0;
+    for (const l of ab.layers) {
+      if (l.type === "text") textLayers++;
+      if (l.type === "shape" || l.type === "symbol" || l.type === "group") {
+        shapeLikeLayers++;
+      }
+    }
+    const designWidth = detectDesignViewportWidth(ab.layers);
+    const complexityScore = Number(
+      (ab.layers.length * 2e-3 + Math.max(0, ab.height / 1800) + Math.max(0, shapeLikeLayers / 500) + Math.max(0, textLayers / 300)).toFixed(2)
+    );
+    const recommended = scoreRecommended(ab.name, ab.width, ab.height, ab.layers.length) >= 0.9;
+    return {
+      name: ab.name,
+      slug: ab.slug,
+      width: ab.width,
+      height: ab.height,
+      totalLayers: ab.layers.length,
+      textLayers,
+      shapeLikeLayers,
+      designWidth,
+      complexityScore,
+      recommended
+    };
+  }).sort(
+    (a, b) => Number(b.recommended) - Number(a.recommended) || b.complexityScore - a.complexityScore
+  );
+}
+
+// src/v3/constants.ts
+var DEFAULT_MAX_NODES = 900;
+var DEFAULT_MAX_COMPONENTS = 500;
+
+// src/v3/scene.ts
+function area(r) {
+  return Math.max(0, r.width) * Math.max(0, r.height);
+}
+function inRegion(r, yMin, yMax) {
+  const top = r.y;
+  const bottom = r.y + r.height;
+  return bottom >= yMin - 40 && top <= yMax + 40;
+}
+function withRegionDefaults(artboard, options) {
+  const yMin = options?.pageY ?? 0;
+  const pageHeight = options?.pageHeight ?? Math.max(artboard.height, 2e3);
+  const yMax = yMin + pageHeight;
+  return { yMin, yMax };
+}
+function guessKind(rawType) {
+  if (rawType === "text") return "text";
+  if (rawType === "shape") return "shape";
+  if (rawType === "symbol") return "symbol";
+  if (rawType === "group") return "group";
+  return "unknown";
+}
+function containsRect(outer, inner, padding = 2) {
+  return outer.x - padding <= inner.x && outer.y - padding <= inner.y && inner.x + inner.width <= outer.x + outer.width + padding && inner.y + inner.height <= outer.y + outer.height + padding;
+}
+function estimateConstraints(parent, child) {
+  const left = Math.round(child.x - parent.x);
+  const right = Math.round(parent.x + parent.width - (child.x + child.width));
+  const top = Math.round(child.y - parent.y);
+  const bottom = Math.round(parent.y + parent.height - (child.y + child.height));
+  let horizontal = "free";
+  let vertical = "free";
+  if (left <= 8 && right <= 8) horizontal = "stretch";
+  else if (Math.abs(left - right) <= 6) horizontal = "center";
+  else if (left <= 12) horizontal = "pin_left";
+  else if (right <= 12) horizontal = "pin_right";
+  if (top <= 8 && bottom <= 8) vertical = "stretch";
+  else if (Math.abs(top - bottom) <= 6) vertical = "center";
+  else if (top <= 12) vertical = "pin_top";
+  else if (bottom <= 12) vertical = "pin_bottom";
+  return { horizontal, vertical, left, right, top, bottom };
+}
+function normalizeLayer(layer, index) {
+  const layerRect = rect(layer);
+  const kind = guessKind(layer.type ?? "unknown");
+  const fontFace = layer.fontFace ?? layer.fontFamily ?? "";
+  const fontWeight = /Medium|Bold|Semibold|Heavy|Black/i.test(fontFace) ? "Medium" : "Regular";
+  const style = {
+    bg: bgColor(layer) || void 0,
+    border: borderInfo(layer),
+    radius: radius(layer),
+    shadow: shadowInfo(layer),
+    opacity: layer.opacity ?? 1,
+    textColor: colorHex(layer.color) || void 0,
+    fontSize: layer.fontSize,
+    fontFamily: fontFace || void 0,
+    fontWeight,
+    lineHeight: layer.lineHeight,
+    letterSpacing: layer.letterSpacing,
+    textAlign: layer.textAlign
+  };
+  return {
+    id: `n${index + 1}`,
+    rawIndex: index,
+    rawType: layer.type ?? "unknown",
+    name: layer.name ?? "",
+    kind,
+    rect: layerRect,
+    style,
+    text: layer.type === "text" ? (layer.content ?? "").trim() : void 0,
+    zIndex: index
+  };
+}
+function isThinSeparator(r) {
+  return r.width >= 48 && r.height <= 3 || r.height >= 48 && r.width <= 3;
+}
+function median(values, fallback) {
+  const sorted = values.filter((v) => Number.isFinite(v) && v > 0).sort((a, b) => a - b);
+  if (sorted.length === 0) return fallback;
+  const mid = Math.floor(sorted.length / 2);
+  return sorted.length % 2 === 0 ? (sorted[mid - 1] + sorted[mid]) / 2 : sorted[mid];
+}
+function normalizeLabel(text) {
+  return (text ?? "").replace(/\s+/g, " ").trim();
+}
+function isMeaningfulSectionLabel(text) {
+  const value = normalizeLabel(text);
+  if (value.length < 2) return false;
+  if (/^[\d\s.、():：-]+$/.test(value)) return false;
+  if (/^[-–—·•|/\\]+$/.test(value)) return false;
+  return true;
+}
+function isStrongFontWeight(weight) {
+  return /Medium|Semibold|Demi|Bold|Heavy|Black/i.test(weight ?? "");
+}
+function isSectionHeadingSeed(node, medianFontSize) {
+  if (node.kind !== "text" || !isMeaningfulSectionLabel(node.text)) return false;
+  const fs = node.style.fontSize ?? medianFontSize;
+  const threshold = Math.max(14, medianFontSize * 1.14);
+  return fs >= threshold || isStrongFontWeight(node.style.fontWeight);
+}
+function pickSectionName(nodes) {
+  const textNodes = nodes.filter((n) => n.kind === "text" && isMeaningfulSectionLabel(n.text)).sort((a, b) => {
+    const fa = a.style.fontSize ?? 12;
+    const fb = b.style.fontSize ?? 12;
+    if (fb !== fa) return fb - fa;
+    const wa = isStrongFontWeight(a.style.fontWeight) ? 1 : 0;
+    const wb = isStrongFontWeight(b.style.fontWeight) ? 1 : 0;
+    if (wb !== wa) return wb - wa;
+    return a.rect.y - b.rect.y || a.rect.x - b.rect.x;
+  });
+  if (textNodes.length === 0) return "";
+  return normalizeLabel(textNodes[0].text);
+}
+function sectionBounds(nodes) {
+  const useful = nodes.filter((n) => !isThinSeparator(n.rect));
+  const candidates = useful.length > 0 ? useful : nodes;
+  const xMin = Math.min(...candidates.map((n) => n.rect.x));
+  const yMin = Math.min(...candidates.map((n) => n.rect.y));
+  const xMax = Math.max(...candidates.map((n) => n.rect.x + n.rect.width));
+  const yMax = Math.max(...candidates.map((n) => n.rect.y + n.rect.height));
+  return { x: xMin, y: yMin, width: xMax - xMin, height: yMax - yMin };
+}
+function collectSectionMembers(allNodes, seeds, medianFontSize) {
+  const top = Math.min(...seeds.map((n) => n.rect.y));
+  const bottom = Math.max(...seeds.map((n) => n.rect.y + n.rect.height));
+  const pad = Math.max(64, Math.min(140, medianFontSize * 6));
+  const seedIds = new Set(seeds.map((n) => n.id));
+  const members = [];
+  for (const node of allNodes) {
+    if (node.id === "root") continue;
+    if (isThinSeparator(node.rect)) continue;
+    const cy = node.rect.y + node.rect.height / 2;
+    const nearBand = cy >= top - pad && cy <= bottom + pad;
+    const seed = seedIds.has(node.id);
+    if (nearBand || seed) members.push(node);
+  }
+  return members.length > 0 ? members : seeds;
+}
+function detectSections(nodes) {
+  const textNodes = nodes.filter((n) => n.kind === "text" && n.text);
+  const medianFontSize = median(
+    textNodes.map((n) => n.style.fontSize ?? 0),
+    14
+  );
+  const headingSeeds = textNodes.filter((n) => isSectionHeadingSeed(n, medianFontSize)).sort((a, b) => a.rect.y - b.rect.y || a.rect.x - b.rect.x);
+  const fallbackSeeds = nodes.filter((n) => n.parentId === "root" && n.id !== "root").filter((n) => !isThinSeparator(n.rect)).filter(
+    (n) => n.rect.width >= 80 || n.kind === "text" && (n.style.fontSize ?? 0) >= medianFontSize
+  ).sort((a, b) => a.rect.y - b.rect.y || a.rect.x - b.rect.x);
+  const seeds = headingSeeds.length > 0 ? headingSeeds : fallbackSeeds;
+  if (seeds.length === 0) return [];
+  const groups = [];
+  let current = [seeds[0]];
+  for (let i = 1; i < seeds.length; i++) {
+    const prev = seeds[i - 1];
+    const curr = seeds[i];
+    const gap = curr.rect.y - (prev.rect.y + prev.rect.height);
+    const gapLimit = Math.max(
+      72,
+      Math.min(220, Math.max(prev.rect.height, curr.rect.height, medianFontSize * 6))
+    );
+    if (gap > gapLimit) {
+      groups.push(current);
+      current = [curr];
+    } else {
+      current.push(curr);
+    }
+  }
+  groups.push(current);
+  const sections = [];
+  for (const group of groups) {
+    const members = collectSectionMembers(nodes, group, medianFontSize);
+    if (members.length === 0) continue;
+    const bounds = sectionBounds(members);
+    if (bounds.width < 20 || bounds.height < 8) continue;
+    const name = pickSectionName(members) || pickSectionName(group) || `Section ${sections.length + 1}`;
+    sections.push({
+      id: `s${sections.length + 1}`,
+      name,
+      bounds,
+      nodeIds: members.map((n) => n.id)
+    });
+  }
+  return sections;
+}
+function nearestSectionId(sections, bounds) {
+  if (sections.length === 0) return void 0;
+  const cy = bounds.y + bounds.height / 2;
+  let best = null;
+  for (const s of sections) {
+    const sy = s.bounds.y + s.bounds.height / 2;
+    const score = Math.abs(cy - sy);
+    if (!best || score < best.score) best = { id: s.id, score };
+  }
+  return best?.id;
+}
+function isLikelyGray(hex) {
+  if (!hex || !hex.startsWith("#") || hex.length < 7) return false;
+  const r = parseInt(hex.slice(1, 3), 16);
+  const g = parseInt(hex.slice(3, 5), 16);
+  const b = parseInt(hex.slice(5, 7), 16);
+  const max = Math.max(r, g, b);
+  const min = Math.min(r, g, b);
+  return max - min < 28;
+}
+function getNodeMap(nodes) {
+  const map = /* @__PURE__ */ new Map();
+  for (const n of nodes) map.set(n.id, n);
+  return map;
+}
+function directChildren(node, map) {
+  return node.children.map((id) => map.get(id)).filter((v) => Boolean(v));
+}
+function getDescendantText(node, map, limit = 16) {
+  const out = [];
+  const stack = [...node.children];
+  while (stack.length > 0 && out.length < limit) {
+    const id = stack.pop();
+    const n = map.get(id);
+    if (!n) continue;
+    if (n.kind === "text" && n.text) out.push(n);
+    for (const child of n.children) stack.push(child);
+  }
+  return out;
+}
+function centeredScore(parent, child) {
+  const px = parent.x + parent.width / 2;
+  const py = parent.y + parent.height / 2;
+  const cx = child.x + child.width / 2;
+  const cy = child.y + child.height / 2;
+  const dx = Math.abs(px - cx) / Math.max(1, parent.width);
+  const dy = Math.abs(py - cy) / Math.max(1, parent.height);
+  return Math.max(0, 1 - (dx + dy) * 1.8);
+}
+function extractComponentCandidates(nodes, sections) {
+  const map = getNodeMap(nodes);
+  const byNode = /* @__PURE__ */ new Map();
+  const kindPriority = {
+    heading: 100,
+    button: 90,
+    select: 86,
+    input: 85,
+    textarea: 84,
+    tab_group: 78,
+    table: 70,
+    modal: 68,
+    card: 60,
+    list_item: 52,
+    tag: 40
+  };
+  const pushCandidate = (candidate) => {
+    const arr = byNode.get(candidate.nodeId) ?? [];
+    arr.push(candidate);
+    byNode.set(candidate.nodeId, arr);
+  };
+  const sortByGeometry = (a, b) => a.rect.y - b.rect.y || a.rect.x - b.rect.x || a.zIndex - b.zIndex;
+  for (const node of nodes) {
+    if (node.id === "root") continue;
+    if (node.kind === "text" && node.text) {
+      const fs = node.style.fontSize ?? 12;
+      const fw = node.style.fontWeight ?? "Regular";
+      const label = normalizeLabel(node.text);
+      if (label.length >= 2 && (fs >= 18 || fs >= 16 && isStrongFontWeight(fw))) {
+        pushCandidate({
+          id: `c-${node.id}-heading`,
+          nodeId: node.id,
+          kind: "heading",
+          confidence: fs >= 18 ? 0.95 : 0.84,
+          bounds: node.rect,
+          text: label,
+          style: node.style,
+          sectionId: nearestSectionId(sections, node.rect),
+          reasons: ["\u6587\u672C\u5B57\u53F7\u8F83\u5927\uFF0C\u7B26\u5408\u6807\u9898\u7279\u5F81"]
+        });
+      }
+      continue;
+    }
+    if (node.kind === "shape" || node.kind === "symbol" || node.kind === "group" || node.kind === "unknown") {
+      if (isThinSeparator(node.rect)) continue;
+      const children = directChildren(node, map);
+      const textChildren = children.filter((c) => c.kind === "text" && c.text).sort(sortByGeometry);
+      const textDesc = getDescendantText(node, map, 24).sort(sortByGeometry);
+      const w = node.rect.width;
+      const h = node.rect.height;
+      const bg = node.style.bg;
+      const hasBorder = Boolean(node.style.border);
+      const primaryText = normalizeLabel(textChildren[0]?.text ?? textDesc[0]?.text);
+      const labelList = [
+        ...new Set(
+          [...textChildren, ...textDesc].map((t) => normalizeLabel(t.text)).filter((t) => isMeaningfulSectionLabel(t))
+        )
+      ];
+      const reasons = [];
+      const hasIconLikeChild = children.some(
+        (c) => c.kind !== "text" && c.id !== "root" && area(c.rect) <= 900 && c.rect.width <= 32 && c.rect.height <= 32
+      );
+      const tabCandidates = textChildren.filter((t) => isMeaningfulSectionLabel(t.text) && (t.text ?? "").trim().length <= 18);
+      let tabGroupScore = 0;
+      if (tabCandidates.length >= 2 && w >= 120 && w <= 900 && h <= 88) {
+        const baseY = tabCandidates[0].rect.y;
+        const aligned = tabCandidates.every((t) => Math.abs(t.rect.y - baseY) <= 18);
+        if (aligned) {
+          tabGroupScore += 0.45;
+          reasons.push("\u591A\u4E2A\u77ED\u6587\u672C\u6A2A\u5411\u6392\u5E03\uFF0C\u7B26\u5408 Tab/\u5206\u6BB5\u63A7\u4EF6\u7279\u5F81");
+        }
+        if (tabCandidates.length >= 3) tabGroupScore += 0.2;
+        if (hasBorder || bg) tabGroupScore += 0.12;
+        if (tabGroupScore >= 0.72) {
+          pushCandidate({
+            id: `c-${node.id}-tab-group`,
+            nodeId: node.id,
+            kind: "tab_group",
+            confidence: Math.min(0.96, tabGroupScore),
+            bounds: node.rect,
+            text: tabCandidates.map((t) => normalizeLabel(t.text)).join(" / "),
+            style: node.style,
+            sectionId: nearestSectionId(sections, node.rect),
+            reasons: [...reasons]
+          });
+        }
+      }
+      let buttonScore = 0;
+      if (w >= 48 && w <= 360 && h >= 24 && h <= 72) {
+        buttonScore += 0.22;
+        reasons.push("\u5C3A\u5BF8\u63A5\u8FD1\u6309\u94AE\u5E38\u89C1\u89C4\u683C");
+      }
+      if (labelList.length === 1 && labelList[0].length <= 18) {
+        buttonScore += 0.24;
+        reasons.push("\u5355\u6587\u672C\u4E14\u957F\u5EA6\u77ED");
+        if (textChildren.length === 1) {
+          buttonScore += centeredScore(node.rect, textChildren[0].rect) * 0.2;
+        }
+      }
+      if (bg && bg !== "#FFFFFF") {
+        buttonScore += 0.2;
+        reasons.push("\u5B58\u5728\u975E\u767D\u5E95\u80CC\u666F\u8272");
+      }
+      if (hasBorder) buttonScore += 0.12;
+      if ((node.style.radius ?? 0) >= 4) buttonScore += 0.08;
+      if (hasIconLikeChild) buttonScore += 0.06;
+      if (buttonScore >= 0.62) {
+        pushCandidate({
+          id: `c-${node.id}-button`,
+          nodeId: node.id,
+          kind: "button",
+          confidence: Math.min(0.99, buttonScore),
+          bounds: node.rect,
+          text: primaryText,
+          style: node.style,
+          sectionId: nearestSectionId(sections, node.rect),
+          reasons: [...reasons]
+        });
+      }
+      let inputScore = 0;
+      const placeholderText = textDesc.find(
+        (t) => /请输入|搜索|请选择|筛选|任务名称|关键词|内容|输入|查询|选择/i.test(
+          normalizeLabel(t.text)
+        )
+      );
+      const multilineText = textDesc.some((t) => (t.text ?? "").includes("\n"));
+      const inputCue = Boolean(placeholderText) || textDesc.some((t) => isLikelyGray(t.style.textColor)) || /输入|搜索|选择|筛选|关键词|查询/i.test((node.name ?? "") + (primaryText ?? ""));
+      if (w >= 140 && w <= 720 && h >= 28 && h <= 64) inputScore += 0.22;
+      if (hasBorder || bg === "#FFFFFF") inputScore += 0.16;
+      if (placeholderText) inputScore += 0.35;
+      if (textDesc.some((t) => isLikelyGray(t.style.textColor))) inputScore += 0.08;
+      if (textChildren.length === 0 && textDesc.length <= 2) inputScore += 0.08;
+      if (!inputCue) inputScore -= 0.14;
+      if (inputCue && inputScore >= 0.7) {
+        pushCandidate({
+          id: `c-${node.id}-input`,
+          nodeId: node.id,
+          kind: /选择|下拉/i.test((node.name ?? "") + (primaryText ?? "")) ? "select" : "input",
+          confidence: Math.min(0.98, inputScore),
+          bounds: node.rect,
+          text: primaryText,
+          style: node.style,
+          sectionId: nearestSectionId(sections, node.rect),
+          reasons: ["\u5C3A\u5BF8+\u8FB9\u6846+\u5360\u4F4D\u6587\u672C\u7B26\u5408\u8F93\u5165\u7EC4\u4EF6\u7279\u5F81"]
+        });
+      }
+      let textareaScore = 0;
+      const textareaCue = Boolean(placeholderText) || multilineText;
+      if (w >= 180 && w <= 960 && h >= 72 && h <= 420) textareaScore += 0.24;
+      if (multilineText) textareaScore += 0.32;
+      if (placeholderText) textareaScore += 0.28;
+      if (hasBorder || bg === "#FFFFFF") textareaScore += 0.18;
+      if (textDesc.length >= 2 && textDesc.length <= 6) textareaScore += 0.08;
+      if (!textareaCue) textareaScore -= 0.16;
+      if (textareaCue && textareaScore >= 0.68) {
+        pushCandidate({
+          id: `c-${node.id}-textarea`,
+          nodeId: node.id,
+          kind: "textarea",
+          confidence: Math.min(0.96, textareaScore),
+          bounds: node.rect,
+          text: primaryText,
+          style: node.style,
+          sectionId: nearestSectionId(sections, node.rect),
+          reasons: ["\u5927\u5C3A\u5BF8\u8F93\u5165\u533A\u5757\uFF0C\u7B26\u5408\u591A\u884C\u6587\u672C\u533A\u57DF\u7279\u5F81"]
+        });
+      }
+      let tagScore = 0;
+      if (w <= 180 && h <= 44) tagScore += 0.28;
+      if (labelList.length === 1 && labelList[0].length <= 12) {
+        tagScore += 0.28;
+      }
+      if (bg || hasBorder) tagScore += 0.2;
+      if ((node.style.radius ?? 0) >= 6) tagScore += 0.1;
+      if (w <= 120 && h <= 32) tagScore += 0.08;
+      if (tagScore >= 0.66) {
+        pushCandidate({
+          id: `c-${node.id}-tag`,
+          nodeId: node.id,
+          kind: "tag",
+          confidence: Math.min(0.95, tagScore),
+          bounds: node.rect,
+          text: primaryText,
+          style: node.style,
+          sectionId: nearestSectionId(sections, node.rect),
+          reasons: ["\u5C0F\u5C3A\u5BF8+\u5355\u6587\u672C\uFF0C\u7B26\u5408\u6807\u7B7E/\u7B5B\u9009\u9879\u7279\u5F81"]
+        });
+      }
+      let modalScore = 0;
+      if (w >= 280 && w <= 980 && h >= 180) modalScore += 0.35;
+      if ((node.style.shadow?.blur ?? 0) > 0) modalScore += 0.2;
+      if ((node.style.radius ?? 0) >= 4) modalScore += 0.1;
+      if (textDesc.length >= 2) modalScore += 0.15;
+      if (modalScore >= 0.72) {
+        pushCandidate({
+          id: `c-${node.id}-modal`,
+          nodeId: node.id,
+          kind: "modal",
+          confidence: Math.min(0.93, modalScore),
+          bounds: node.rect,
+          text: primaryText,
+          style: node.style,
+          sectionId: nearestSectionId(sections, node.rect),
+          reasons: ["\u5927\u9762\u79EF\u5BB9\u5668+\u9634\u5F71/\u5706\u89D2\uFF0C\u7B26\u5408\u5F39\u5C42\u7279\u5F81"]
+        });
+      }
+      let tableScore = 0;
+      const wideChildren = children.filter(
+        (c) => c.kind !== "text" && c.rect.width >= Math.max(400, w * 0.55) && c.rect.height >= 28 && c.rect.height <= 84
+      );
+      if (w >= 560 && h >= 180) tableScore += 0.25;
+      if (wideChildren.length >= 3) tableScore += 0.45;
+      if (textDesc.length >= 8) tableScore += 0.15;
+      if (tableScore >= 0.72) {
+        pushCandidate({
+          id: `c-${node.id}-table`,
+          nodeId: node.id,
+          kind: "table",
+          confidence: Math.min(0.96, tableScore),
+          bounds: node.rect,
+          style: node.style,
+          sectionId: nearestSectionId(sections, node.rect),
+          reasons: ["\u5BBD\u5217\u8868\u7ED3\u6784\u660E\u663E\uFF0C\u542B\u591A\u884C\u91CD\u590D\u5757"]
+        });
+      }
+      if (w >= 220 && w <= 720 && h >= 100 && h <= 420 && (bg || hasBorder)) {
+        const cardScore = 0.62 + Math.min(0.28, textDesc.length * 0.03);
+        if (cardScore >= 0.7) {
+          pushCandidate({
+            id: `c-${node.id}-card`,
+            nodeId: node.id,
+            kind: "card",
+            confidence: Math.min(0.9, cardScore),
+            bounds: node.rect,
+            text: primaryText,
+            style: node.style,
+            sectionId: nearestSectionId(sections, node.rect),
+            reasons: ["\u4E2D\u7B49\u5C3A\u5BF8\u5BB9\u5668\uFF0C\u7B26\u5408\u5361\u7247\u7ED3\u6784"]
+          });
+        }
+      }
+    }
+  }
+  const bestByNode = /* @__PURE__ */ new Map();
+  for (const candidates of byNode.values()) {
+    candidates.sort((a, b) => {
+      if (b.confidence !== a.confidence) return b.confidence - a.confidence;
+      return (kindPriority[b.kind] ?? 0) - (kindPriority[a.kind] ?? 0);
+    });
+    const best = candidates[0];
+    if (!best) continue;
+    const current = bestByNode.get(best.nodeId);
+    if (!current || best.confidence > current.confidence || best.confidence === current.confidence && (kindPriority[best.kind] ?? 0) > (kindPriority[current.kind] ?? 0)) {
+      bestByNode.set(best.nodeId, best);
+    }
+  }
+  return [...bestByNode.values()].sort((a, b) => {
+    if (b.confidence !== a.confidence) return b.confidence - a.confidence;
+    return (kindPriority[b.kind] ?? 0) - (kindPriority[a.kind] ?? 0);
+  });
+}
+function buildSceneGraph(artboard, options) {
+  const { yMin, yMax } = withRegionDefaults(artboard, options);
+  const designWidth = detectDesignViewportWidth(artboard.layers);
+  const normalized = [];
+  for (let i = 0; i < artboard.layers.length; i++) {
+    const raw = artboard.layers[i];
+    if (isNoise(raw) || isAnnotation(raw)) continue;
+    if (isMarginSpecText(raw, designWidth)) continue;
+    const layer = normalizeLayer(raw, i);
+    if (!inRegion(layer.rect, yMin, yMax)) continue;
+    if (layer.rect.width <= 0 || layer.rect.height <= 0) continue;
+    normalized.push(layer);
+  }
+  const maxNodes = options?.maxNodes ?? DEFAULT_MAX_NODES;
+  const truncated = normalized.length > maxNodes;
+  const sliced = normalized.slice(0, maxNodes);
+  const nodes = [
+    {
+      id: "root",
+      rawIndex: -1,
+      rawType: "artboard",
+      kind: "root",
+      name: artboard.name,
+      rect: { x: 0, y: 0, width: designWidth, height: artboard.height },
+      zIndex: -1,
+      parentId: "",
+      children: [],
+      style: {}
+    }
+  ];
+  for (const layer of sliced) {
+    nodes.push({
+      id: layer.id,
+      rawIndex: layer.rawIndex,
+      rawType: layer.rawType,
+      kind: layer.kind,
+      name: layer.name,
+      text: layer.text,
+      rect: layer.rect,
+      zIndex: layer.zIndex,
+      parentId: "root",
+      children: [],
+      style: layer.style
+    });
+  }
+  const map = getNodeMap(nodes);
+  const candidates = nodes.filter((n) => n.id !== "root").map((n) => ({ node: n, area: area(n.rect) })).sort((a, b) => a.area - b.area);
+  for (const { node } of candidates) {
+    let bestParent;
+    for (const maybe of nodes) {
+      if (maybe.id === "root" || maybe.id === node.id) continue;
+      if (maybe.kind === "text") continue;
+      const parentArea = area(maybe.rect);
+      const childArea = area(node.rect);
+      if (parentArea <= childArea * 1.05) continue;
+      if (!containsRect(maybe.rect, node.rect, 2)) continue;
+      if (!bestParent || area(bestParent.rect) > parentArea) {
+        bestParent = maybe;
+      }
+    }
+    if (bestParent) node.parentId = bestParent.id;
+  }
+  for (const node of nodes) {
+    if (node.id === "root") continue;
+    const parent = map.get(node.parentId) ?? map.get("root");
+    if (parent) parent.children.push(node.id);
+  }
+  for (const node of nodes) {
+    node.children.sort((a, b) => {
+      const na = map.get(a);
+      const nb = map.get(b);
+      if (!na || !nb) return 0;
+      return na.rect.y - nb.rect.y || na.rect.x - nb.rect.x || na.zIndex - nb.zIndex;
+    });
+  }
+  for (const node of nodes) {
+    if (node.id === "root") continue;
+    const parent = map.get(node.parentId);
+    if (!parent) continue;
+    node.constraints = estimateConstraints(parent.rect, node.rect);
+  }
+  const sections = detectSections(nodes);
+  return {
+    artboard: artboard.name,
+    width: artboard.width,
+    height: artboard.height,
+    designWidth,
+    region: { yMin, yMax },
+    rootId: "root",
+    nodeCount: nodes.length,
+    truncated,
+    sections,
+    nodes
+  };
+}
+
+// src/v3/ai.ts
+import { createHash as createHash2 } from "crypto";
+var MAX_BLOCKS_PER_REQUEST = 6;
+var REQUEST_TIMEOUT_MS = 3e4;
+var analysisCache = /* @__PURE__ */ new Map();
+var visualStateEnum = [
+  "hover",
+  "active",
+  "selected",
+  "disabled",
+  "loading",
+  "empty",
+  "error",
+  "focus",
+  "open",
+  "closed",
+  "expanded",
+  "collapsed",
+  "pressed",
+  "unknown"
+];
+var interactionRoleEnum = [
+  "trigger",
+  "condition",
+  "action",
+  "visual_state",
+  "note"
+];
+function env(name) {
+  return process.env[name]?.trim() ?? "";
+}
+function resolveConfig() {
+  const providerEnv = env("SKETCH_MCP_INTERACTION_PROVIDER").toLowerCase().trim();
+  const provider = providerEnv === "fallback" ? "fallback" : "anthropic";
+  const apiKey = env("SKETCH_MCP_AUTH_TOKEN");
+  const enabled = provider !== "fallback" && Boolean(apiKey);
+  const model = env("SKETCH_MCP_INTERACTION_MODEL");
+  const baseUrl = env("SKETCH_MCP_BASE_URL");
+  return { provider, enabled, model, baseUrl, apiKey };
+}
+function stableHash(value) {
+  return createHash2("sha256").update(JSON.stringify(value)).digest("hex");
+}
+function compactRect(rect2) {
+  return {
+    x: Math.round(rect2.x),
+    y: Math.round(rect2.y),
+    width: Math.round(rect2.width),
+    height: Math.round(rect2.height)
+  };
+}
+function summarizeNode(node) {
+  return {
+    id: node.id,
+    kind: node.kind,
+    name: node.name,
+    text: node.text,
+    rect: compactRect(node.rect),
+    style: {
+      bg: node.style.bg,
+      border: node.style.border ? {
+        color: node.style.border.color,
+        width: node.style.border.width
+      } : null,
+      radius: node.style.radius,
+      shadow: node.style.shadow ? {
+        color: node.style.shadow.color,
+        x: node.style.shadow.x,
+        y: node.style.shadow.y,
+        blur: node.style.shadow.blur,
+        spread: node.style.shadow.spread
+      } : null,
+      opacity: node.style.opacity,
+      textColor: node.style.textColor,
+      fontSize: node.style.fontSize,
+      fontWeight: node.style.fontWeight
+    }
+  };
+}
+function buildUserPayload(blocks) {
+  return JSON.stringify(
+    {
+      blocks: blocks.map((block) => ({
+        blockId: block.blockId,
+        anchor: block.anchor,
+        target: block.target,
+        section: block.section,
+        specLines: block.specLines,
+        nearbyNodes: block.nearbyNodes
+      }))
+    },
+    null,
+    2
+  );
+}
+function buildSystemPrompt() {
+  return [
+    "\u4F60\u662F\u8BBE\u8BA1\u7A3F\u4EA4\u4E92\u7406\u89E3\u5668\u3002",
+    "\u4F60\u7684\u4EFB\u52A1\u662F\u57FA\u4E8E\u8F93\u5165\u7684\u4EA4\u4E92\u5757\u3001\u951A\u70B9\u3001\u76EE\u6807\u7EC4\u4EF6\u548C\u9644\u8FD1\u89C6\u89C9\u8282\u70B9\uFF0C\u7406\u89E3\u8FD9\u6BB5\u8BF4\u660E\u771F\u6B63\u63CF\u8FF0\u7684\u4EA4\u4E92\u4E0E\u89C6\u89C9\u72B6\u6001\u3002",
+    "\u4E0D\u8981\u7528\u5B57\u9762\u5173\u952E\u8BCD\u89C4\u5219\u53BB\u5206\u7C7B\uFF1B\u8981\u6309\u8BED\u4E49\u7406\u89E3\u6BCF\u4E00\u884C\u5C5E\u4E8E\u89E6\u53D1\u3001\u6761\u4EF6\u3001\u52A8\u4F5C\u3001\u89C6\u89C9\u72B6\u6001\u8FD8\u662F\u5907\u6CE8\u3002",
+    "\u5982\u679C\u4E00\u6BB5\u8BF4\u660E\u540C\u65F6\u5305\u542B\u884C\u4E3A\u548C\u89C6\u89C9\u72B6\u6001\uFF0C\u8BF7\u8F93\u51FA mixed\uFF0C\u5E76\u5728 visualHints \u91CC\u63CF\u8FF0\u72B6\u6001\u53D8\u5316\u3002",
+    "\u5982\u679C\u8BF4\u660E\u63CF\u8FF0\u7684\u662F hover\u3001active\u3001selected\u3001disabled\u3001loading\u3001empty\u3001error\u3001focus\u3001open\u3001closed\u3001expanded\u3001collapsed\u3001pressed \u7B49\u72B6\u6001\uFF0C\u8BF7\u4F18\u5148\u5199\u8FDB visualHints\u3002",
+    "\u5982\u679C\u6CA1\u6709\u628A\u63E1\uFF0C\u4E0D\u8981\u786C\u731C\u5177\u4F53\u8BED\u4E49\uFF0C\u4FDD\u7559 note \u5E76\u964D\u4F4E confidence\u3002",
+    "steps \u5FC5\u987B\u4E0E\u8F93\u5165 specLines \u4E00\u4E00\u5BF9\u5E94\uFF0ClineIndex \u4ECE 0 \u5F00\u59CB\u3002"
+  ].join("\n");
+}
+function interactionAnalysisSchema() {
+  return {
+    type: "object",
+    additionalProperties: false,
+    required: ["blocks"],
+    properties: {
+      blocks: {
+        type: "array",
+        items: {
+          type: "object",
+          additionalProperties: false,
+          required: [
+            "blockId",
+            "blockType",
+            "relation",
+            "summary",
+            "confidence",
+            "steps",
+            "visualHints",
+            "notes"
+          ],
+          properties: {
+            blockId: { type: "string" },
+            blockType: {
+              type: "string",
+              enum: ["interaction", "visual_state", "mixed", "note"]
+            },
+            relation: {
+              type: "string",
+              enum: [
+                "same_component",
+                "modal",
+                "popover",
+                "sidebar",
+                "page",
+                "overlay",
+                "unknown"
+              ]
+            },
+            summary: { type: "string" },
+            confidence: { type: "number" },
+            steps: {
+              type: "array",
+              items: {
+                type: "object",
+                additionalProperties: false,
+                required: ["lineIndex", "role"],
+                properties: {
+                  lineIndex: { type: "integer" },
+                  role: {
+                    type: "string",
+                    enum: interactionRoleEnum
+                  },
+                  detail: { type: ["string", "null"] }
+                }
+              }
+            },
+            visualHints: {
+              type: "array",
+              items: {
+                type: "object",
+                additionalProperties: false,
+                required: ["state", "description", "confidence"],
+                properties: {
+                  state: {
+                    type: "string",
+                    enum: visualStateEnum
+                  },
+                  description: { type: "string" },
+                  confidence: { type: "number" }
+                }
+              }
+            },
+            notes: {
+              type: "array",
+              items: { type: "string" }
+            }
+          }
+        }
+      }
+    }
+  };
+}
+function extractAnthropicText(data) {
+  if (typeof data?.content === "string" && data.content.trim()) {
+    return data.content;
+  }
+  if (!Array.isArray(data?.content)) return void 0;
+  const chunks = [];
+  for (const item of data.content) {
+    if (typeof item?.text === "string" && item.text.trim()) {
+      chunks.push(item.text);
+    }
+  }
+  return chunks.length > 0 ? chunks.join("") : void 0;
+}
+function extractJsonText(text) {
+  const trimmed = text.trim();
+  if (!trimmed) throw new Error("\u6A21\u578B\u54CD\u5E94\u4E3A\u7A7A");
+  if (trimmed.startsWith("```")) {
+    const withoutFence = trimmed.replace(/^```(?:json)?\s*/i, "").replace(/\s*```$/, "");
+    if (withoutFence.trim()) return withoutFence.trim();
+  }
+  if (trimmed.startsWith("{") || trimmed.startsWith("[")) {
+    return trimmed;
+  }
+  const firstObject = trimmed.indexOf("{");
+  const lastObject = trimmed.lastIndexOf("}");
+  if (firstObject >= 0 && lastObject > firstObject) {
+    return trimmed.slice(firstObject, lastObject + 1);
+  }
+  const firstArray = trimmed.indexOf("[");
+  const lastArray = trimmed.lastIndexOf("]");
+  if (firstArray >= 0 && lastArray > firstArray) {
+    return trimmed.slice(firstArray, lastArray + 1);
+  }
+  return trimmed;
+}
+function parseAnalysisResponse(text) {
+  return JSON.parse(extractJsonText(text));
+}
+function normalizeAnalysis(raw, fallback, block, model, provider) {
+  const rawSteps = Array.isArray(raw.steps) ? raw.steps : [];
+  const steps = block.specLines.map((line, index) => {
+    const matched = rawSteps.find((step) => step.lineIndex === index);
+    if (matched) {
+      return {
+        type: matched.role,
+        text: line,
+        detail: matched.detail ?? void 0
+      };
+    }
+    return fallback.steps[index] ?? {
+      type: "note",
+      text: line
+    };
+  });
+  const visualHints = Array.isArray(raw.visualHints) ? raw.visualHints.map((hint) => ({
+    state: hint.state,
+    description: hint.description,
+    confidence: Number(hint.confidence)
+  })).filter((hint) => hint.description.trim().length > 0) : [];
+  return {
+    ...fallback,
+    provider,
+    model,
+    blockType: raw.blockType,
+    relation: raw.relation,
+    summary: raw.summary,
+    confidence: Number(raw.confidence),
+    steps,
+    visualHints,
+    notes: Array.isArray(raw.notes) ? raw.notes.filter((note) => note.trim().length > 0) : []
+  };
+}
+function inferVisualHintsFromText(lines) {
+  const hints = [];
+  const text = lines.join(" ").toLowerCase();
+  const add = (state, description, confidence) => {
+    hints.push({ state, description, confidence });
+  };
+  if (text.includes("hover")) add("hover", "\u6587\u672C\u63CF\u8FF0\u5305\u542B hover \u6001", 0.55);
+  if (text.includes("selected") || text.includes("\u9009\u4E2D")) add("selected", "\u6587\u672C\u63CF\u8FF0\u5305\u542B\u9009\u4E2D\u6001", 0.55);
+  if (text.includes("disabled") || text.includes("\u7981\u7528")) add("disabled", "\u6587\u672C\u63CF\u8FF0\u5305\u542B\u7981\u7528\u6001", 0.55);
+  if (text.includes("loading") || text.includes("\u52A0\u8F7D")) add("loading", "\u6587\u672C\u63CF\u8FF0\u5305\u542B\u52A0\u8F7D\u6001", 0.55);
+  if (text.includes("empty") || text.includes("\u7A7A\u6001")) add("empty", "\u6587\u672C\u63CF\u8FF0\u5305\u542B\u7A7A\u6001", 0.55);
+  if (text.includes("error") || text.includes("\u9519\u8BEF")) add("error", "\u6587\u672C\u63CF\u8FF0\u5305\u542B\u9519\u8BEF\u6001", 0.55);
+  if (text.includes("\u6253\u5F00") || text.includes("open")) add("open", "\u6587\u672C\u63CF\u8FF0\u5305\u542B\u6253\u5F00\u52A8\u4F5C", 0.5);
+  if (text.includes("\u5173\u95ED") || text.includes("close")) add("closed", "\u6587\u672C\u63CF\u8FF0\u5305\u542B\u5173\u95ED\u52A8\u4F5C", 0.5);
+  return hints;
+}
+function buildFallbackAnalysis(block) {
+  const rules = getCompiledRules();
+  const steps = block.specLines.map((line) => {
+    if (rules.interactionTriggerRegex.test(line)) {
+      return { type: "trigger", text: line };
+    }
+    if (rules.interactionConditionRegex.test(line)) {
+      return { type: "condition", text: line };
+    }
+    if (rules.interactionActionRegex.test(line)) {
+      return { type: "action", text: line };
+    }
+    return { type: "note", text: line };
+  });
+  const visualHints = inferVisualHintsFromText(block.specLines);
+  const text = block.specLines.join(" ");
+  const hasVisualKeywords = visualHints.length > 0;
+  const blockType = steps.some((step) => step.type !== "note") && hasVisualKeywords ? "mixed" : steps.some((step) => step.type !== "note") ? "interaction" : hasVisualKeywords ? "visual_state" : "note";
+  return {
+    provider: "fallback",
+    model: void 0,
+    blockType,
+    relation: "unknown",
+    summary: block.specLines[0] ?? `\u4EA4\u4E92\u6807\u8BB0 ${block.anchor.number ?? ""}`.trim(),
+    confidence: block.specLines.length > 0 ? 0.5 : 0.3,
+    steps,
+    visualHints,
+    notes: text ? [text] : []
+  };
+}
+async function requestAnthropicChunk(blocks, config, fetchImpl) {
+  const payload = buildUserPayload(blocks);
+  const apiRoot = config.baseUrl.replace(/\/$/, "").replace(/\/v1$/, "");
+  const response = await fetchImpl(`${apiRoot}/v1/messages`, {
+    method: "POST",
+    headers: {
+      "x-api-key": config.apiKey,
+      "anthropic-version": "2023-06-01",
+      "content-type": "application/json"
+    },
+    body: JSON.stringify({
+      model: config.model,
+      system: buildJsonInstruction(),
+      messages: [
+        {
+          role: "user",
+          content: payload
+        }
+      ],
+      max_tokens: 2e3,
+      temperature: 0
+    }),
+    signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS)
+  });
+  if (!response.ok) {
+    const detail = await response.text().catch(() => "");
+    throw new Error(
+      `Anthropic Messages API \u8BF7\u6C42\u5931\u8D25: HTTP ${response.status} ${response.statusText}${detail ? ` - ${detail}` : ""}`
+    );
+  }
+  const data = await response.json();
+  const text = extractAnthropicText(data);
+  if (!text) {
+    throw new Error("Anthropic \u54CD\u5E94\u4E2D\u672A\u627E\u5230\u53EF\u89E3\u6790\u6587\u672C");
+  }
+  return parseAnalysisChunk(blocks, text, config, "anthropic");
+}
+function buildJsonInstruction() {
+  return [
+    buildSystemPrompt(),
+    "\u53EA\u8F93\u51FA\u5408\u6CD5 JSON\uFF0C\u4E0D\u8981\u8F93\u51FA markdown\u3001\u89E3\u91CA\u3001\u524D\u540E\u7F00\u6587\u5B57\u6216\u4EE3\u7801\u5757\u3002",
+    "JSON \u5FC5\u987B\u7B26\u5408\u4EE5\u4E0B schema\uFF1A",
+    JSON.stringify(interactionAnalysisSchema(), null, 2)
+  ].join("\n\n");
+}
+function parseAnalysisChunk(blocks, text, config, provider) {
+  const parsed = parseAnalysisResponse(text);
+  const out = /* @__PURE__ */ new Map();
+  for (const block of blocks) {
+    const raw = parsed.blocks.find((item) => item.blockId === block.blockId);
+    if (!raw) {
+      out.set(block.blockId, buildFallbackAnalysis(block));
+      continue;
+    }
+    const fallback = buildFallbackAnalysis(block);
+    out.set(block.blockId, normalizeAnalysis(raw, fallback, block, config.model, provider));
+  }
+  return out;
+}
+async function analyzeInteractionBlocks(blocks, fetchImpl = fetch) {
+  const config = resolveConfig();
+  if (!config.enabled || blocks.length === 0) {
+    const analyses2 = /* @__PURE__ */ new Map();
+    for (const block of blocks) analyses2.set(block.blockId, buildFallbackAnalysis(block));
+    return {
+      analyses: analyses2,
+      provider: "fallback",
+      model: void 0
+    };
+  }
+  const analyses = /* @__PURE__ */ new Map();
+  let provider = "fallback";
+  for (let i = 0; i < blocks.length; i += MAX_BLOCKS_PER_REQUEST) {
+    const chunk = blocks.slice(i, i + MAX_BLOCKS_PER_REQUEST);
+    const pending = [];
+    for (const block of chunk) {
+      const cacheKey = stableHash({ provider: config.provider, baseUrl: config.baseUrl, model: config.model, block });
+      const cached = analysisCache.get(cacheKey);
+      if (cached) {
+        analyses.set(block.blockId, cached);
+        provider = cached.provider !== "fallback" ? cached.provider : provider;
+      } else {
+        pending.push(block);
+      }
+    }
+    if (pending.length > 0) {
+      try {
+        const responseMap = await requestAnthropicChunk(pending, config, fetchImpl);
+        if (responseMap) {
+          provider = config.provider;
+          for (const [blockId, analysis] of responseMap.entries()) {
+            const block = pending.find((item) => item.blockId === blockId);
+            if (block) {
+              analysisCache.set(
+                stableHash({ provider: config.provider, baseUrl: config.baseUrl, model: config.model, block }),
+                analysis
+              );
+            }
+            analyses.set(blockId, analysis);
+          }
+          continue;
+        }
+      } catch (error) {
+        console.error(
+          `[sketch-mcp] AI interaction analysis failed for ${pending.map((b) => b.blockId).join(", ")}:`,
+          error instanceof Error ? error.message : String(error)
+        );
+      }
+    }
+    for (const block of pending) {
+      const fallback = buildFallbackAnalysis(block);
+      analyses.set(block.blockId, fallback);
+      analysisCache.set(
+        stableHash({ provider: config.provider, baseUrl: config.baseUrl, model: config.model, block }),
+        fallback
+      );
+    }
+  }
+  return {
+    analyses,
+    provider,
+    model: provider === "fallback" ? void 0 : config.model
+  };
+}
+function summarizeNodeForAi(node) {
+  return summarizeNode(node);
+}
+
+// src/v3/interactions.ts
+function normalizeSpecText(text) {
+  return text.replace(/\s+/g, "").replace(/[，。；、！？!?:：]/g, "").toLowerCase();
+}
+function splitSpecLines(layers, yMin, yMax, designWidth, specFontIncludes) {
+  const lines = [];
+  for (const l of layers) {
+    if (l.type !== "text") continue;
+    const content = (l.content ?? "").trim();
+    if (!content) continue;
+    const r = rect(l);
+    if (!inRegion(r, yMin, yMax)) continue;
+    const ff = l.fontFace ?? "";
+    const isSpecLayer = includesAny(ff, specFontIncludes) || isMarginSpecText(l, designWidth);
+    if (!isSpecLayer) continue;
+    if ((l.fontSize ?? 0) > 32) continue;
+    const lineHeight = l.lineHeight ?? Math.round((l.fontSize ?? 14) * 1.45);
+    const parts = content.split("\n").map((x) => x.trim()).filter(Boolean);
+    parts.forEach((text, i) => {
+      lines.push({
+        text,
+        x: r.x,
+        y: r.y + i * lineHeight
+      });
+    });
+  }
+  lines.sort((a, b) => a.y - b.y || a.x - b.x);
+  const deduped = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const line of lines) {
+    const key = `${Math.round(line.x)}|${Math.round(line.y)}|${normalizeSpecText(line.text)}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    deduped.push(line);
+  }
+  return deduped;
+}
+function clusterSpecBlocks(lines) {
+  if (lines.length === 0) return [];
+  const blocks = [];
+  let current = {
+    id: "sb1",
+    x: lines[0].x,
+    y: lines[0].y,
+    lines: [lines[0]]
+  };
+  for (let i = 1; i < lines.length; i++) {
+    const prev = lines[i - 1];
+    const now = lines[i];
+    const sameColumn = Math.abs(now.x - current.x) <= 64;
+    const contiguousY = now.y - prev.y <= 62;
+    if (sameColumn && contiguousY) {
+      current.lines.push(now);
+    } else {
+      blocks.push(current);
+      current = {
+        id: `sb${blocks.length + 2}`,
+        x: now.x,
+        y: now.y,
+        lines: [now]
+      };
+    }
+  }
+  blocks.push(current);
+  return blocks;
+}
+function nearestSectionIdFromY(sections, y) {
+  if (sections.length === 0) return void 0;
+  let best = null;
+  for (const section of sections) {
+    const cy = section.bounds.y + section.bounds.height / 2;
+    const score = Math.abs(cy - y);
+    if (!best || score < best.score) best = { id: section.id, score };
+  }
+  return best?.id;
+}
+function extractAnchorNumber(anchor, textLayers) {
+  const ar = rect(anchor);
+  const acx = ar.x + ar.width / 2;
+  const acy = ar.y + ar.height / 2;
+  for (const t of textLayers) {
+    if (t.type !== "text") continue;
+    const content = (t.content ?? "").trim();
+    if (!/^\d{1,2}$/.test(content)) continue;
+    const tr = rect(t);
+    const tcx = tr.x + tr.width / 2;
+    const tcy = tr.y + tr.height / 2;
+    if (Math.abs(tcx - acx) <= ar.width && Math.abs(tcy - acy) <= ar.height) {
+      return content;
+    }
+  }
+  return void 0;
+}
+function nearestTargetNode(anchorRect, nodes, designWidth) {
+  const acx = anchorRect.x + anchorRect.width / 2;
+  const acy = anchorRect.y + anchorRect.height / 2;
+  let best = null;
+  for (const node of nodes) {
+    if (node.id === "root") continue;
+    if (node.kind === "text") continue;
+    if (node.rect.x + node.rect.width > designWidth + 2) continue;
+    if (node.rect.width < 16 && node.rect.height < 16) continue;
+    if (area(node.rect) < 300) continue;
+    const ncx = node.rect.x + node.rect.width / 2;
+    const ncy = node.rect.y + node.rect.height / 2;
+    const dist = Math.sqrt((ncx - acx) ** 2 + (ncy - acy) ** 2);
+    if (dist > 640) continue;
+    const sizePenalty = Math.max(0, Math.log10(Math.max(1, area(node.rect))) - 4) * 20;
+    const score = dist + sizePenalty;
+    if (!best || score < best.score) best = { node, score };
+  }
+  return best?.node;
+}
+function nearestSceneNodes(anchorRect, nodes, limit = 8) {
+  const acx = anchorRect.x + anchorRect.width / 2;
+  const acy = anchorRect.y + anchorRect.height / 2;
+  return nodes.filter((node) => node.id !== "root" && area(node.rect) >= 80).sort((a, b) => {
+    const adx = a.rect.x + a.rect.width / 2 - acx;
+    const ady = a.rect.y + a.rect.height / 2 - acy;
+    const bdx = b.rect.x + b.rect.width / 2 - acx;
+    const bdy = b.rect.y + b.rect.height / 2 - acy;
+    const ad = Math.sqrt(adx * adx + ady * ady);
+    const bd = Math.sqrt(bdx * bdx + bdy * bdy);
+    return ad - bd;
+  }).slice(0, limit);
+}
+function buildBlockInputs(scene, anchors, blocks, textLayers) {
+  const usedBlockIds = /* @__PURE__ */ new Set();
+  const edges = [];
+  const inputs = [];
+  for (let i = 0; i < anchors.length; i++) {
+    const anchor = anchors[i];
+    const ar = rect(anchor);
+    const num = extractAnchorNumber(anchor, textLayers);
+    const analysisId = `ia-${i + 1}`;
+    let bestBlock;
+    let bestScore = Number.POSITIVE_INFINITY;
+    for (const block of blocks) {
+      const dx = block.x >= ar.x ? (block.x - ar.x) * 0.2 : 600 + (ar.x - block.x);
+      const dy = Math.abs(block.y - ar.y);
+      const score = dx + dy;
+      if (score < bestScore) {
+        bestScore = score;
+        bestBlock = block;
+      }
+    }
+    const target = nearestTargetNode(ar, scene.nodes, scene.designWidth);
+    if (bestBlock) usedBlockIds.add(bestBlock.id);
+    const rawLines = bestBlock ? bestBlock.lines.map((l) => l.text) : [];
+    const uniqLines = [];
+    const seen = /* @__PURE__ */ new Set();
+    for (const line of rawLines) {
+      const key = normalizeSpecText(line);
+      if (seen.has(key)) continue;
+      seen.add(key);
+      uniqLines.push(line);
+    }
+    const targetCenterY = target ? target.rect.y + target.rect.height / 2 : ar.y + ar.height / 2;
+    const sectionId = nearestSectionIdFromY(scene.sections, targetCenterY);
+    const section = sectionId ? scene.sections.find((item) => item.id === sectionId) : void 0;
+    const nearbyNodes = nearestSceneNodes(ar, scene.nodes).filter((node) => node.id !== target?.id).map((node) => summarizeNodeForAi(node));
+    if (target) {
+      nearbyNodes.unshift(summarizeNodeForAi(target));
+    }
+    inputs.push({
+      blockId: analysisId,
+      anchor: {
+        x: ar.x,
+        y: ar.y,
+        number: num
+      },
+      target: target ? {
+        id: target.id,
+        name: target.name,
+        kind: target.kind,
+        text: target.text,
+        rect: target.rect
+      } : void 0,
+      section: section ? {
+        id: section.id,
+        name: section.name,
+        bounds: section.bounds
+      } : void 0,
+      specLines: uniqLines,
+      nearbyNodes
+    });
+    edges.push({
+      analysisId,
+      specBlockId: bestBlock?.id,
+      anchorRect: ar,
+      target,
+      sectionId,
+      sectionName: section?.name,
+      specLines: uniqLines
+    });
+  }
+  return { inputs, usedBlockIds, edges };
+}
+async function buildInteractionGraph(artboard, options) {
+  const rules = getCompiledRules();
+  const scene = buildSceneGraph(artboard, {
+    pageY: options?.pageY,
+    pageHeight: options?.pageHeight,
+    maxNodes: DEFAULT_MAX_NODES
+  });
+  const yMin = scene.region.yMin;
+  const yMax = scene.region.yMax;
+  const designWidth = scene.designWidth;
+  const textLayers = artboard.layers.filter((l) => l.type === "text");
+  const anchors = artboard.layers.filter((l) => {
+    if (l.type !== "symbol") return false;
+    const name = l.name ?? "";
+    if (!startsWithAny(name, rules.raw.anchorNamePrefixes)) return false;
+    return inRegion(rect(l), yMin, yMax);
+  }).sort((a, b) => rect(a).y - rect(b).y || rect(a).x - rect(b).x);
+  const specLines = splitSpecLines(
+    artboard.layers,
+    yMin,
+    yMax,
+    designWidth,
+    rules.raw.specFontIncludes
+  );
+  const blocks = clusterSpecBlocks(specLines);
+  const { inputs, usedBlockIds, edges } = buildBlockInputs(
+    scene,
+    anchors,
+    blocks,
+    textLayers
+  );
+  const aiResult = await analyzeInteractionBlocks(inputs);
+  const interactions = edges.map((edge, index) => {
+    const analysis = aiResult.analyses.get(edge.analysisId) ?? {
+      provider: "fallback",
+      model: void 0,
+      blockType: "note",
+      relation: "unknown",
+      summary: edge.specLines[0] ?? `\u4EA4\u4E92\u6807\u8BB0 ${index + 1}`,
+      confidence: 0.3,
+      steps: edge.specLines.map((line) => ({ type: "note", text: line })),
+      visualHints: [],
+      notes: []
+    };
+    return {
+      id: `ia-${index + 1}`,
+      anchor: {
+        x: edge.anchorRect.x,
+        y: edge.anchorRect.y,
+        number: inputs[index]?.anchor.number
+      },
+      targetNodeId: edge.target?.id,
+      targetName: edge.target?.name || edge.target?.text,
+      targetBounds: edge.target?.rect,
+      summary: analysis.summary,
+      confidence: Number(analysis.confidence.toFixed(2)),
+      steps: analysis.steps,
+      specLines: edge.specLines,
+      blockType: analysis.blockType,
+      relation: analysis.relation,
+      analysisProvider: analysis.provider,
+      analysisModel: analysis.model,
+      visualHints: analysis.visualHints,
+      notes: analysis.notes
+    };
+  });
+  const unboundSpecLines = blocks.filter((b) => !usedBlockIds.has(b.id)).flatMap((b) => b.lines.map((l) => l.text));
+  return {
+    artboard: artboard.name,
+    region: { yMin, yMax },
+    analysisProvider: aiResult.provider,
+    analysisModel: aiResult.model,
+    interactions,
+    unboundSpecLines
+  };
+}
+
+// src/v3/blueprint.ts
+function topN(map, n) {
+  const result = {};
+  const sorted = [...map.entries()].sort((a, b) => b[1] - a[1]).slice(0, n);
+  for (const [key, value] of sorted) result[key] = value;
+  return result;
+}
+function collectTokens(layers, yMin, yMax, designWidth) {
+  const textColors = /* @__PURE__ */ new Map();
+  const bgColors = /* @__PURE__ */ new Map();
+  const fontSizes = /* @__PURE__ */ new Map();
+  const fontFamilies = /* @__PURE__ */ new Map();
+  const radii = /* @__PURE__ */ new Map();
+  for (const l of layers) {
+    if (isNoise(l) || isAnnotation(l)) continue;
+    if (isMarginSpecText(l, designWidth)) continue;
+    const r = rect(l);
+    if (!inRegion(r, yMin, yMax)) continue;
+    if (l.type === "text") {
+      const c = colorHex(l.color);
+      if (c) textColors.set(c, (textColors.get(c) ?? 0) + 1);
+      if (l.fontSize) {
+        const key = String(l.fontSize);
+        fontSizes.set(key, (fontSizes.get(key) ?? 0) + 1);
+      }
+      const family = (l.fontFace ?? l.fontFamily ?? "").trim();
+      if (family) fontFamilies.set(family, (fontFamilies.get(family) ?? 0) + 1);
+    }
+    const bg = bgColor(l);
+    if (bg) bgColors.set(bg, (bgColors.get(bg) ?? 0) + 1);
+    const rad = radius(l);
+    if (rad > 0) radii.set(String(rad), (radii.get(String(rad)) ?? 0) + 1);
+  }
+  return {
+    textColors: topN(textColors, 24),
+    bgColors: topN(bgColors, 20),
+    fontSizes: topN(fontSizes, 12),
+    fontFamilies: topN(fontFamilies, 12),
+    radii: topN(radii, 10)
+  };
+}
+async function buildBlueprint(artboard, options) {
+  const scene = buildSceneGraph(artboard, options);
+  const maxComponents = options?.maxComponents ?? DEFAULT_MAX_COMPONENTS;
+  const components = extractComponentCandidates(scene.nodes, scene.sections).slice(
+    0,
+    maxComponents
+  );
+  const interactionGraph = await buildInteractionGraph(artboard, {
+    pageY: options?.pageY,
+    pageHeight: options?.pageHeight
+  });
+  const interactions = interactionGraph.interactions;
+  const visualHintSeen = /* @__PURE__ */ new Set();
+  const visualHints = interactions.flatMap(
+    (interaction) => interaction.visualHints.map((hint) => ({
+      ...hint,
+      description: `${interaction.targetName ?? interaction.summary}: ${hint.description}`
+    })).filter((hint) => {
+      const key = `${hint.state}|${hint.description}`;
+      if (visualHintSeen.has(key)) return false;
+      visualHintSeen.add(key);
+      return true;
+    })
+  );
+  const tokens = collectTokens(
+    artboard.layers,
+    scene.region.yMin,
+    scene.region.yMax,
+    scene.designWidth
+  );
+  return {
+    meta: {
+      artboard: artboard.name,
+      width: artboard.width,
+      height: artboard.height,
+      designWidth: scene.designWidth,
+      region: scene.region
+    },
+    layout: {
+      sections: scene.sections
+    },
+    tokens,
+    components,
+    visualHints,
+    interactions,
+    implementationHints: {
+      recommendedStack: "React + Ant Design",
+      codingChecklist: [
+        "\u5148\u6309 sections \u642D\u5EFA\u9875\u9762\u9AA8\u67B6\uFF0C\u518D\u653E\u7F6E\u9AD8\u7F6E\u4FE1\u5EA6\u7EC4\u4EF6\u3002",
+        "\u6240\u6709\u989C\u8272/\u5B57\u53F7/\u5706\u89D2\u4F18\u5148\u4F7F\u7528 tokens\uFF0C\u907F\u514D\u786C\u7F16\u7801\u6563\u843D\u6837\u5F0F\u3002",
+        "\u5148\u5B8C\u6210\u9ED8\u8BA4\u6001\uFF0C\u518D\u8865\u9F50 hover/active/disabled/empty/loading\u3002",
+        "\u4EA4\u4E92\u5B9E\u73B0\u4EE5 AI \u7406\u89E3\u540E\u7684 interactions.steps \u4E0E visualHints \u4E3A\u51C6\uFF0C\u5148\u8FD8\u539F\u72B6\u6001\u89C6\u89C9\u518D\u6302\u4E8B\u4EF6\u3002",
+        "\u5B9E\u73B0\u540E\u8FDB\u884C\u622A\u56FE diff\uFF0C\u9010\u8F6E\u4FEE\u590D\u95F4\u8DDD\u3001\u5B57\u53F7\u3001\u989C\u8272\u504F\u5DEE\u3002"
+      ],
+      claudePromptSkeleton: "\u57FA\u4E8E blueprint \u751F\u6210 React + Ant Design \u9875\u9762\u3002\u8981\u6C42\uFF1A1) section \u987A\u5E8F\u4E0E bounds \u4E00\u81F4\uFF1B2) \u4F18\u5148\u5B9E\u73B0 confidence>=0.75 \u7684\u7EC4\u4EF6\uFF1B3) \u6309 interactions.steps \u5B9E\u73B0\u4E8B\u4EF6\uFF1B4) \u6309 visualHints \u5B9E\u73B0 hover/active/disabled/empty/loading/open \u7B49\u72B6\u6001\u89C6\u89C9\uFF1B5) \u8F93\u51FA\u5B8C\u6574\u53EF\u8FD0\u884C\u7EC4\u4EF6\u4E0E\u6837\u5F0F\u3002"
+    }
+  };
+}
+
+// src/v3/validate.ts
+function normalizeComponentText(v) {
+  if (typeof v !== "string") return "";
+  return v.toLowerCase().replace(/\s+/g, "");
+}
+function matchKey(component) {
+  const kind = String(component?.kind ?? component?.type ?? "unknown").toLowerCase();
+  const text = normalizeComponentText(component?.text ?? component?.content ?? "");
+  return `${kind}:${text}`;
+}
+function metricFromDelta(delta, tolerance) {
+  if (delta <= 0) return 1;
+  if (delta >= tolerance) return 0;
+  return Number((1 - delta / tolerance).toFixed(4));
+}
+function validateImplementation(expectedInput, actualInput) {
+  const expected = expectedInput ?? {};
+  const actual = actualInput ?? {};
+  const expectedComponents = expected.components ?? expected.blueprint?.components ?? [];
+  const actualComponents = actual.components ?? actual.blueprint?.components ?? [];
+  const actualByKey = /* @__PURE__ */ new Map();
+  for (const comp of actualComponents) {
+    const key = matchKey(comp);
+    const arr = actualByKey.get(key) ?? [];
+    arr.push(comp);
+    actualByKey.set(key, arr);
+  }
+  let layoutAcc = 0;
+  let styleAcc = 0;
+  let matched = 0;
+  const findings = [];
+  for (const exp of expectedComponents) {
+    const key = matchKey(exp);
+    const candidates = actualByKey.get(key) ?? [];
+    let best = candidates[0];
+    if (!best && candidates.length === 0) {
+      const kind = String(exp?.kind ?? exp?.type ?? "").toLowerCase();
+      best = actualComponents.find(
+        (a) => String(a?.kind ?? a?.type ?? "").toLowerCase() === kind
+      );
+    }
+    if (!best) {
+      findings.push({
+        severity: "high",
+        title: `\u7F3A\u5C11\u7EC4\u4EF6: ${exp?.kind ?? exp?.type ?? "unknown"}`,
+        detail: `\u672A\u5728\u5B9E\u73B0\u4E2D\u627E\u5230\u4E0E\u300C${exp?.text ?? exp?.content ?? "\u65E0\u6587\u672C"}\u300D\u5339\u914D\u7684\u7EC4\u4EF6\u3002`
+      });
+      continue;
+    }
+    matched++;
+    const eb = exp.bounds ?? exp.rect;
+    const ab = best.bounds ?? best.rect;
+    if (eb && ab) {
+      const dx = Math.abs((ab.x ?? 0) - (eb.x ?? 0));
+      const dy = Math.abs((ab.y ?? 0) - (eb.y ?? 0));
+      const dw = Math.abs((ab.width ?? 0) - (eb.width ?? 0));
+      const dh = Math.abs((ab.height ?? 0) - (eb.height ?? 0));
+      const score = metricFromDelta(dx, 36) * 0.3 + metricFromDelta(dy, 36) * 0.3 + metricFromDelta(dw, 42) * 0.2 + metricFromDelta(dh, 42) * 0.2;
+      layoutAcc += score;
+      if (score < 0.58) {
+        findings.push({
+          severity: "medium",
+          title: `\u5E03\u5C40\u504F\u5DEE: ${exp?.kind ?? exp?.type ?? "component"}`,
+          detail: `\u4F4D\u7F6E/\u5C3A\u5BF8\u504F\u5DEE\u8F83\u5927 (dx=${dx}, dy=${dy}, dw=${dw}, dh=${dh})\u3002`
+        });
+      }
+    } else {
+      layoutAcc += 0.45;
+    }
+    const expColor = exp?.style?.bg ?? exp?.style?.textColor ?? "";
+    const actColor = best?.style?.bg ?? best?.style?.textColor ?? "";
+    const expFont = exp?.style?.fontSize ?? 0;
+    const actFont = best?.style?.fontSize ?? 0;
+    const colorScore = expColor && actColor ? expColor === actColor ? 1 : 0.4 : 0.6;
+    const fontScore = expFont && actFont ? metricFromDelta(Math.abs(expFont - actFont), 4) : 0.6;
+    styleAcc += colorScore * 0.6 + fontScore * 0.4;
+  }
+  const totalExpected = Math.max(1, expectedComponents.length);
+  const layoutScore = Number((layoutAcc / totalExpected * 100).toFixed(1));
+  const styleScore = Number((styleAcc / totalExpected * 100).toFixed(1));
+  const expectedInteractions = expected.interactions ?? expected.blueprint?.interactions ?? [];
+  const actualInteractions = actual.interactions ?? actual.blueprint?.interactions ?? [];
+  let interactionScore = 0;
+  if (expectedInteractions.length === 0) {
+    interactionScore = actualInteractions.length > 0 ? 80 : 60;
+  } else {
+    const coverage = Math.min(1, actualInteractions.length / expectedInteractions.length);
+    interactionScore = Number((coverage * 100).toFixed(1));
+    if (coverage < 0.75) {
+      findings.push({
+        severity: "medium",
+        title: "\u4EA4\u4E92\u8986\u76D6\u4E0D\u8DB3",
+        detail: `\u671F\u671B\u4EA4\u4E92 ${expectedInteractions.length} \u6761\uFF0C\u5F53\u524D\u5B9E\u73B0\u4EC5\u8BC6\u522B\u5230 ${actualInteractions.length} \u6761\u3002`
+      });
+    }
+  }
+  const overallScore = Number(
+    (layoutScore * 0.5 + styleScore * 0.3 + interactionScore * 0.2).toFixed(1)
+  );
+  if (matched / totalExpected < 0.8) {
+    findings.push({
+      severity: "high",
+      title: "\u6838\u5FC3\u7EC4\u4EF6\u7F3A\u5931\u8F83\u591A",
+      detail: `\u53EA\u5339\u914D\u5230 ${matched}/${totalExpected} \u4E2A\u671F\u671B\u7EC4\u4EF6\uFF0C\u5EFA\u8BAE\u5148\u8865\u9F50\u7ED3\u6784\u518D\u8C03\u6837\u5F0F\u3002`
+    });
+  }
+  return {
+    overallScore,
+    layoutScore,
+    styleScore,
+    interactionScore,
+    matchedComponents: matched,
+    totalExpectedComponents: totalExpected,
+    findings,
+    nextPrompt: "\u8BF7\u57FA\u4E8E findings \u4F18\u5148\u4FEE\u590D high \u4E25\u91CD\u5EA6\u95EE\u9898\uFF0C\u7136\u540E\u6309 layout->style->interaction \u987A\u5E8F\u8FED\u4EE3\uFF1B\u6BCF\u6B21\u6539\u52A8\u540E\u91CD\u65B0\u622A\u56FE\u5E76\u518D\u6B21\u8C03\u7528 validate_implementation\u3002"
+  };
+}
+
+// src/engine/output.ts
+var MAX_TEXT_RESPONSE = 2e5;
+function isRecord(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function attachRuntimeMeta(value, toolName) {
+  const runtime = getRuleRuntimeMeta();
+  const meta = {
+    tool: toolName,
+    ruleProfile: runtime.profile,
+    ruleConfidence: runtime.confidence,
+    ruleSource: runtime.source
+  };
+  if (Array.isArray(value)) {
+    return {
+      meta,
+      items: value
+    };
+  }
+  if (isRecord(value)) {
+    const existingMeta = isRecord(value.meta) ? value.meta : {};
+    const { meta: _discard, ...rest } = value;
+    return {
+      meta: {
+        ...existingMeta,
+        ...meta
+      },
+      ...rest
+    };
+  }
+  return { meta, value };
+}
+function toJsonOrThrow(value, toolName, hint) {
+  const withMeta = attachRuntimeMeta(value, toolName);
+  const output = JSON.stringify(withMeta, null, 2);
+  if (output.length > MAX_TEXT_RESPONSE) {
+    const advice = hint ?? "\u8BF7\u7F29\u5C0F page_height\uFF0C\u6216\u4F7F\u7528 offset/limit \u5206\u9875\u53C2\u6570\u5206\u6279\u62C9\u53D6\u3002";
+    throw new Error(
+      `${toolName} \u8F93\u51FA\u8FC7\u5927(${output.length} chars > ${MAX_TEXT_RESPONSE})\u3002\u5DF2\u53D6\u6D88\u8FD4\u56DE\uFF0C\u907F\u514D\u9759\u9ED8\u622A\u65AD\u5F71\u54CD\u8FD8\u539F\u5EA6\u3002${advice}`
+    );
+  }
+  return output;
+}
+function resolvePaging(input, defaultLimit, maxLimit = 2e3) {
+  let offset = Math.max(0, Math.floor(input.offset ?? 0));
+  if (input.cursor) {
+    const m = /^offset:(\d+)$/.exec(input.cursor.trim());
+    if (!m) {
+      throw new Error("cursor \u683C\u5F0F\u9519\u8BEF\uFF0C\u671F\u671B\u793A\u4F8B: offset:200");
+    }
+    offset = Number(m[1]);
+  }
+  const rawLimit = input.limit ?? defaultLimit;
+  if (!Number.isFinite(rawLimit) || rawLimit <= 0) {
+    throw new Error("limit \u5FC5\u987B\u662F\u6B63\u6574\u6570");
+  }
+  const limit = Math.min(maxLimit, Math.floor(rawLimit));
+  return { offset, limit };
+}
+function paginateArray(items, paging) {
+  const total = items.length;
+  const start = Math.min(total, paging.offset);
+  const end = Math.min(total, start + paging.limit);
+  const sliced = items.slice(start, end);
+  const hasMore = end < total;
+  return {
+    items: sliced,
+    page: {
+      offset: start,
+      limit: paging.limit,
+      total,
+      hasMore,
+      nextOffset: hasMore ? end : null,
+      nextCursor: hasMore ? `offset:${end}` : null
+    }
+  };
+}
+
+// src/engine/v3-tools.ts
+async function toolGetArtboardManifestPaged(url, offset = 0, limit = 100, cursor) {
+  const wudi = await getWudi(url);
+  const manifest = buildArtboardManifest(wudi.artboards);
+  const paging = resolvePaging({ offset, limit, cursor }, 100, 1e3);
+  const paged = paginateArray(manifest, paging);
+  return toJsonOrThrow(
+    {
+      url,
+      totalArtboards: paged.page.total,
+      recommendedFirst: manifest.filter((x) => x.recommended).map((x) => x.name),
+      pagination: paged.page,
+      artboards: paged.items
+    },
+    "get_artboard_manifest"
+  );
+}
+async function toolGetSceneGraph(url, artboardName, pageY = 0, pageHeight = 4e3, maxNodes = 900, offset = 0, limit = 300, cursor) {
+  const wudi = await getWudi(url);
+  const ab = findArtboard(wudi, artboardName);
+  const scene = buildSceneGraph(ab, { pageY, pageHeight, maxNodes });
+  const root = scene.nodes.find((n) => n.id === "root");
+  const nonRoot = scene.nodes.filter((n) => n.id !== "root");
+  const paging = resolvePaging({ offset, limit, cursor }, 300, 2e3);
+  const paged = paginateArray(nonRoot, paging);
+  return toJsonOrThrow(
+    {
+      ...scene,
+      pagination: {
+        target: "nodes",
+        ...paged.page
+      },
+      nodes: root ? [root, ...paged.items] : paged.items
+    },
+    "get_scene_graph",
+    "\u8BF7\u51CF\u5C0F page_height\uFF0C\u6216\u964D\u4F4E limit \u5E76\u7ED3\u5408 nextCursor \u5206\u9875\u62C9\u53D6\u3002"
+  );
+}
+async function toolGetBlueprint(url, artboardName, pageY = 0, pageHeight = 4e3, maxNodes = 900, maxComponents = 500, offset = 0, limit = 200, cursor, includeInteractions = true) {
+  const wudi = await getWudi(url);
+  const ab = findArtboard(wudi, artboardName);
+  const blueprint = await buildBlueprint(ab, { pageY, pageHeight, maxNodes, maxComponents });
+  const paging = resolvePaging({ offset, limit, cursor }, 200, 2e3);
+  const compPaged = paginateArray(blueprint.components, paging);
+  const result = {
+    ...blueprint,
+    components: compPaged.items,
+    interactions: includeInteractions ? blueprint.interactions : [],
+    pagination: {
+      target: "components",
+      ...compPaged.page,
+      interactionsIncluded: includeInteractions,
+      interactionsTotal: blueprint.interactions.length
+    }
+  };
+  return toJsonOrThrow(
+    result,
+    "get_blueprint",
+    "\u8BF7\u51CF\u5C0F page_height\uFF0C\u6216\u4F7F\u7528 offset/limit \u7FFB\u9875\uFF1B\u4E5F\u53EF\u8BBE\u7F6E include_interactions=false \u518D\u5355\u72EC\u8C03\u7528 get_interaction_graph\u3002"
+  );
+}
+async function toolGetInteractionGraph(url, artboardName, pageY = 0, pageHeight = 5e3, offset = 0, limit = 200, cursor) {
+  const wudi = await getWudi(url);
+  const ab = findArtboard(wudi, artboardName);
+  const graph = await buildInteractionGraph(ab, { pageY, pageHeight });
+  const paging = resolvePaging({ offset, limit, cursor }, 200, 2e3);
+  const paged = paginateArray(graph.interactions, paging);
+  return toJsonOrThrow(
+    {
+      ...graph,
+      interactions: paged.items,
+      pagination: {
+        target: "interactions",
+        ...paged.page
+      }
+    },
+    "get_interaction_graph",
+    "\u8BF7\u51CF\u5C0F page_height\uFF0C\u6216\u4F7F\u7528 offset/limit + nextCursor \u5206\u9875\u62C9\u53D6\u4EA4\u4E92\u3002"
+  );
+}
+async function toolValidateImplementation(expectedJson, actualJson) {
+  let expected = expectedJson;
+  let actual = actualJson;
+  try {
+    expected = JSON.parse(expectedJson);
+  } catch (e) {
+    throw new Error("expected_json \u4E0D\u662F\u5408\u6CD5 JSON");
+  }
+  try {
+    actual = JSON.parse(actualJson);
+  } catch (e) {
+    throw new Error("actual_json \u4E0D\u662F\u5408\u6CD5 JSON");
+  }
+  const result = validateImplementation(expected, actual);
+  return toJsonOrThrow(result, "validate_implementation");
+}
+
+// src/index.ts
+var cliArgs = process.argv.slice(2);
+var toolNames = [
+  "get_artboard_manifest",
+  "get_scene_graph",
+  "get_blueprint",
+  "get_interaction_graph",
+  "validate_implementation"
+];
+var hasHtmlFile = cliArgs.includes("--html-file");
+if (hasHtmlFile || cliArgs.length > 0 && toolNames.includes(cliArgs[0])) {
+  if (hasHtmlFile) {
+    const fileIdx = cliArgs.indexOf("--html-file");
+    const htmlFile = cliArgs[fileIdx + 1];
+    setHtmlOverride(htmlFile);
+    cliArgs.splice(fileIdx, 2);
+  }
+  const tool = cliArgs[0];
+  const toolArgs = cliArgs.slice(1);
+  if (!tool) {
+    console.error("Usage: node dist/index.js [--html-file <path>] <tool> [args...]");
+    console.error(
+      "Tools: get_artboard_manifest, get_scene_graph, get_blueprint, get_interaction_graph, validate_implementation"
+    );
+    process.exit(1);
+  }
+  try {
+    const url = hasHtmlFile ? "file://local" : toolArgs[0] || "file://local";
+    const argsOffset = hasHtmlFile ? 0 : 1;
+    let result;
+    switch (tool) {
+      case "get_artboard_manifest":
+        result = await toolGetArtboardManifestPaged(
+          url,
+          Number(toolArgs[argsOffset]) || 0,
+          Number(toolArgs[argsOffset + 1]) || 100,
+          toolArgs[argsOffset + 2]
+        );
+        break;
+      case "get_scene_graph":
+        result = await toolGetSceneGraph(
+          url,
+          toolArgs[argsOffset],
+          Number(toolArgs[argsOffset + 1]) || 0,
+          Number(toolArgs[argsOffset + 2]) || 4e3,
+          Number(toolArgs[argsOffset + 3]) || 900,
+          Number(toolArgs[argsOffset + 4]) || 0,
+          Number(toolArgs[argsOffset + 5]) || 300,
+          toolArgs[argsOffset + 6]
+        );
+        break;
+      case "get_blueprint":
+        result = await toolGetBlueprint(
+          url,
+          toolArgs[argsOffset],
+          Number(toolArgs[argsOffset + 1]) || 0,
+          Number(toolArgs[argsOffset + 2]) || 4e3,
+          Number(toolArgs[argsOffset + 3]) || 900,
+          Number(toolArgs[argsOffset + 4]) || 500,
+          Number(toolArgs[argsOffset + 5]) || 0,
+          Number(toolArgs[argsOffset + 6]) || 200,
+          toolArgs[argsOffset + 7],
+          toolArgs[argsOffset + 8] !== "false"
+        );
+        break;
+      case "get_interaction_graph":
+        result = await toolGetInteractionGraph(
+          url,
+          toolArgs[argsOffset],
+          Number(toolArgs[argsOffset + 1]) || 0,
+          Number(toolArgs[argsOffset + 2]) || 5e3,
+          Number(toolArgs[argsOffset + 3]) || 0,
+          Number(toolArgs[argsOffset + 4]) || 200,
+          toolArgs[argsOffset + 5]
+        );
+        break;
+      case "validate_implementation":
+        result = await toolValidateImplementation(
+          toolArgs[0] || "{}",
+          toolArgs[1] || "{}"
+        );
+        break;
+      default:
+        console.error("Unknown tool:", tool);
+        process.exit(1);
+    }
+    console.log(result);
+  } catch (e) {
+    console.error("Error:", e.message);
+    process.exit(1);
+  }
+  process.exit(0);
+}
+var pkg = JSON.parse(
+  readFileSync3(new URL("../package.json", import.meta.url), "utf-8")
+);
+var server = new McpServer({
+  name: "sketch-design",
+  version: pkg.version
+});
+server.tool(
+  "get_artboard_manifest",
+  "V3\u63A8\u8350\u5165\u53E3\uFF1A\u8FD4\u56DE\u753B\u677F\u6E05\u5355\u3001\u590D\u6742\u5EA6\u8BC4\u5206\u3001\u63A8\u8350\u4F18\u5148\u5B9E\u73B0\u7684\u9875\u9762\u3002\u652F\u6301 offset/limit/cursor \u5206\u9875\u3002",
+  {
+    url: z.string().describe("\u8BBE\u8BA1\u7A3F\u9875\u9762 URL"),
+    offset: z.number().describe("\u5206\u9875\u8D77\u59CB\u504F\u79FB").default(0),
+    limit: z.number().describe("\u5206\u9875\u5927\u5C0F").default(100),
+    cursor: z.string().optional().describe("\u5206\u9875\u6E38\u6807\uFF0C\u683C\u5F0F\u793A\u4F8B: offset:200")
+  },
+  async ({ url, offset = 0, limit = 100, cursor }) => {
+    const data = await toolGetArtboardManifestPaged(url, offset, limit, cursor);
+    return { content: [{ type: "text", text: data }] };
+  }
+);
+server.tool(
+  "get_scene_graph",
+  "V3\u6838\u5FC3\uFF1A\u8FD4\u56DE\u5C42\u7EA7\u5316 scene graph\uFF08\u7236\u5B50\u7ED3\u6784\u3001\u7EA6\u675F\u3001\u6837\u5F0F\uFF09\uFF0C\u652F\u6301 nodes \u5206\u9875\uFF0C\u907F\u514D\u5927\u7ED3\u679C\u622A\u65AD\u3002",
+  {
+    url: z.string().describe("\u8BBE\u8BA1\u7A3F\u9875\u9762 URL"),
+    artboard: z.string().describe("\u753B\u677F\u540D\u79F0"),
+    page_y: z.number().describe("Y \u8D77\u59CB\u5750\u6807").default(0),
+    page_height: z.number().describe("Y \u8303\u56F4\u9AD8\u5EA6").default(4e3),
+    max_nodes: z.number().describe("\u6700\u5927\u8FD4\u56DE\u8282\u70B9\u6570").default(900),
+    offset: z.number().describe("nodes \u5206\u9875\u8D77\u59CB\u504F\u79FB").default(0),
+    limit: z.number().describe("nodes \u5206\u9875\u5927\u5C0F").default(300),
+    cursor: z.string().optional().describe("\u5206\u9875\u6E38\u6807\uFF0C\u683C\u5F0F\u793A\u4F8B: offset:300")
+  },
+  async ({
+    url,
+    artboard,
+    page_y = 0,
+    page_height = 4e3,
+    max_nodes = 900,
+    offset = 0,
+    limit = 300,
+    cursor
+  }) => {
+    const data = await toolGetSceneGraph(
+      url,
+      artboard,
+      page_y,
+      page_height,
+      max_nodes,
+      offset,
+      limit,
+      cursor
+    );
+    return { content: [{ type: "text", text: data }] };
+  }
+);
+server.tool(
+  "get_blueprint",
+  "V3\u63A8\u8350\uFF1A\u8FD4\u56DE\u53EF\u76F4\u63A5\u7F16\u7801\u7684\u5B9E\u73B0\u5951\u7EA6\uFF08layout/tokens/components/interactions/hints\uFF09\uFF0C\u652F\u6301 components \u5206\u9875\u3002",
+  {
+    url: z.string().describe("\u8BBE\u8BA1\u7A3F\u9875\u9762 URL"),
+    artboard: z.string().describe("\u753B\u677F\u540D\u79F0"),
+    page_y: z.number().describe("Y \u8D77\u59CB\u5750\u6807").default(0),
+    page_height: z.number().describe("Y \u8303\u56F4\u9AD8\u5EA6").default(4e3),
+    max_nodes: z.number().describe("\u6700\u5927\u8282\u70B9\u6570").default(900),
+    max_components: z.number().describe("\u6700\u5927\u7EC4\u4EF6\u5019\u9009\u6570").default(500),
+    offset: z.number().describe("components \u5206\u9875\u8D77\u59CB\u504F\u79FB").default(0),
+    limit: z.number().describe("components \u5206\u9875\u5927\u5C0F").default(200),
+    cursor: z.string().optional().describe("\u5206\u9875\u6E38\u6807\uFF0C\u683C\u5F0F\u793A\u4F8B: offset:200"),
+    include_interactions: z.boolean().describe("\u662F\u5426\u5728 blueprint \u4E2D\u5305\u542B interactions\uFF08false \u65F6\u53EF\u5355\u72EC\u8C03 get_interaction_graph\uFF09").default(true)
+  },
+  async ({
+    url,
+    artboard,
+    page_y = 0,
+    page_height = 4e3,
+    max_nodes = 900,
+    max_components = 500,
+    offset = 0,
+    limit = 200,
+    cursor,
+    include_interactions = true
+  }) => {
+    const data = await toolGetBlueprint(
+      url,
+      artboard,
+      page_y,
+      page_height,
+      max_nodes,
+      max_components,
+      offset,
+      limit,
+      cursor,
+      include_interactions
+    );
+    return { content: [{ type: "text", text: data }] };
+  }
+);
+server.tool(
+  "get_interaction_graph",
+  "V3\u63A8\u8350\uFF1A\u7ED3\u6784\u5316\u4EA4\u4E92\u56FE\uFF08trigger/condition/action + target \u7ED1\u5B9A\uFF09\uFF0C\u652F\u6301\u5206\u9875\u3002",
+  {
+    url: z.string().describe("\u8BBE\u8BA1\u7A3F\u9875\u9762 URL"),
+    artboard: z.string().describe("\u753B\u677F\u540D\u79F0"),
+    page_y: z.number().describe("Y \u8D77\u59CB\u5750\u6807").default(0),
+    page_height: z.number().describe("Y \u8303\u56F4\u9AD8\u5EA6").default(5e3),
+    offset: z.number().describe("interactions \u5206\u9875\u8D77\u59CB\u504F\u79FB").default(0),
+    limit: z.number().describe("interactions \u5206\u9875\u5927\u5C0F").default(200),
+    cursor: z.string().optional().describe("\u5206\u9875\u6E38\u6807\uFF0C\u683C\u5F0F\u793A\u4F8B: offset:200")
+  },
+  async ({
+    url,
+    artboard,
+    page_y = 0,
+    page_height = 5e3,
+    offset = 0,
+    limit = 200,
+    cursor
+  }) => {
+    const data = await toolGetInteractionGraph(
+      url,
+      artboard,
+      page_y,
+      page_height,
+      offset,
+      limit,
+      cursor
+    );
+    return { content: [{ type: "text", text: data }] };
+  }
+);
+server.tool(
+  "validate_implementation",
+  "V3\u95ED\u73AF\uFF1A\u5BF9\u6BD4\u671F\u671B blueprint \u4E0E\u5B9E\u73B0\u5FEB\u7167\uFF0C\u8F93\u51FA\u5E03\u5C40/\u6837\u5F0F/\u4EA4\u4E92\u8BC4\u5206\u4E0E\u4FEE\u590D\u5EFA\u8BAE\u3002",
+  {
+    expected_json: z.string().describe("\u671F\u671B blueprint JSON \u5B57\u7B26\u4E32"),
+    actual_json: z.string().describe("\u5B9E\u73B0\u5FEB\u7167 JSON \u5B57\u7B26\u4E32")
+  },
+  async ({ expected_json, actual_json }) => {
+    const data = await toolValidateImplementation(expected_json, actual_json);
+    return { content: [{ type: "text", text: data }] };
+  }
+);
+var transport = new StdioServerTransport();
+await server.connect(transport);
+//# sourceMappingURL=index.js.map