mini-figma-code-connect 0.1.0 → 0.1.3

package/dist/main/handle.js

@@ -0,0 +1,167 @@
+import { lookup } from '../runtime/registry';
+export class ErrorHandle {
+    constructor(message) {
+        this.message = message;
+        this.type = 'ERROR';
+    }
+}
+class TextHandle {
+    constructor(node) {
+        this.node = node;
+        this.type = 'TEXT';
+    }
+    get name() {
+        return this.node.name;
+    }
+    get textContent() {
+        return this.node.characters;
+    }
+}
+export class InstanceHandle {
+    constructor(node, ctx) {
+        this.node = node;
+        this.ctx = ctx;
+        this.type = 'INSTANCE';
+    }
+    get name() {
+        return this.node.name;
+    }
+    // ── 属性查找：key 带 "#id" 后缀，按显示名找回来 ──
+    entryKey(prop) {
+        const props = this.node.componentProperties;
+        if (Object.prototype.hasOwnProperty.call(props, prop))
+            return prop;
+        return Object.keys(props).find((k) => k.split('#')[0] === prop);
+    }
+    /** 保留 type —— 否则 getString 之类无法察觉自己读错了属性类型 */
+    entry(prop) {
+        const k = this.entryKey(prop);
+        if (k === undefined)
+            return undefined;
+        return this.node.componentProperties[k];
+    }
+    log(c) {
+        this.ctx.calls.push({ ...c, depth: this.ctx.depth });
+    }
+    getString(prop) {
+        const e = this.entry(prop);
+        if (!e) {
+            this.log({ prop, method: 'getString', ok: false, note: '属性不存在' });
+            return '';
+        }
+        if (e.type === 'INSTANCE_SWAP') {
+            // INSTANCE_SWAP 的 value 是个节点 id，直接当字符串吐进代码里毫无意义
+            this.log({
+                prop,
+                method: 'getString',
+                ok: false,
+                note: '这是 INSTANCE_SWAP 属性，应该用 getInstanceSwap()',
+            });
+            return '';
+        }
+        this.log({ prop, method: 'getString', ok: true });
+        return String(e.value);
+    }
+    getBoolean(prop, mapping) {
+        const e = this.entry(prop);
+        if (!e) {
+            this.log({ prop, method: 'getBoolean', ok: false, note: '属性不存在' });
+            return mapping ? mapping.false : false;
+        }
+        // 布尔常被做成 VARIANT，选项写作 "True"/"False"（Figma UI 的默认命名），
+        // 所以必须大小写不敏感，否则 Disabled 永远读成 false
+        const v = this.ctx.probe ? true : e.value === true || String(e.value).toLowerCase() === 'true';
+        this.log({ prop, method: 'getBoolean', ok: true });
+        return mapping ? (v ? mapping.true : mapping.false) : v;
+    }
+    /** 字典查表。命中不了就返回 undefined —— 跟真实 CC 一样静默，靠 validate() 事后揪出来 */
+    getEnum(prop, mapping) {
+        const keys = Object.keys(mapping);
+        const e = this.entry(prop);
+        if (!e) {
+            this.log({ prop, method: 'getEnum', mappingKeys: keys, ok: false, note: '属性不存在' });
+            return undefined;
+        }
+        const raw = String(e.value);
+        const hit = Object.prototype.hasOwnProperty.call(mapping, raw);
+        this.log({
+            prop,
+            method: 'getEnum',
+            mappingKeys: keys,
+            ok: hit,
+            note: hit ? undefined : `当前值 "${raw}" 不在字典里，返回了 undefined`,
+        });
+        return hit ? mapping[raw] : undefined;
+    }
+    /** 绑插槽而不是绑图层名：找到把 mainComponent 绑在这个属性上的后代实例 */
+    getInstanceSwap(prop) {
+        const key = this.entryKey(prop);
+        if (key === undefined) {
+            this.log({ prop, method: 'getInstanceSwap', ok: false, note: '属性不存在' });
+            return null;
+        }
+        const hit = this.node.findOne((n) => {
+            if (n.type !== 'INSTANCE')
+                return false;
+            const refs = n.componentPropertyReferences;
+            return !!refs && refs.mainComponent === key;
+        });
+        if (!hit) {
+            this.log({ prop, method: 'getInstanceSwap', ok: false, note: '找不到绑定该属性的子实例' });
+            return new ErrorHandle(`找不到 instance swap 插槽 "${prop}"`);
+        }
+        this.log({ prop, method: 'getInstanceSwap', ok: true });
+        return new InstanceHandle(hit, this.ctx);
+    }
+    findInstance(layerName) {
+        const hit = this.node.findOne((n) => n.type === 'INSTANCE' && n.name === layerName);
+        return hit ? new InstanceHandle(hit, this.ctx) : new ErrorHandle(`找不到图层 "${layerName}"`);
+    }
+    findText(layerName) {
+        const hit = this.node.findOne((n) => n.type === 'TEXT' && n.name === layerName);
+        return hit ? new TextHandle(hit) : new ErrorHandle(`找不到文本图层 "${layerName}"`);
+    }
+    template() {
+        const ref = this.ctx.mainByNode.get(this.node.id);
+        return ref ? lookup(ref.key, ref.name) : null;
+    }
+    hasCodeConnect() {
+        return this.template() !== null;
+    }
+    codeConnectId() {
+        const t = this.template();
+        return t ? t.id : null;
+    }
+    /** 递归求值：子模板的输出直接插进父模板的字面量 */
+    executeTemplate() {
+        const ref = this.ctx.mainByNode.get(this.node.id);
+        if (this.ctx.depth > 8) {
+            return { example: [{ type: 'ERROR', message: '嵌套层级过深，已截断' }], id: 'depth-limit' };
+        }
+        const t = this.template();
+        if (!t) {
+            // 没有映射 → 返回 INSTANCE 段，保留实例身份（真实 CC 在这里渲染成 pill）
+            return {
+                example: [
+                    {
+                        type: 'INSTANCE',
+                        guid: this.node.id,
+                        symbolId: ref ? ref.id : '',
+                        name: ref ? ref.name : this.node.name,
+                    },
+                ],
+                id: 'unmapped',
+            };
+        }
+        const child = new InstanceHandle(this.node, { ...this.ctx, depth: this.ctx.depth + 1 });
+        try {
+            return t.render(child);
+        }
+        catch (err) {
+            return {
+                example: [{ type: 'ERROR', message: `模板 ${t.id} 执行失败: ${String(err)}` }],
+                id: t.id,
+            };
+        }
+    }
+}

