mini-figma-code-connect 0.1.1 → 0.1.4

package/dist/generate-registry.mjs

@@ -0,0 +1,86 @@
+// scripts/generate-registry.mjs
+import fs from "node:fs";
+import path2 from "node:path";
+
+// scripts/is-cli-entrypoint.mjs
+import { existsSync, readFileSync, realpathSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+function isCliEntrypoint(importMetaUrl, entryName) {
+  if (!process.argv[1]) return false;
+  try {
+    const argvPath = realpathSync(process.argv[1]);
+    const metaPath = realpathSync(fileURLToPath(importMetaUrl));
+    if (argvPath !== metaPath) return false;
+    if (entryName) {
+      return path.basename(argvPath).includes(entryName);
+    }
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// scripts/generate-registry.mjs
+function parseGlob(glob) {
+  const starIdx = glob.indexOf("*");
+  if (starIdx === -1) throw new Error(`generate-registry: glob \u91CC\u6CA1\u6709 *\uFF1A"${glob}"`);
+  const dir = glob.slice(0, starIdx).replace(/\/$/, "");
+  const recursive = glob.includes("**");
+  return { dir, recursive };
+}
+function findFigmaFiles(dir, recursive) {
+  const results = [];
+  function walk(d) {
+    if (!fs.existsSync(d)) return;
+    for (const entry of fs.readdirSync(d, { withFileTypes: true })) {
+      if (entry.name === "node_modules" || entry.name.startsWith(".")) continue;
+      const full = path2.join(d, entry.name);
+      if (entry.isDirectory()) {
+        if (recursive) walk(full);
+      } else if (entry.name.endsWith(".figma.ts")) {
+        results.push(full);
+      }
+    }
+  }
+  walk(dir);
+  return results.sort();
+}
+function identifierFor(filePath, index) {
+  const base = path2.basename(filePath).replace(/\.figma\.ts$/, "").replace(/[^a-zA-Z0-9]/g, "");
+  const safe = base && /^[a-zA-Z_]/.test(base) ? base : `M${base}`;
+  return `${safe || "Mapping"}_${index}`;
+}
+function generateRegistry({ cwd, mappingsGlob, outFile, typesImport = "./types" }) {
+  const { dir, recursive } = parseGlob(mappingsGlob);
+  const files = findFigmaFiles(path2.resolve(cwd, dir), recursive);
+  const outDir = path2.dirname(outFile);
+  const imports = files.map((f, i) => {
+    const id = identifierFor(f, i);
+    let rel = path2.relative(outDir, f).replace(/\.ts$/, "");
+    if (!rel.startsWith(".")) rel = `./${rel}`;
+    rel = rel.split(path2.sep).join("/");
+    return { id, importPath: rel };
+  });
+  const typeLine = typesImport == null ? "" : `import type { Template } from '${typesImport}'
+`;
+  const templatesAnn = typesImport == null ? "" : ": Template[]";
+  const body = `// \u81EA\u52A8\u751F\u6210\uFF0C\u4E0D\u8981\u624B\u6539 \u2014\u2014 \u7531 scripts/generate-registry.mjs \u626B .figma.ts \u751F\u6210\uFF0C\u6BCF\u6B21 build \u524D\u91CD\u8DD1
+` + typeLine + imports.map((i) => `import ${i.id} from '${i.importPath}'`).join("\n") + (imports.length ? "\n\n" : "\n") + `export const templates${templatesAnn} = [${imports.map((i) => i.id).join(", ")}]
+`;
+  fs.mkdirSync(outDir, { recursive: true });
+  fs.writeFileSync(outFile, body);
+  return { count: files.length, files };
+}
+if (isCliEntrypoint(import.meta.url, "generate-registry")) {
+  const [, , mappingsGlob, outFile] = process.argv;
+  if (!mappingsGlob || !outFile) {
+    console.error("\u7528\u6CD5: node scripts/generate-registry.mjs <mappingsGlob> <outFile>");
+    process.exit(1);
+  }
+  const result = generateRegistry({ cwd: process.cwd(), mappingsGlob, outFile: path2.resolve(outFile) });
+  console.log(`[generate-registry] \u5199\u5165 ${result.count} \u6761\u6620\u5C04\u5230 ${outFile}`);
+}
+export {
+  generateRegistry
+};

package/dist/install-skill.mjs

@@ -0,0 +1,91 @@
+#!/usr/bin/env node
+
+// scripts/install-skill.mjs
+import fs from "node:fs";
+import path2 from "node:path";
+
+// scripts/is-cli-entrypoint.mjs
+import { existsSync, readFileSync, realpathSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+function isCliEntrypoint(importMetaUrl, entryName) {
+  if (!process.argv[1]) return false;
+  try {
+    const argvPath = realpathSync(process.argv[1]);
+    const metaPath = realpathSync(fileURLToPath(importMetaUrl));
+    if (argvPath !== metaPath) return false;
+    if (entryName) {
+      return path.basename(argvPath).includes(entryName);
+    }
+    return true;
+  } catch {
+    return false;
+  }
+}
+function findPackageRoot(importMetaUrl) {
+  let dir = path.dirname(fileURLToPath(importMetaUrl));
+  while (true) {
+    const pkgPath = path.join(dir, "package.json");
+    if (existsSync(pkgPath)) {
+      try {
+        const pkg = JSON.parse(readFileSync(pkgPath, "utf8"));
+        if (pkg.name === "mini-figma-code-connect") return dir;
+      } catch {
+      }
+    }
+    const parent = path.dirname(dir);
+    if (parent === dir) {
+      throw new Error("[mini-figma-code-connect] \u627E\u4E0D\u5230\u5305\u6839\u76EE\u5F55\uFF08package.json\uFF09");
+    }
+    dir = parent;
+  }
+}
+
+// scripts/install-skill.mjs
+var PACKAGE_ROOT = findPackageRoot(import.meta.url);
+var SKILL_SOURCE = path2.join(PACKAGE_ROOT, ".claude/skills/mini-code-connect");
+var SKILL_NAME = "mini-code-connect";
+function findRepoRoot(cwd) {
+  let dir = cwd;
+  while (true) {
+    if (fs.existsSync(path2.join(dir, ".git"))) return dir;
+    const parent = path2.dirname(dir);
+    if (parent === dir) return cwd;
+    dir = parent;
+  }
+}
+function installSkill({ cwd, root, force = false, claudeMirror = true }) {
+  const base = root ?? findRepoRoot(cwd);
+  const targets = [];
+  if (claudeMirror) targets.push(path2.join(base, ".claude/skills", SKILL_NAME));
+  if (fs.existsSync(path2.join(base, ".agents/skills"))) {
+    targets.push(path2.join(base, ".agents/skills", SKILL_NAME));
+  }
+  const results = [];
+  for (const target of targets) {
+    if (fs.existsSync(target) && !force) {
+      results.push({ target, skipped: true });
+      continue;
+    }
+    fs.rmSync(target, { recursive: true, force: true });
+    fs.cpSync(SKILL_SOURCE, target, { recursive: true });
+    results.push({ target, skipped: false });
+  }
+  return { results, root: base };
+}
+if (isCliEntrypoint(import.meta.url, "install-skill")) {
+  const args = process.argv.slice(2);
+  const force = args.includes("--force");
+  const noClaudeMirror = args.includes("--no-claude-mirror");
+  const rootIdx = args.indexOf("--root");
+  const root = rootIdx !== -1 ? path2.resolve(args[rootIdx + 1]) : void 0;
+  const { results, root: usedRoot } = installSkill({ cwd: process.cwd(), root, force, claudeMirror: !noClaudeMirror });
+  console.log(`[install-skill] \u9879\u76EE\u6839\u76EE\u5F55\uFF1A${usedRoot}`);
+  for (const r of results) {
+    console.log(r.skipped ? `[install-skill] \u5DF2\u5B58\u5728\uFF0C\u8DF3\u8FC7\uFF08\u52A0 --force \u8986\u76D6\uFF09\uFF1A${r.target}` : `[install-skill] \u5DF2\u5199\u5165\uFF1A${r.target}`);
+  }
+  console.log('\n\u8DD1 /mini-code-connect\uFF08\u6216\u76F4\u63A5\u8BF4"\u5E2E\u6211\u6620\u5C04\u8FD9\u4E2A Figma \u7EC4\u4EF6"\uFF09\u89E6\u53D1 skill\u3002');
+}
+export {
+  installSkill
+};

package/dist/main/code.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/main/code.js

@@ -0,0 +1,388 @@
+/**
+ * 主线程。三个运行形态，共用同一条流水线：
+ *
+ *   figma.mode === 'codegen'  → Dev Mode 右侧 Code 区（真实 Code Connect 出现的位置）
+ *   figma.mode === 'inspect'  → Dev Mode 右侧 Inspect 面板，铺满
+ *   其余（Design 模式）        → 普通浮层面板
+ *
+ * 流水线本身刻意跟 figma-code-connect skill 的 6 步对齐：
+ *   Step 1 归一化输入      —— 拿到 InstanceNode
+ *   Step 2 任意节点 → 主组件 —— getMainComponentAsync + definitionOwner
+ *   Step 3 组件 → 属性 schema —— extractSchema
+ *   Step 4 找代码那一侧     —— registry.lookup（代码组件由模板的 meta.source 声明）
+ *   Step 5 执行映射         —— template.render(handle)
+ *   Step 6 自检             —— validate(schema, calls, probeCalls)
+ */
+import { extractSchema, definitionOwner } from './schema';
+import { InstanceHandle } from './handle';
+import { lookup } from '../runtime/registry';
+import { renderToString, collectErrors } from '../runtime/render';
+import { validate } from './validate';
+// build 时打包进 dist/code.js —— 装插件的人只有这份产物，摸不到消费方项目的源码，
+// 所以这份映射表得跟着插件一起发，不能指望大家去消费方仓库里找 .figma.ts 文件
+// 消费方的 figma-mapping-table.json 由 scripts/copy-mapping-table.mjs 在 build 前复制到这里
+// （gitignore 掉，不进 git diff）——这份代码本身不该硬编码"数据就在我自己仓库里"这个假设。
+import mappingTable from './mapping-table.generated.json';
+async function mainRefOf(node) {
+    const main = await node.getMainComponentAsync();
+    if (!main)
+        return null;
+    const owner = definitionOwner(main);
+    return { id: owner.id, key: owner.key, name: owner.name };
+}
+/** 把整棵实例子树的主组件身份预解析好，让 render() 能保持同步。并发，别串行 */
+async function buildMainMap(root) {
+    const nodes = [root];
+    for (const n of root.findAllWithCriteria({ types: ['INSTANCE'] }))
+        nodes.push(n);
+    const refs = await Promise.all(nodes.map((n) => mainRefOf(n)));
+    const map = new Map();
+    nodes.forEach((n, i) => {
+        const ref = refs[i];
+        if (ref)
+            map.set(n.id, ref);
+    });
+    return map;
+}
+async function analyze(node) {
+    const main = await node.getMainComponentAsync();
+    if (!main)
+        return { ok: false, reason: '读不到主组件（可能是缺失的远端组件）' };
+    const schema = await extractSchema(main);
+    const template = lookup(schema.componentKey, schema.componentName);
+    if (!template) {
+        return {
+            ok: false,
+            schema,
+            reason: `还没有 "${schema.componentName}" 的映射。在这个项目的 figma-mappings/ 下新建一个 .figma.ts，` +
+                `match.componentName 填 "${schema.componentName}"，然后重新跑一遍插件构建（会自动重新扫描收录）。`,
+        };
+    }
+    const mainByNode = await buildMainMap(node);
+    const calls = [];
+    let sections;
+    let imports;
+    try {
+        const result = template.render(new InstanceHandle(node, { mainByNode, calls, depth: 0 }));
+        sections = result.example;
+        imports = result.imports ?? [];
+    }
+    catch (err) {
+        return { ok: false, schema, reason: `模板执行抛错：${String(err)}` };
+    }
+    // 第二遍：探测模式，只为算「模板最多会碰到哪些属性」，避免条件分支被误报未映射
+    const probeCalls = [];
+    try {
+        template.render(new InstanceHandle(node, { mainByNode, calls: probeCalls, depth: 0, probe: true }));
+    }
+    catch {
+        // 探测失败不影响主流程
+    }
+    const findings = validate(schema, calls, probeCalls);
+    for (const m of collectErrors(sections))
+        findings.push({ level: 'error', text: m });
+    return {
+        ok: true,
+        schema,
+        template: { id: template.id, meta: template.meta },
+        sections,
+        snippet: renderToString(sections),
+        imports,
+        findings,
+        calls,
+    };
+}
+/** 嵌套在别的实例里的实例（比如 Button 内部的图标）交给那个父实例的模板自己处理，不算独立候选 */
+function isNestedInAnotherInstance(node, root) {
+    let p = node.parent;
+    while (p && p !== root) {
+        if (p.type === 'INSTANCE')
+            return true;
+        p = p.parent;
+    }
+    return false;
+}
+async function isMapped(node) {
+    const ref = await mainRefOf(node);
+    return ref !== null && lookup(ref.key, ref.name) !== null;
+}
+/** figma.fileKey 只对私有插件开放（manifest 需 enablePrivatePluginApi），拿不到就老实置 null */
+function figmaUrlFor(componentId) {
+    const fileKey = figma.fileKey;
+    return fileKey ? `https://www.figma.com/design/${fileKey}/?node-id=${componentId.replace(':', '-')}` : null;
+}
+async function asInstance(node) {
+    if (!node)
+        return { error: '在画布上选中一个组件实例' };
+    if (node.type === 'INSTANCE')
+        return node;
+    if ('findAllWithCriteria' in node) {
+        const all = node.findAllWithCriteria({ types: ['INSTANCE'] });
+        const mappedFlags = await Promise.all(all.map((n) => isMapped(n)));
+        // 嵌套实例已映射的话，父模板自己 getInstanceSwap 就能渲染出来，不用再单独列一遍；
+        // 没映射的嵌套实例（比如还没接的图标）没有别的地方能发现它，照样单独列出来，
+        // 不然永远不知道要先去映射它，父模板那个插槽也会一直是空的
+        const instances = all
+            .map((n, i) => ({ node: n, mapped: mappedFlags[i] }))
+            .filter(({ node: n, mapped }) => !(mapped && isNestedInAnotherInstance(n, node)));
+        if (instances.length === 1)
+            return instances[0].node;
+        if (instances.length > 1) {
+            return { candidates: instances.map(({ node: n, mapped }) => ({ id: n.id, name: n.name, mapped })) };
+        }
+    }
+    return { error: `选中的是 ${node.type}，里面没有组件实例（INSTANCE）` };
+}
+// ───────────────────────── 形态一：Dev Mode Code 区 ─────────────────────────
+if (figma.mode === 'codegen') {
+    figma.codegen.on('generate', async ({ node }) => {
+        const picked = await asInstance(node);
+        if ('error' in picked) {
+            return [{ title: 'Simple Code Connect', code: `// ${picked.error}`, language: 'PLAINTEXT' }];
+        }
+        if ('candidates' in picked) {
+            return [
+                {
+                    title: 'Simple Code Connect',
+                    code: `// 里面有 ${picked.candidates.length} 个组件实例，请单选其中一个：\n${picked.candidates
+                        .map((c) => `//  - ${c.name}`)
+                        .join('\n')}`,
+                    language: 'PLAINTEXT',
+                },
+            ];
+        }
+        const a = await analyze(picked);
+        if (!a.ok) {
+            return [{ title: 'Simple Code Connect', code: `// ${a.reason}`, language: 'PLAINTEXT' }];
+        }
+        const results = [
+            {
+                title: `React · ${a.template.meta.component}`,
+                code: (a.imports.length ? a.imports.join('\n') + '\n\n' : '') + a.snippet,
+                language: 'TYPESCRIPT',
+            },
+        ];
+        if (a.findings.length > 0) {
+            results.push({
+                title: 'Code Connect 自检',
+                code: a.findings.map((f) => `[${f.level}] ${f.text}`).join('\n'),
+                language: 'PLAINTEXT',
+            });
+        }
+        results.push({
+            title: '绑定',
+            code: [
+                `component:  ${a.template.meta.component}`,
+                `source:     ${a.template.meta.source}`,
+                `templateId: ${a.template.id}`,
+                `figma:      ${a.schema.componentName}`,
+            ].join('\n'),
+            language: 'PLAINTEXT',
+        });
+        return results;
+    });
+}
+else {
+    // ───────────────────── 形态二/三：面板（Inspect 或 Design 浮层）─────────────────────
+    figma.showUI(__html__, { width: 480, height: 660, themeColors: true });
+    function post(msg) {
+        figma.ui.postMessage(msg);
+    }
+    /**
+     * 选区变化会连续触发 run()，而 run() 中间有多个 await。
+     * 没有代际校验的话，旧的那次可能在新的之后 post，面板显示上一个实例的结果。
+     */
+    let generation = 0;
+    /** 上一次「容器里多个实例」的候选名单，选完一个之后还留着，供面板画「返回列表」 */
+    let lastCandidates = null;
+    /** 扫一遍当前页所有实例，按主组件去重，列出全部并标已映射/未映射——对应真实 CC 的 get_code_connect_suggestions */
+    async function scanPage() {
+        const instances = figma.currentPage.findAllWithCriteria({ types: ['INSTANCE'] });
+        const groups = new Map();
+        for (const inst of instances) {
+            const main = await inst.getMainComponentAsync();
+            if (!main)
+                continue;
+            const owner = definitionOwner(main);
+            const template = lookup(owner.key, owner.name);
+            const groupKey = owner.key || owner.id;
+            const g = groups.get(groupKey);
+            if (g) {
+                g.count++;
+            }
+            else {
+                groups.set(groupKey, {
+                    componentName: owner.name,
+                    count: 1,
+                    sampleNodeId: inst.id,
+                    mapped: template !== null,
+                    codeComponent: template ? template.meta.component : null,
+                });
+            }
+        }
+        const list = [...groups.entries()].map(([componentKey, g]) => ({ componentKey, ...g }));
+        list.sort((a, b) => Number(a.mapped) - Number(b.mapped) || b.count - a.count);
+        const unmappedCount = list.filter((g) => !g.mapped).length;
+        post({
+            type: 'state',
+            state: 'scan',
+            message: list.length === 0
+                ? '当前页面没有任何组件实例'
+                : `共 ${list.length} 个组件，${unmappedCount} 个还没映射`,
+            groups: list,
+        });
+    }
+    async function run() {
+        const my = ++generation;
+        const stale = () => my !== generation;
+        const sel = figma.currentPage.selection;
+        if (sel.length > 1) {
+            post({ type: 'state', state: 'empty', message: `选中了 ${sel.length} 个节点，请单选一个组件实例` });
+            return;
+        }
+        const picked = await asInstance(sel[0] ?? null);
+        if ('error' in picked) {
+            post({ type: 'state', state: 'empty', message: picked.error, candidates: lastCandidates ?? undefined });
+            return;
+        }
+        if ('candidates' in picked) {
+            lastCandidates = picked.candidates;
+            post({
+                type: 'state',
+                state: 'candidates',
+                message: `里面有 ${picked.candidates.length} 个组件实例，请单选其中一个`,
+                candidates: picked.candidates,
+            });
+            return;
+        }
+        const a = await analyze(picked);
+        if (stale())
+            return;
+        if (!a.ok) {
+            post({
+                type: 'state',
+                state: a.schema ? 'unmapped' : 'error',
+                message: a.reason,
+                schema: a.schema,
+                figmaUrl: a.schema ? figmaUrlFor(a.schema.componentId) : undefined,
+                candidates: lastCandidates ?? undefined,
+            });
+            return;
+        }
+        post({
+            type: 'state',
+            state: 'ok',
+            message: '',
+            schema: a.schema,
+            template: a.template,
+            snippet: a.snippet,
+            imports: a.imports,
+            sections: a.sections,
+            findings: a.findings,
+            calls: a.calls,
+            candidates: lastCandidates ?? undefined,
+        });
+    }
+    /**
+     * Figma 不会 await 这些 handler，也不会处理它们的 rejection。
+     * 任何漏出来的 throw 都等于「面板永久停在上一帧」，所以每个入口都得自己兜住。
+     */
+    async function guard(fn) {
+        try {
+            await fn();
+        }
+        catch (err) {
+            post({ type: 'state', state: 'error', message: `插件内部错误：${String(err)}` });
+            console.error(err);
+        }
+    }
+    figma.ui.onmessage = (msg) => {
+        if (msg.type === 'refresh')
+            void guard(run);
+        else if (msg.type === 'pick') {
+            void guard(async () => {
+                const node = await figma.getNodeByIdAsync(msg.id);
+                if (!node || node.type !== 'INSTANCE') {
+                    figma.notify('这个实例已经不在画布上了，重新读取一下');
+                    return;
+                }
+                figma.currentPage.selection = [node];
+                figma.viewport.scrollAndZoomIntoView([node]);
+                await run();
+            });
+        }
+        else if (msg.type === 'scan') {
+            void guard(scanPage);
+        }
+        else if (msg.type === 'exportMappingTable') {
+            void guard(async () => {
+                post({ type: 'download', filename: 'mapping-table.json', json: JSON.stringify(mappingTable, null, 2) });
+            });
+        }
+        else if (msg.type === 'exportAllSchemas') {
+            void guard(async () => {
+                if (!lastCandidates || lastCandidates.length === 0) {
+                    figma.notify('没有候选实例可导出，先框选一个里面有多个实例的容器');
+                    return;
+                }
+                const schemas = [];
+                const seenKeys = new Set();
+                for (const c of lastCandidates) {
+                    const node = await figma.getNodeByIdAsync(c.id);
+                    if (!node || node.type !== 'INSTANCE')
+                        continue;
+                    const main = await node.getMainComponentAsync();
+                    if (!main)
+                        continue;
+                    const schema = await extractSchema(main);
+                    const dedupeKey = schema.componentKey || schema.componentId;
+                    if (seenKeys.has(dedupeKey))
+                        continue;
+                    seenKeys.add(dedupeKey);
+                    schemas.push(schema);
+                }
+                if (schemas.length === 0) {
+                    figma.notify('没读到任何组件 schema');
+                    return;
+                }
+                post({ type: 'download', filename: 'schemas.json', json: JSON.stringify(schemas, null, 2) });
+            });
+        }
+        else if (msg.type === 'backToList') {
+            if (lastCandidates) {
+                post({
+                    type: 'state',
+                    state: 'candidates',
+                    message: `里面有 ${lastCandidates.length} 个组件实例，请单选其中一个`,
+                    candidates: lastCandidates,
+                });
+            }
+        }
+        else if (msg.type === 'exportSchema') {
+            void guard(async () => {
+                const picked = await asInstance(figma.currentPage.selection[0] ?? null);
+                if ('error' in picked) {
+                    figma.notify(picked.error);
+                    return;
+                }
+                if ('candidates' in picked) {
+                    figma.notify(`里面有 ${picked.candidates.length} 个组件实例，请先单选其中一个`);
+                    return;
+                }
+                const main = await picked.getMainComponentAsync();
+                if (!main) {
+                    figma.notify('读不到主组件');
+                    return;
+                }
+                const schema = await extractSchema(main);
+                const safeName = schema.componentName.replace(/[^a-zA-Z0-9]+/g, '') || 'Component';
+                post({ type: 'download', filename: `${safeName}.schema.json`, json: JSON.stringify(schema, null, 2) });
+            });
+        }
+    };
+    figma.on('selectionchange', () => {
+        void guard(run);
+    });
+    // 首次读取由 UI 就绪后主动 send('refresh') 触发 —— 否则这里的 post 可能早于
+    // iframe 挂上 onmessage，首帧直接丢掉。
+}

package/dist/main/handle.d.ts

@@ -0,0 +1,55 @@
+import type { AccessorCall, ErrorLike, InstanceLike, TemplateResult, TextLike } from '../runtime/types';
+/** 预解析好的主组件身份 */
+export type MainRef = {
+    id: string;
+    key: string;
+    name: string;
+};
+/**
+ * render() 是同步的（跟真实 CC 一致），但 Figma 的 getMainComponentAsync 是异步的。
+ * 解法：执行模板前先把整棵实例子树的主组件身份解析好塞进 ctx，句柄层就能保持同步。
+ */
+export type RenderCtx = {
+    mainByNode: Map<string, MainRef>;
+    calls: AccessorCall[];
+    depth: number;
+    /**
+     * 探测模式：所有 getBoolean 一律返回 true。
+     * 用来跑第二遍 render，收集「模板最多会碰到哪些属性」——
+     * 否则条件分支里的属性（Has Icon 为 false 时的 Icon）会被误报成「未映射」。
+     */
+    probe?: boolean;
+};
+export declare class ErrorHandle implements ErrorLike {
+    readonly message: string;
+    readonly type: "ERROR";
+    constructor(message: string);
+}
+export declare class InstanceHandle implements InstanceLike {
+    private node;
+    private ctx;
+    readonly type: "INSTANCE";
+    constructor(node: InstanceNode, ctx: RenderCtx);
+    get name(): string;
+    private entryKey;
+    /** 保留 type —— 否则 getString 之类无法察觉自己读错了属性类型 */
+    private entry;
+    private log;
+    getString(prop: string): string;
+    getBoolean(prop: string): boolean;
+    getBoolean<T>(prop: string, mapping: {
+        true: T;
+        false: T;
+    }): T;
+    /** 字典查表。命中不了就返回 undefined —— 跟真实 CC 一样静默，靠 validate() 事后揪出来 */
+    getEnum<T>(prop: string, mapping: Record<string, T>): T | undefined;
+    /** 绑插槽而不是绑图层名：找到把 mainComponent 绑在这个属性上的后代实例 */
+    getInstanceSwap(prop: string): InstanceLike | ErrorLike | null;
+    findInstance(layerName: string): InstanceLike | ErrorLike;
+    findText(layerName: string): TextLike | ErrorLike;
+    private template;
+    hasCodeConnect(): boolean;
+    codeConnectId(): string | null;
+    /** 递归求值：子模板的输出直接插进父模板的字面量 */
+    executeTemplate(): TemplateResult | null;
+}