cardbuddy 0.23.0 → 0.25.0

package/dist/vendored/server/core/flameCompile/h5.js

@@ -0,0 +1,326 @@
+/**
+ * H5 产物编译（ai-assistant-h5 的卡片 js）
+ *
+ * 1:1 迁移自 flame-release-mange（Java）的
+ *   h5/H5Engine.java
+ *   h5/convert/{CardConvert,ComponentConvert,StyleConvert,PropertyConvert,
+ *               ExpressionConvert,EventActionConvert,DirectiveConvert,DataConvert}
+ *   h5/entity/*（JsFileEntify / JsFileComponentEntify / ...）
+ *
+ * 产物：单文件 AMD 模块
+ *   define(function(){ return {...} });
+ * 返回一个 Vue 组件选项对象，由 @ynet/card 的 m-card 通过 require 装载后 `h(content, {props:{data}})`
+ * 渲染。组件不自带 h：一律 `this.getCreateElement(this, _h)` 取宿主注入的创建器（Vue2/Vue3 双兼容），
+ * 元素组件通过 `this.getElement('Text')` 取宿主 elements 注册表。
+ *
+ * 关键契约（照抄平台侧，改动会直接导致真机渲染空白）：
+ *   - 数据挂在 `s = c.state`，表达式里的 `$foo` 已改写为 `s.$foo`；
+ *   - `data` 里必须同时给 defaultState / state / n（n 是刷新因子，模板里靠它触发重算）；
+ *   - watch.data 重新合并 state，宿主下发新数据时才能刷新；
+ *   - 每个事件的实现体被搬到 methods 里，on 只留转发（避免闭包捕获旧 state）。
+ */
+
+import {
+  collectProps,
+  convertCondition,
+  convertExpression,
+  convertPropsClient,
+  convertPropsH5,
+  hasText,
+  jsKey,
+  pickVarProps,
+} from './common.js'
+import { elementOf } from './clientElements.js'
+
+const INJECTS = {
+  getObject: { type: 'Function', default: 'function(){return function(){}}' },
+  getElement: { type: 'Function', default: 'function(){return function(n){return n}}' },
+  getCreateElement: { type: 'Function', default: 'function(){return function(vm){ return vm.$createElement;}}' },
+}
+
+export function createH5Compiler(card, { warnings = [] } = {}) {
+  let counter = 0
+  const nextVal = (prefix) => `${prefix}${counter++}`
+
+  /** 生命周期代码桶 */
+  const lifecycles = { created: [], destroyed: [], unmounted: [] }
+  const methods = []
+  const components = []
+
+  /* ---------------------------- 卡片级上下文 ---------------------------- */
+
+  lifecycles.created.push(`this.$emit('info',${JSON.stringify({ width: card.width })});`)
+
+  // data 定义：入参默认值 + 运行态 state + 刷新因子
+  const defaultState = {}
+  for (const field of card.data.props) defaultState[field.key] = field.defaultValue
+
+  lifecycles.created.push('this.state = Object.assign({}, this.defaultState, this.data);')
+
+  lifecycles.created.push("var CC = this.getObject('context');")
+  lifecycles.created.push('CC.init&&CC.init(this);')
+  lifecycles.destroyed.push("var CC = this.getObject('context');")
+  lifecycles.destroyed.push('CC.destroy&&CC.destroy(this);')
+  lifecycles.unmounted.push("var CC = this.getObject('context');")
+  lifecycles.unmounted.push('CC.destroy&&CC.destroy(this);')
+
+  const watch = { data: 'this.state = Object.assign({}, this.defaultState, this.data);' }
+
+  /* ------------------------------ 组件树 ------------------------------ */
+
+  const root = {
+    id: 'root',
+    name: card.className,
+    style: {},
+    props: convertPropsH5(card.properties),
+    styleProps: convertPropsH5(card.style.properties),
+    events: [],
+    slots: [],
+  }
+  components.push(root)
+
+  // 根节点不处理 directives —— 与平台 h5/convert/CardConvert 一致（该处只转 style + 事件）。
+  // 早期版本这里调过一次 applyDirectives，但卡片模型本就没有 directives 字段，属于死代码；
+  // 更要紧的是平台产物不含根层显隐，本地产物若多出来就会与线上不一致。
+  for (const ea of card.eventactions) addEvent(root, ea)
+
+  const slot = { slotKey: 'default', slotScope: false, components: [] }
+  root.slots.push(slot)
+  for (const child of card.components) slot.components.push(convertComponent(child))
+
+  function convertComponent(component) {
+    const layer = {
+      id: component.componentId,
+      name: component.className,
+      style: {},
+      props: convertPropsH5(component.properties),
+      styleProps: convertPropsH5(component.style.properties),
+      events: [],
+      slots: [],
+    }
+
+    applyDirectives(component, layer, warnings)
+    // 双向绑定必须先于事件动作入队：平台的 ea 编号是按 events 列表顺序分配的，
+    // 顺序错了会让 on 里的转发名与 methods 里的实现体错位。
+    convertTwoWayBinding(component, layer)
+    for (const ea of component.eventactions) addEvent(layer, ea)
+
+    const childSlot = component.slots && component.slots[0]
+    if (childSlot) {
+      const s = {
+        slotKey: childSlot.slotKey,
+        // 列表 / 网格的插槽是作用域插槽（每项独立上下文）
+        slotScope: component.className === 'ListLayout' || component.className === 'GridLayout',
+        components: [],
+      }
+      layer.slots.push(s)
+      for (const child of childSlot.components) s.components.push(convertComponent(child))
+    }
+
+    return layer
+  }
+
+  /**
+   * v-show → 内联 display
+   *
+   * 平台侧（h5/DirectiveConvert）对「表达式型条件」走改写（`$x` → `s.$x`），
+   * 对「结构化条件」直接拼未改写的结果。这里统一改写：结构化条件的 val 也可能是 `$x`，
+   * 不改写会在真机上抛 ReferenceError（平台侧缺陷，属修正而非偏离）。
+   */
+  function applyDirectives(component, layer, warnings) {
+    const { const: constProps } = convertPropsClient(component.directives)
+    const showProps = constProps['v-show']
+    if (!showProps || typeof showProps !== 'object') return
+    const showType = showProps.showType
+    if (showType === '00') return
+
+    const condition = showProps.condition
+    if (!condition || typeof condition !== 'object') return
+
+    let expression = null
+    if (hasText(condition.expression)) {
+      expression = convertExpression(condition.expression)
+    } else if (Array.isArray(condition.group) && condition.group.length > 0) {
+      expression = convertExpression(convertCondition(condition.group))
+    }
+    if (!expression) {
+      warnings.push(`组件 ${component.componentId || 'root'} 的 v-show 条件为空，已忽略`)
+      return
+    }
+
+    if (showType === '01') layer.style.display = `(${expression}) ? 'block' : 'none'`
+    else if (showType === '02') layer.style.display = `(${expression}) ? 'none' : 'block'`
+  }
+
+  /**
+   * 双向绑定：value 动态绑定时补一条 input 监听，把宿主事件值写回状态
+   *
+   * 迁移自 h5/convert/element/{Input,CheckGroup,RadioButton,ProgressSlider}Transfer.doUpdatePropEvent ——
+   * 四个组件的实现逐字相同：事件名固定 `input`，实现体是 `this.setData({"$value":event}, '1')`。
+   * 注意键名走 JSON.stringify（与属性段的裸写口径不同），因为 $value 这类键在平台侧就是这么发的。
+   */
+  function convertTwoWayBinding(component, layer) {
+    if (!elementOf(component.className).twoWayBinding) return
+    const modelVar = pickVarProps(component.properties).value
+    if (!hasText(modelVar)) return
+    const name = nextVal('ea')
+    methods.push({
+      name,
+      code: `this.setData({${JSON.stringify(modelVar.trim())}:event}, '1');`,
+    })
+    layer.events.push({ name: 'input', handler: name })
+  }
+
+  /** 事件：实现体进 methods，on 里只做转发 */
+  function addEvent(layer, eventAction) {
+    if (!hasText(eventAction.eventKey) || !hasText(eventAction.actionType)) return
+    const name = nextVal('ea')
+    const body = buildEventBody(eventAction, layer)
+    methods.push({ name, code: body })
+    layer.events.push({ name: eventAction.eventKey, handler: name })
+  }
+
+  function buildEventBody(eventAction, layer) {
+    const actionType = eventAction.actionType
+    // 事件参数：走平台口径的 JSON 序列化（动态值原样进 JSON，不改写）
+    const propsMap = collectProps(eventAction.properties)
+    const { const: constProps } = convertPropsClient(eventAction.properties)
+
+    if (actionType === 'customAction') {
+      const fn = constProps.function
+      const code = fn && typeof fn === 'object' ? fn.code : null
+      const compiled = fn && typeof fn === 'object' ? fn.compiled : null
+      // 平台侧优先用 compiled（ES5 转译版），缺失才回退手写 code
+      if (hasText(compiled)) return compiled
+      if (hasText(code)) return code
+      warnings.push(`事件 ${eventAction.eventKey} 的 customAction 缺少 code，已跳过`)
+      return ''
+    }
+
+    if (actionType === 'closeAlertCard') {
+      return `ynet.callJSAPI('${actionType}',${JSON.stringify({ cardCode: card.code })});`
+    }
+
+    if (!hasText(actionType)) return ''
+    // 其余动作统一走 JSAPI，参数是属性对象
+    return `ynet.callJSAPI('${actionType}',${JSON.stringify(propsMap)});`
+  }
+
+  /* ------------------------------ 序列化 ------------------------------ */
+
+  const serializeComponent = (layer) => {
+    const args = [`e(${JSON.stringify(layer.name)})`]
+    const options = []
+
+    options.push(`ref:${JSON.stringify(layer.id)}`)
+
+    if (Object.keys(layer.style).length) {
+      const styleCode = Object.entries(layer.style)
+        .map(([k, v]) => `${jsKey(k)}:${v}`)
+        .join(',')
+      options.push(`style:{${styleCode}}`)
+    }
+
+    if (hasText(layer.props) && layer.props !== '{}') {
+      options.push(`props:{styleProps:${layer.styleProps}${stripBraces(layer.props)}}`)
+    } else if (hasText(layer.styleProps) && layer.styleProps !== '{}') {
+      options.push(`props:{styleProps:${layer.styleProps}}`)
+    }
+
+    if (layer.events.length) {
+      const code = layer.events
+        .map((ev) => `${jsKey(ev.name)}:function(event){_vm.${ev.handler}(c,event)}`)
+        .join(',')
+      options.push(`on:{${code}}`)
+    }
+
+    const normalSlots = layer.slots.filter((s) => !s.slotScope)
+    const scopeSlots = layer.slots.filter((s) => s.slotScope)
+
+    if (scopeSlots.length) {
+      const code = scopeSlots
+        .map(
+          (s) =>
+            `${jsKey(s.slotKey)}:function(_sd_){return (function(c){var s = c.state; return [${s.components
+              .map(serializeComponent)
+              .join(',')}]})(new CC(_vm,_sd_,c))}`
+        )
+        .join(',')
+      options.push(`scopedSlots:{${code}}`)
+    }
+
+    args.push(`{${options.join(',')}}`)
+
+    if (normalSlots.length) {
+      const slots = normalSlots
+        .map(
+          (s) =>
+            `h('template', {slot: ${JSON.stringify(s.slotKey)}},[${s.components.map(serializeComponent).join(',')}])`
+        )
+        .join(',')
+      args.push(`[${slots}]`)
+    }
+
+    return `h(${args.join(',')})`
+  }
+
+  const renderBody =
+    'render: function (_h) {' +
+    'var _vm = this;' +
+    'var h = this.getCreateElement(this,_h);' +
+    "var CC = this.getObject('context');" +
+    'var e = this.getElement;' +
+    'var c = new CC(this,this);' +
+    'var s = c.state;' +
+    'var n = this.n;' +
+    `return ${components.map(serializeComponent).join('')}` +
+    '}'
+
+  const parts = []
+
+  const injectCode = Object.entries(INJECTS)
+    .map(([k, v]) => `${k}:{type:${v.type},default:${v.default}}`)
+    .join(',')
+  parts.push(`inject:{${injectCode}}`)
+
+  parts.push('props:{data:{type:Object,default:function(){ return {} }}}')
+
+  const dataCode = [
+    `defaultState:${JSON.stringify(defaultState)}`,
+    'state:{}',
+    'n:0',
+  ].join(',')
+  parts.push(`data:function(){ return {${dataCode}}}`)
+
+  for (const key of ['created', 'destroyed', 'unmounted']) {
+    if (lifecycles[key].length) parts.push(`${key}:function(){${lifecycles[key].join('')}}`)
+  }
+
+  if (Object.keys(watch).length) {
+    const code = Object.entries(watch)
+      .map(([k, v]) => `${k}:function(){${v}}`)
+      .join(',')
+    parts.push(`watch:{${code}}`)
+  }
+
+  parts.push(renderBody)
+
+  if (methods.length) {
+    const code = methods
+      .map(
+        (m) =>
+          `${m.name}:function(c, event){var ynet=this.getObject('ynet');(function(){\n${m.code}\n}).apply(c);}`
+      )
+      .join(',')
+    parts.push(`methods:{${code}}`)
+  }
+
+  // 结尾与平台侧一致：`return {…}});`（对象闭合后直接跟 `});`，无空格）
+  return `define(function(){ return {${parts.join(',')}}});`
+}
+
+function stripBraces(literal) {
+  if (!literal) return ''
+  const body = literal.replace(/^\{/, '').replace(/\}$/, '')
+  return body ? `,${body}` : ''
+}