package/dist/main/mapping-table.generated.json

@@ -0,0 +1 @@
+[]

package/dist/main/messages.d.ts

@@ -0,0 +1,71 @@
+import type { AccessorCall, ComponentSchema, ResultSection, TemplateMeta } from '../runtime/types';
+import type { Finding } from './validate';
+type Candidate = {
+    id: string;
+    name: string;
+    mapped: boolean;
+};
+export type UnmappedGroup = {
+    componentKey: string;
+    componentName: string;
+    count: number;
+    sampleNodeId: string;
+    mapped: boolean;
+    codeComponent: string | null;
+};
+export type ToUi = {
+    type: 'state';
+    state: 'empty' | 'unmapped' | 'error';
+    message: string;
+    schema?: ComponentSchema;
+    /** 该实例在 Figma 里的完整节点地址，拿不到 figma.fileKey 时为 null；仅 unmapped 用得上 */
+    figmaUrl?: string | null;
+    /** 上一次「一个容器里多个实例」的候选名单，供面板画「返回列表」 */
+    candidates?: Candidate[];
+} | {
+    type: 'state';
+    state: 'candidates';
+    message: string;
+    candidates: Candidate[];
+} | {
+    type: 'state';
+    state: 'scan';
+    message: string;
+    groups: UnmappedGroup[];
+} | {
+    type: 'state';
+    state: 'ok';
+    message: '';
+    schema: ComponentSchema;
+    template: {
+        id: string;
+        meta: TemplateMeta;
+    };
+    snippet: string;
+    imports: string[];
+    sections: ResultSection[];
+    findings: Finding[];
+    calls: AccessorCall[];
+    candidates?: Candidate[];
+} | {
+    type: 'download';
+    filename: string;
+    json: string;
+};
+export type FromUi = {
+    type: 'refresh';
+} | {
+    type: 'pick';
+    id: string;
+} | {
+    type: 'backToList';
+} | {
+    type: 'exportSchema';
+} | {
+    type: 'scan';
+} | {
+    type: 'exportAllSchemas';
+} | {
+    type: 'exportMappingTable';
+};
+export {};

package/dist/main/messages.js

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

package/dist/main/schema.d.ts

@@ -0,0 +1,9 @@
+import type { ComponentSchema } from '../runtime/types';
+/**
+ * VARIANT 属性的定义住在 ComponentSet 上，其余属性也一并在那儿
+ * （ComponentSet 的 componentPropertyDefinitions 同时包含 VARIANT 和 BOOLEAN/TEXT/INSTANCE_SWAP）。
+ * 所以只取这一个 owner 不会漏属性，后面所有身份（key / name / id）都以它为准。
+ */
+export declare function definitionOwner(main: ComponentNode): ComponentNode | ComponentSetNode;
+/** Step 3：组件 → 属性 schema */
+export declare function extractSchema(main: ComponentNode): Promise<ComponentSchema>;

package/dist/main/schema.js

@@ -0,0 +1,39 @@
+/**
+ * VARIANT 属性的定义住在 ComponentSet 上，其余属性也一并在那儿
+ * （ComponentSet 的 componentPropertyDefinitions 同时包含 VARIANT 和 BOOLEAN/TEXT/INSTANCE_SWAP）。
+ * 所以只取这一个 owner 不会漏属性，后面所有身份（key / name / id）都以它为准。
+ */
+export function definitionOwner(main) {
+    return main.parent && main.parent.type === 'COMPONENT_SET' ? main.parent : main;
+}
+/** Step 3：组件 → 属性 schema */
+export async function extractSchema(main) {
+    const owner = definitionOwner(main);
+    // 注意：这个 getter 在「是 variant 但拿不到所属 ComponentSet」时会 **抛错**，
+    // 不是返回 undefined —— 所以必须 try/catch，`?? {}` 是无效防护。
+    let defs = {};
+    try {
+        defs = owner.componentPropertyDefinitions;
+    }
+    catch {
+        defs = {};
+    }
+    const properties = Object.keys(defs).map((key) => {
+        const def = defs[key];
+        return {
+            // key 带 "#123:4" 后缀（VARIANT 除外）。只在展示层剥掉，查表时仍用完整 key
+            name: key.split('#')[0],
+            type: def.type,
+            variantOptions: def.variantOptions ? def.variantOptions.slice() : undefined,
+            defaultValue: typeof def.defaultValue === 'string' || typeof def.defaultValue === 'boolean'
+                ? def.defaultValue
+                : undefined,
+        };
+    });
+    return {
+        componentId: owner.id,
+        componentKey: owner.key,
+        componentName: owner.name,
+        properties,
+    };
+}

package/dist/main/validate.d.ts

@@ -0,0 +1,16 @@
+import type { AccessorCall, ComponentSchema } from '../runtime/types';
+export type Finding = {
+    level: 'error' | 'warn';
+    text: string;
+};
+/**
+ * Step 6 的自动化版本。
+ *
+ * 思路：不让模板重复声明它消费了什么，而是在 render 期间记录每一次 accessor 调用，
+ * 事后拿这份调用记录和 schema 对账。「穷举缺失」和「属性未映射」就都能被机器发现。
+ *
+ * @param calls    真实一遍 render 的调用记录 —— 用来报错
+ * @param coverage 探测一遍（所有 boolean 视为 true）的调用记录 —— 用来算覆盖率，
+ *                 避免条件分支里的属性被误报成未映射
+ */
+export declare function validate(schema: ComponentSchema, calls: AccessorCall[], coverage?: AccessorCall[]): Finding[];

package/dist/main/validate.js