package/dist/vendored/server/core/flameCompile/index.js

@@ -0,0 +1,126 @@
+/**
+ * 卡片编译入口：schema.json → 客户端（GaiaX）产物 + H5 产物
+ *
+ * 编译逻辑迁移自 flame-release-mange（Java）的 card/exporter 包，
+ * 本文件只做「两套引擎的编排 + 文件序列化 + 加密」，不含业务判断。
+ *
+ * 返回：
+ *   {
+ *     cardCode, version,
+ *     client: [{ code, files: { 'index.json': string, ... } }],
+ *     h5: string,
+ *     warnings: string[],
+ *     stats: { nodes, templates, clientBytes, h5Bytes }
+ *   }
+ */
+
+import crypto from 'node:crypto'
+import { parseCard } from './model.js'
+import {
+  createClientCompiler,
+  serializeTemplateCss,
+  serializeTemplateData,
+  serializeTemplateDataBinding,
+  serializeTemplateJs,
+  serializeTemplateJson,
+} from './client.js'
+import { createH5Compiler } from './h5.js'
+
+/** 平台侧 SM4 参数（CBC / PKCS5Padding），与 NativeEngine 内的常量一致 */
+const SM4_KEY = '95330f00edb563a34de2200bcf745147'
+const SM4_IV = 'f2e7f925855c66f75e4f070e782f7ed4'
+
+/**
+ * index.style：index.js 的密文（iOS 侧仅在明文 index.js 缺失时才读它）
+ *
+ * 平台侧是 `SM4/CBC/PKCS5Padding` 的 `doFinal` 结果直接落盘 —— 即**二进制密文**，
+ * 不是 base64 文本。Node 的 `sm4-cbc` 默认填充同为 PKCS#7（16 字节块下与 PKCS#5 等价），
+ * 所以这里也必须输出 Buffer，编码成 base64 会让 iOS 侧解不出来。
+ *
+ * @returns {Buffer|null} 密文字节；运行环境不支持 SM4 时返回 null
+ */
+export function encryptStyle(jsCode) {
+  try {
+    const cipher = crypto.createCipheriv('sm4-cbc', Buffer.from(SM4_KEY, 'hex'), Buffer.from(SM4_IV, 'hex'))
+    return Buffer.concat([cipher.update(jsCode, 'utf8'), cipher.final()])
+  } catch (e) {
+    return null
+  }
+}
+
+/** 单个产物的字节数（index.style 是 Buffer，其余是字符串） */
+function byteSize(value) {
+  return Buffer.isBuffer(value) ? value.length : Buffer.byteLength(value, 'utf8')
+}
+
+/** 统计视图树节点数（含子模板），用于产物报告 */
+function countNodes(components) {
+  let n = 0
+  const walk = (list) => {
+    for (const c of list) {
+      n += 1
+      for (const s of c.slots || []) walk(s.components)
+    }
+  }
+  walk(components)
+  return n
+}
+
+/**
+ * 编译一张卡片
+ * @param {Object} schema  schema.json 内容
+ * @param {Object} opts
+ * @param {string} opts.cardCode 卡片编码（= 本地目录名）
+ * @param {string} [opts.version] 模板版本（写进 package.version，缺省取 schema.version）
+ * @param {boolean} [opts.encryptStyle] 是否额外产出 index.style，默认 true
+ */
+export function compileCard(schema, { cardCode, version, encryptStyle: withEncryptedStyle = true } = {}) {
+  const warnings = []
+  const ver = String(version || schema.version || '1.0.0')
+
+  // 两份独立模型：客户端编译会改写列表类组件的 componentId（平台侧同款副作用），
+  // 若与 H5 共用同一份模型，H5 产物的 ref 会变成子模板编码。
+  const clientCard = parseCard(schema, cardCode)
+  const h5Card = parseCard(schema, cardCode)
+
+  const clientEngine = createClientCompiler(clientCard, { version: ver, warnings })
+
+  const client = clientEngine.templates.map((template) => {
+    const files = {
+      'index.json': serializeTemplateJson(template),
+      'index.css': serializeTemplateCss(template),
+      'index.databinding': serializeTemplateDataBinding(template),
+      'index.data': serializeTemplateData(template),
+      'index.js': serializeTemplateJs(template),
+    }
+    if (withEncryptedStyle) {
+      const encrypted = encryptStyle(files['index.js'])
+      if (encrypted) files['index.style'] = encrypted
+      else warnings.push('当前 Node 不支持 SM4，已跳过 index.style')
+    }
+    return { code: template.code, files }
+  })
+
+  const h5 = createH5Compiler(h5Card, { warnings })
+
+  const clientBytes = client.reduce(
+    (sum, t) => sum + Object.values(t.files).reduce((s, v) => s + byteSize(v), 0),
+    0
+  )
+
+  return {
+    cardCode,
+    version: ver,
+    client,
+    h5,
+    warnings,
+    stats: {
+      nodes: countNodes(clientCard.components),
+      templates: client.length,
+      clientBytes,
+      h5Bytes: Buffer.byteLength(h5, 'utf8'),
+    },
+  }
+}
+
+export default compileCard

package/dist/vendored/server/core/flameCompile/model.js

@@ -0,0 +1,162 @@
+/**
+ * schema.json → 编译模型
+ *
+ * 1:1 迁移自 flame-release-mange（Java）的
+ *   com.ynet.inmanage.application.card.model.{CardModel,ComponentModel,StyleModel,
+ *   PropertyModel,PropertyGroupModel,DataModel,FieldModel,SlotModel,EventActionModel}
+ *
+ * 输入契约与 dsl-card 的 src/cards/<id>/schema.json **完全同源**：
+ *   { platform, dictionary:{dictionaryList,inputParams}, view:{ width, className, style,
+ *     properties, eventactions, components:[{ componentId, className, style, properties,
+ *     directives, eventactions, slots:[{ slotKey, components }] }] } }
+ * 因此不需要任何字段重命名，也不需要经过编辑器的 buildPreview（那会灌入 meta 默认值，
+ * 与平台侧编译结果不一致）。
+ *
+ * 设计约束：本文件只做**结构解析**，不判断语义；所有取值一律走 `pick`，
+ * 缺字段时给 Java 侧同样的空值（`''` / `[]` / `{}`），保证下游转换分支与 Java 等价。
+ */
+
+/** 取字符串（Java getString 语义：非字符串值转字符串，null 保持 null） */
+export function str(v) {
+  if (v === undefined || v === null) return null
+  if (typeof v === 'string') return v
+  return String(v)
+}
+
+/** 取 JSON 对象（对应 Java getJSONObject：非对象返回 null） */
+export function obj(v) {
+  return v && typeof v === 'object' && !Array.isArray(v) ? v : null
+}
+
+/** 取 JSON 数组（对应 Java getJSONArray：非数组返回 null） */
+export function arr(v) {
+  return Array.isArray(v) ? v : null
+}
+
+/* ------------------------------ Property ------------------------------ */
+
+/**
+ * 属性节点
+ * @typedef {Object} PropertyModel
+ * @property {string} itemKey
+ * @property {string} itemValueFrom  '0' 静态 / '1' 动态表达式 / '2' 资源地址
+ * @property {*} itemValue
+ * @property {*} itemDefaultValue
+ * @property {PropertyModel[]} children   对象属性的子项（itemChildren.properties）
+ * @property {PropertyModel[][]} list     数组属性（itemList[].properties）
+ */
+export function parseProperty(p = {}) {
+  const children = obj(p.itemChildren)
+  const list = arr(p.itemList)
+  return {
+    itemKey: str(p.itemKey),
+    itemValueFrom: str(p.itemValueFrom),
+    itemValue: p.itemValue === undefined ? null : p.itemValue,
+    itemDefaultValue: p.itemDefaultValue === undefined ? null : p.itemDefaultValue,
+    children: children ? parsePropertyArray(children.properties) : [],
+    list: list ? list.map((g) => parsePropertyArray(obj(g) ? g.properties : null)) : [],
+  }
+}
+
+export function parsePropertyArray(list) {
+  const a = arr(list)
+  return a ? a.map((p) => parseProperty(p || {})) : []
+}
+
+/** 样式定义（StyleModel）：实质就是一组属性 */
+export function parseStyle(style) {
+  const s = obj(style)
+  return { properties: s ? parsePropertyArray(s.properties) : [] }
+}
+
+/* ------------------------------ Component ----------------------------- */
+
+export function parseSlot(slot = {}) {
+  return {
+    slotKey: str(slot.slotKey) || 'default',
+    slotScope: slot.slotScope === true || slot.slotScope === 'true',
+    components: parseComponentArray(slot.components),
+  }
+}
+
+export function parseComponent(c = {}) {
+  const slots = arr(c.slots)
+  return {
+    componentId: str(c.componentId),
+    className: str(c.className),
+    name: str(c.name),
+    style: parseStyle(c.style),
+    properties: parsePropertyArray(c.properties),
+    directives: parsePropertyArray(c.directives),
+    eventactions: parseEventActionArray(c.eventactions),
+    slots: slots ? slots.map((s) => parseSlot(s || {})) : [],
+  }
+}
+
+export function parseComponentArray(list) {
+  const a = arr(list)
+  return a ? a.map((c) => parseComponent(c || {})) : []
+}
+
+/* ------------------------------ EventAction --------------------------- */
+
+export function parseEventAction(ea = {}) {
+  const event = obj(ea.event) || {}
+  const action = obj(ea.action) || {}
+  return {
+    eventKey: str(event.eventKey),
+    actionType: str(action.actionType),
+    properties: parsePropertyArray(action.properties),
+  }
+}
+
+export function parseEventActionArray(list) {
+  const a = arr(list)
+  return a ? a.map((ea) => parseEventAction(ea || {})) : []
+}
+
+/* -------------------------------- Field ------------------------------- */
+
+export function parseField(f = {}) {
+  const children = arr(f.children)
+  return {
+    key: str(f.key),
+    name: str(f.name),
+    type: str(f.type),
+    defaultValue: f.defaultValue === undefined ? null : f.defaultValue,
+    children: children ? children.map((c) => parseField(c || {})) : [],
+  }
+}
+
+export function parseFieldArray(list) {
+  const a = arr(list)
+  return a ? a.map((f) => parseField(f || {})) : []
+}
+
+/* --------------------------------- Card ------------------------------- */
+
+/**
+ * 卡片模型
+ * @param {Object} schema schema.json 内容
+ * @param {string} code   卡片编码（= 本地卡片目录名）
+ */
+export function parseCard(schema = {}, code = '') {
+  const dictionary = obj(schema.dictionary) || {}
+  const view = obj(schema.view) || {}
+  return {
+    code,
+    platform: str(schema.platform),
+    width: str(view.width),
+    className: str(view.className) || 'Root',
+    data: {
+      // 数据域定义（下发数据）
+      fields: parseFieldArray(dictionary.dictionaryList),
+      // 入参定义（默认值即 index.data）
+      props: parseFieldArray(dictionary.inputParams),
+    },
+    style: parseStyle(view.style),
+    properties: parsePropertyArray(view.properties),
+    components: parseComponentArray(view.components),
+    eventactions: parseEventActionArray(view.eventactions),
+  }
+}