@@ -0,0 +1,40 @@
+/**
+ * Step 6 的自动化版本。
+ *
+ * 思路：不让模板重复声明它消费了什么，而是在 render 期间记录每一次 accessor 调用，
+ * 事后拿这份调用记录和 schema 对账。「穷举缺失」和「属性未映射」就都能被机器发现。
+ *
+ * @param calls    真实一遍 render 的调用记录 —— 用来报错
+ * @param coverage 探测一遍（所有 boolean 视为 true）的调用记录 —— 用来算覆盖率，
+ *                 避免条件分支里的属性被误报成未映射
+ */
+export function validate(schema, calls, coverage = calls) {
+    const real = calls.filter((c) => c.depth === 0);
+    const touched = new Set(coverage.filter((c) => c.depth === 0).map((c) => c.prop));
+    const findings = [];
+    for (const p of schema.properties) {
+        if (!touched.has(p.name)) {
+            findings.push({ level: 'warn', text: `属性 "${p.name}" (${p.type}) 未被模板消费` });
+            continue;
+        }
+        if (p.type === 'VARIANT' && p.variantOptions) {
+            for (const c of real) {
+                if (c.prop !== p.name || c.method !== 'getEnum' || !c.mappingKeys)
+                    continue;
+                const keys = c.mappingKeys;
+                const missing = p.variantOptions.filter((v) => keys.indexOf(v) === -1);
+                if (missing.length > 0) {
+                    findings.push({
+                        level: 'error',
+                        text: `"${p.name}" 的 getEnum 字典漏了 ${missing.join('、')} —— 选到这些值时会静默产出 undefined`,
+                    });
+                }
+            }
+        }
+    }
+    for (const c of real) {
+        if (!c.ok)
+            findings.push({ level: 'error', text: `${c.method}("${c.prop}")：${c.note ?? '失败'}` });
+    }
+    return findings;
+}

package/dist/runtime/define.d.ts

@@ -0,0 +1,3 @@
+import type { Template } from './types';
+/** 只做类型收窄，让 .figma.ts 里能拿到 accessor 的补全 */
+export declare function defineTemplate(t: Template): Template;

package/dist/runtime/define.js

@@ -0,0 +1,4 @@
+/** 只做类型收窄，让 .figma.ts 里能拿到 accessor 的补全 */
+export function defineTemplate(t) {
+    return t;
+}

package/{src/runtime/index.ts → dist/runtime/index.d.ts}

@@ -5,17 +5,6 @@
  *
  *   import { defineTemplate, code } from 'mini-figma-code-connect'
  */
-export { defineTemplate } from './define'
-export { code } from './tagged'
-export type {
-  AccessorCall,
-  ComponentSchema,
-  ErrorLike,
-  FigmaPropertyType,
-  InstanceLike,
-  PropertyDef,
-  ResultSection,
-  Template,
-  TemplateResult,
-  TextLike,
-} from './types'
+export { defineTemplate } from './define';
+export { code } from './tagged';
+export type { AccessorCall, ComponentSchema, ErrorLike, FigmaPropertyType, InstanceLike, PropertyDef, ResultSection, Template, TemplateResult, TextLike, } from './types';

package/dist/runtime/index.js

@@ -0,0 +1,9 @@
+/**
+ * 包的公开入口。消费方的 .figma.ts 文件从这里导入，不用相对路径 `'../runtime/define'`——
+ * .figma.ts 现在就放在消费方自己的仓库里（比如 trex-website/apps/rexy/figma-mappings/），
+ * 跟这个引擎仓库没有相对路径关系，只能靠包名导入：
+ *
+ *   import { defineTemplate, code } from 'mini-figma-code-connect'
+ */
+export { defineTemplate } from './define';
+export { code } from './tagged';

package/dist/runtime/registry.d.ts

@@ -0,0 +1,5 @@
+import type { Template } from './types';
+import { templates } from './registry.generated';
+export { templates };
+/** 先按 componentKey 精确匹配（绑定过的），再退回组件名 */
+export declare function lookup(componentKey: string, componentName: string): Template | null;

package/dist/runtime/registry.generated.d.ts

@@ -0,0 +1,3 @@
+/** build-package stub — 消费方 buildPlugin 会重定向到自己的 .generated */
+import type { Template } from './types';
+export declare const templates: Template[];

package/dist/runtime/registry.generated.js

@@ -0,0 +1 @@
+export const templates = [];

package/{src/runtime/registry.ts → dist/runtime/registry.js}

@@ -1,14 +1,13 @@
-import type { Template } from './types'
 // templates 数组不再手写维护 —— 由 scripts/generate-registry.mjs 扫 .figma.ts 自动生成，
 // 每次 build 前重跑，文件挪了/加了/删了自动跟上，不需要手动加 import。
 // 真实 Code Connect 是把模板发布到 Figma 服务端（CLI publish 或 MCP add_code_connect_map），
 // 由 Figma 在读取时执行；这里为了「装进插件就能跑」，改成插件内注册表。
-import { templates } from './registry.generated'
-export { templates }
-
+import { templates } from './registry.generated';
+export { templates };
 /** 先按 componentKey 精确匹配（绑定过的），再退回组件名 */
-export function lookup(componentKey: string, componentName: string): Template | null {
-  const byKey = templates.find((t) => t.match.componentKey && t.match.componentKey === componentKey)
-  if (byKey) return byKey
-  return templates.find((t) => t.match.componentName === componentName) ?? null
+export function lookup(componentKey, componentName) {
+    const byKey = templates.find((t) => t.match.componentKey && t.match.componentKey === componentKey);
+    if (byKey)
+        return byKey;
+    return templates.find((t) => t.match.componentName === componentName) ?? null;
 }

package/dist/runtime/render.d.ts

@@ -0,0 +1,6 @@
+import type { ResultSection } from './types';
+/** 去掉模板字面量带来的公共缩进 */
+export declare function dedent(text: string): string;
+/** ResultSection[] → 给人看的字符串。真正的消费端（Dev Mode / MCP）拿的是数组本身 */
+export declare function renderToString(sections: ResultSection[]): string;
+export declare function collectErrors(sections: ResultSection[]): string[];

package/dist/runtime/render.js

@@ -0,0 +1,27 @@
+/** 去掉模板字面量带来的公共缩进 */
+export function dedent(text) {
+    const lines = text.replace(/^\n+/, '').replace(/\s+$/, '').split('\n');
+    const indents = lines.filter((l) => l.trim() !== '').map((l) => /^[ \t]*/.exec(l)[0].length);
+    const min = indents.length ? Math.min(...indents) : 0;
+    return lines.map((l) => l.slice(min)).join('\n');
+}
+/** ResultSection[] → 给人看的字符串。真正的消费端（Dev Mode / MCP）拿的是数组本身 */
+export function renderToString(sections) {
+    let out = '';
+    for (const s of sections) {
+        if (s.type === 'CODE')
+            out += s.code;
+        else if (s.type === 'INSTANCE')
+            out += `{/* <${s.name}> 未连接 Code Connect */}`;
+        else
+            out += `/* ⚠ ${s.message} */`;
+    }
+    return dedent(out);
+}
+export function collectErrors(sections) {
+    const out = [];
+    for (const s of sections)
+        if (s.type === 'ERROR')
+            out.push(s.message);
+    return out;
+}

package/dist/runtime/tagged.d.ts

@@ -0,0 +1,6 @@
+import type { ResultSection } from './types';
+export type Interpolable = ResultSection[] | string | number | boolean | null | undefined;
+export declare function code(strings: TemplateStringsArray, ...values: Interpolable[]): ResultSection[];
+/** 真实 CC 里这些只影响语法高亮，运行时行为完全一致 */
+export declare const tsx: typeof code;
+export declare const html: typeof code;

package/dist/runtime/tagged.js

@@ -0,0 +1,45 @@
+/**
+ * figma.code`...` 的简版。
+ *
+ * 职责只有两件：把插值切成 ResultSection[]，把嵌套的 section 数组摊平。
+ * 它 **不解析代码语义** —— 这正是真实 Code Connect 的实现边界，
+ * 也是为什么用 `+` 或 `.join()` 拼 section 会得到 [object Object]。
+ */
+function tag(strings, values) {
+    const out = [];
+    const pushCode = (s) => {
+        if (s === '')
+            return;
+        const last = out[out.length - 1];
+        if (last && last.type === 'CODE')
+            last.code += s;
+        else
+            out.push({ type: 'CODE', code: s });
+    };
+    strings.forEach((chunk, i) => {
+        pushCode(chunk);
+        if (i >= values.length)
+            return;
+        const v = values[i];
+        // null / undefined / false 一律不输出，方便写条件插值
+        if (v === null || v === undefined || v === false)
+            return;
+        if (Array.isArray(v)) {
+            for (const sec of v) {
+                if (sec.type === 'CODE')
+                    pushCode(sec.code);
+                else
+                    out.push(sec);
+            }
+            return;
+        }
+        pushCode(String(v));
+    });
+    return out;
+}
+export function code(strings, ...values) {
+    return tag(strings, values);
+}
+/** 真实 CC 里这些只影响语法高亮，运行时行为完全一致 */
+export const tsx = code;
+export const html = code;

package/dist/runtime/types.d.ts

@@ -0,0 +1,107 @@
+/**
+ * 迷你 Code Connect 运行时的类型定义。
+ *
+ * 关键一点，也是整套实现的地基：模板的输出不是字符串，而是 ResultSection[]。
+ * 这样才能在拼装时保留实例身份、并让错误就地降级而不是拖垮整段 snippet。
+ */
+/** 一段普通代码文本 */
+export type CodeSection = {
+    type: 'CODE';
+    code: string;
+};
+/** 「有实例但没有映射」的占位段：保留实例身份，真实 CC 在这里渲染成可展开的 pill */
+export type InstanceSection = {
+    type: 'INSTANCE';
+    guid: string;
+    symbolId: string;
+    name: string;
+};
+/** 就地降级的错误段 */
+export type ErrorSection = {
+    type: 'ERROR';
+    message: string;
+};
+export type ResultSection = CodeSection | InstanceSection | ErrorSection;
+/** Figma 组件属性的封闭类型集（真实 CC 还有 SLOT，简版不做） */
+export type FigmaPropertyType = 'TEXT' | 'BOOLEAN' | 'VARIANT' | 'INSTANCE_SWAP';
+export type PropertyDef = {
+    name: string;
+    type: FigmaPropertyType;
+    variantOptions?: string[];
+    defaultValue?: string | boolean;
+};
+/** Step 3 的产出：组件的属性 schema —— 映射的「左手边」 */
+export type ComponentSchema = {
+    componentId: string;
+    componentKey: string;
+    componentName: string;
+    properties: PropertyDef[];
+};
+export type TemplateResult = {
+    example: ResultSection[];
+    id: string;
+    imports?: string[];
+    metadata?: {
+        nestable?: boolean;
+        props?: Record<string, unknown>;
+    };
+};
+/** 头部三行绑定注释的结构化版本（真实 CC 是在构建时解析注释） */
+export type TemplateMeta = {
+    url: string;
+    source: string;
+    component: string;
+};
+export type Template = {
+    meta: TemplateMeta;
+    id: string;
+    /** 怎么认出这个模板对应哪个 Figma 组件：优先 componentKey，退回组件名 */
+    match: {
+        componentName: string;
+        componentKey?: string;
+    };
+    /**
+     * 映射的实体是这个函数，不是任何一段固定代码。
+     * 写一份，覆盖该组件的全部 variant 组合。
+     */
+    render: (instance: InstanceLike) => TemplateResult;
+};
+/** 模板能看到的实例接口（accessor 层） */
+export interface InstanceLike {
+    readonly type: 'INSTANCE';
+    readonly name: string;
+    getString(prop: string): string;
+    getBoolean(prop: string): boolean;
+    getBoolean<T>(prop: string, mapping: {
+        true: T;
+        false: T;
+    }): T;
+    getEnum<T>(prop: string, mapping: Record<string, T>): T | undefined;
+    getInstanceSwap(prop: string): InstanceLike | ErrorLike | null;
+    findInstance(layerName: string): InstanceLike | ErrorLike;
+    findText(layerName: string): TextLike | ErrorLike;
+    hasCodeConnect(): boolean;
+    codeConnectId(): string | null;
+    executeTemplate(): TemplateResult | null;
+}
+/** 注意 type 是 'ERROR' 而不是 null —— 查找失败返回的是 truthy 的句柄。
+ *  这是真实 CC 的实现权衡：为了把 message 带下去渲染成 ERROR 段而放弃 null 惯例。
+ *  代价就是模板里每次都得写 `x.type === 'INSTANCE'` 检查。 */
+export interface ErrorLike {
+    readonly type: 'ERROR';
+    readonly message: string;
+}
+export interface TextLike {
+    readonly type: 'TEXT';
+    readonly name: string;
+    readonly textContent: string;
+}
+/** 一次 accessor 调用的记录，供 Step 6 的自动校验使用 */
+export type AccessorCall = {
+    depth: number;
+    prop: string;
+    method: 'getString' | 'getBoolean' | 'getEnum' | 'getInstanceSwap';
+    mappingKeys?: string[];
+    ok: boolean;
+    note?: string;
+};

package/dist/runtime/types.js

@@ -0,0 +1,7 @@
+/**
+ * 迷你 Code Connect 运行时的类型定义。
+ *
+ * 关键一点，也是整套实现的地基：模板的输出不是字符串，而是 ResultSection[]。
+ * 这样才能在拼装时保留实例身份、并让错误就地降级而不是拖垮整段 snippet。
+ */
+export {};