package/dist/vendored/server/core/index.js

@@ -19,6 +19,7 @@ import { createSliceUploadMiddleware } from './sliceUpload.js'
 import { createRemoteCardMiddleware } from './remoteCard.js'
 import { createCardFilesMiddleware, refreshCardList } from './cardFiles.js'
 import { createExportMiddleware } from './cardExport.js'
+import { createCompileMiddleware } from './cardCompile.js'
 import { createSaveMiddleware } from './cardSave.js'
 import { createImportMetaMiddleware } from './cardImportMeta.js'
 import { createHistoryMiddleware } from './cardHistory.js'
@@ -58,6 +59,7 @@ export {
   createSaveMiddleware,
   createImportMetaMiddleware,
   createExportMiddleware,
+  createCompileMiddleware,
   createHistoryMiddleware,
   createValidateMiddleware,
   createRenderStatusMiddleware,
@@ -126,6 +128,10 @@ export function mountCoreMiddlewares(app, { root, viteServer = null, upstream =
   // 与 docs/卡片导出产物逆向分析与导出功能.md；previewSchema 经 viteServer.ssrLoadModule 复用
   // 编辑器同源 buildPreview，故本中间件需要 viteServer（无则退化为 schema 原样序列化）。
   app.use(createExportMiddleware({ root, viteServer, upstream }))
+  // 卡片编译（编辑器「网格预览 → 勾选 → 编译选中卡片」）：把 schema 编译成客户端 GaiaX 模板包
+  // 与 H5 卡片 js，产物落 <root>/flame-build/{client,h5}。编译规则迁移自 flame-release-mange
+  // 的 card/exporter（见 server/core/flameCompile/ 各文件头注释）。
+  app.use(createCompileMiddleware({ root }))
   app.use(createHistoryMiddleware({ root }))
   app.use(createValidateMiddleware({ root }))
   app.use(createRenderStatusMiddleware({ root, viteServer }))

package/dist/vendored/skills/dsl-card-generator/references/generation_pitfalls.md

@@ -169,7 +169,7 @@ node skills/dsl-card-generator/scripts/render_card.mjs --id <id> --width 375 --o
 ```js
 // 仅当需要自定义页面交互/逐样式断言且宿主 dev server(5180) 已启动时使用；
 // 本 skill 的离线 render_card.mjs 不提供任意页面交互，复制 skill 到其他项目后该配方按需自建。
-import { chromium } from 'playwright';
+import { chromium } from 'playwright-core';
 const ts = Date.now();
 const url = `http://localhost:5180/?card=<id>&t=${ts}`;
 const browser = await chromium.launch({ channel: 'chrome', args: ['--no-sandbox'] });