@proteus-vue/compiler-backend 0.1.0

package/dist/index.js

@@ -0,0 +1,1061 @@
+// src/conformance.ts
+import { TAG_SEMANTIC_MAP } from "@proteus-vue/component-ir";
+var DEFAULT_CONFORMANCE_SFC = `<template>
+  <p-stack :gap="12">
+    <p-grid :min-col-width="160" :max-cols="4">
+      <p-box />
+      <view class="compat"></view>
+    </p-grid>
+    <p-text>{{ title }}</p-text>
+    <p-button @click="onSave">\u4FDD\u5B58</p-button>
+    <p-input v-model="keyword" />
+    <p-scan-qr />
+  </p-stack>
+</template>`;
+function walkRender(node, fn) {
+  fn(node);
+  for (const c of node.children) walkRender(c, fn);
+}
+function countCIR(node) {
+  return 1 + node.children.reduce((acc, c) => acc + countCIR(c), 0);
+}
+function runCompilerConformance(backend, fixture = DEFAULT_CONFORMANCE_SFC) {
+  const checks = [];
+  function check(name, pass, detail) {
+    checks.push({ name, pass, detail });
+  }
+  check("id", typeof backend.id === "string" && backend.id.length > 0, `id=${String(backend.id)}`);
+  check("version", typeof backend.version === "string" && backend.version.length > 0, `version=${String(backend.version)}`);
+  check("minCompatVersion", backend.minCompatVersion === 1, `minCompatVersion=${String(backend.minCompatVersion)}\uFF08\u5951\u7EA6=1\uFF0CCMP004\uFF09`);
+  const caps = backend.capabilities;
+  if (!caps) {
+    check("capabilities", false, "\u7F3A\u5931 capabilities \u58F0\u660E");
+  } else {
+    check("capabilities.incremental", typeof caps.incremental === "boolean", `incremental=${String(caps.incremental)}`);
+    check("capabilities.sourceMap", typeof caps.sourceMap === "boolean", `sourceMap=${String(caps.sourceMap)}`);
+    check("capabilities.treeShaking", typeof caps.treeShaking === "boolean", `treeShaking=${String(caps.treeShaking)}`);
+    check("capabilities.wasmRuntime", typeof caps.wasmRuntime === "boolean", `wasmRuntime=${String(caps.wasmRuntime)}`);
+    check("capabilities.plugins", typeof caps.plugins === "boolean", `plugins=${String(caps.plugins)}`);
+    check("capabilities.maxFileSize", typeof caps.maxFileSize === "number" && caps.maxFileSize > 0, `maxFileSize=${String(caps.maxFileSize)}`);
+  }
+  let ir = null;
+  try {
+    ir = backend.compile({ filename: "conformance.vue", source: fixture });
+  } catch (e) {
+    check("compile", false, "compile \u629B\u9519: " + e.message);
+  }
+  if (ir) {
+    check("ir.version", ir.version === 1, `version=${String(ir.version)}\uFF08CMP004\uFF09`);
+    let semanticNodes = 0;
+    let compatElements = 0;
+    let linkBroken = [];
+    try {
+      walkRender(ir.render.root, (n) => {
+        check(`render.${n.type}`, typeof n.type === "string" && n.type.length > 0, `type=${n.type}`);
+        if (typeof n.type !== "string" || !Array.isArray(n.children)) {
+          return;
+        }
+        if (n.semantic) {
+          semanticNodes++;
+          const expected = n.type.startsWith("p-") ? TAG_SEMANTIC_MAP[n.type] : void 0;
+          if (n.type.startsWith("p-")) {
+            if (expected === void 0) {
+              linkBroken.push(`${n.type}\uFF08TAG_SEMANTIC_MAP \u672A\u767B\u8BB0\uFF09`);
+            } else if (expected !== n.semantic) {
+              linkBroken.push(`${n.type}: semantic=${n.semantic} \u2260 \u671F\u671B ${expected}`);
+            }
+          } else {
+            linkBroken.push(`${n.type}: \u975E p- \u5143\u7D20\u4E0D\u5E94\u643A\u5E26 semantic`);
+          }
+        } else if (n.type !== "#text" && n.type !== "#interpolation" && n.type !== "#comment") {
+          compatElements++;
+        }
+      });
+    } catch (e) {
+      check("render.tree", false, "render \u6811\u904D\u5386\u629B\u9519: " + e.message);
+    }
+    check("render.semanticLink", linkBroken.length === 0, linkBroken.length ? linkBroken.join("; ") : void 0);
+    const sem = ir.semantic;
+    if (!sem) {
+      check("ir.semantic", false, "\u7F3A\u5931 semantic IR");
+    } else {
+      check("ir.semantic.tree", sem.tree === null || typeof sem.tree.tag === "string" && typeof sem.tree.semantic === "string", sem.tree ? `root=${sem.tree.tag}\u2192${sem.tree.semantic}` : "tree=null");
+      const irCount = sem.tree ? countCIR(sem.tree) : 0;
+      check("ir.semantic.countMatch", irCount === sem.semanticCount, `C-IR \u6811 ${irCount} \u8282\u70B9 vs semanticCount=${sem.semanticCount}`);
+      check("ir.semantic.renderMatch", sem.semanticCount === semanticNodes, `semanticCount=${sem.semanticCount} vs \u6E32\u67D3\u6811\u8BED\u4E49\u8282\u70B9 ${semanticNodes}`);
+      check("ir.semantic.compatCount", sem.compatCount === compatElements, `compatCount=${sem.compatCount} vs \u6E32\u67D3\u6811\u517C\u5BB9\u5143\u7D20 ${compatElements}`);
+    }
+    const b = ir.bindings;
+    check("bindings.capabilities", Array.isArray(b?.capabilities), void 0);
+    check("bindings.models", Array.isArray(b?.models), void 0);
+    check("bindings.handlers", Array.isArray(b?.handlers), void 0);
+  }
+  try {
+    const ast = backend.parse("<p-grid />");
+    check("parse", typeof ast.root === "object" && ast.root !== null, `root.type=${String(ast?.root?.type)}`);
+  } catch (e) {
+    check("parse", false, "parse \u629B\u9519: " + e.message);
+  }
+  try {
+    if (ir) {
+      const gen = backend.generate(ir);
+      check("generate", typeof gen.code === "string" && Array.isArray(gen.warnings), void 0);
+    }
+  } catch {
+    check("generate", false, "generate \u629B\u9519");
+  }
+  if (backend.hotUpdate !== void 0 && typeof backend.hotUpdate !== "function") check("optional.hotUpdate", false, "hotUpdate \u975E\u51FD\u6570");
+  if (backend.generateSourceMap !== void 0 && typeof backend.generateSourceMap !== "function") check("optional.generateSourceMap", false, "generateSourceMap \u975E\u51FD\u6570");
+  return { ok: checks.every((c) => c.pass), checks };
+}
+
+// src/node.ts
+import { parse as sfcParse } from "@vue/compiler-sfc";
+import { parse as domParse, NodeTypes } from "@vue/compiler-dom";
+import { toComponentIR, TAG_SEMANTIC_MAP as TAG_SEMANTIC_MAP2 } from "@proteus-vue/component-ir";
+var NODE_CAPABILITIES = {
+  incremental: true,
+  // 官方 Node 后端支持增量（G-34 HMR 已有编译侧增量）
+  sourceMap: false,
+  // B4
+  treeShaking: false,
+  // B4
+  wasmRuntime: false,
+  plugins: true,
+  // 与 @proteus-vue/compiler 规则注册表同源
+  maxFileSize: 5 * 1024 * 1024
+};
+function camelize(s) {
+  return s.replace(/-([a-z])/g, (_, c) => c.toUpperCase());
+}
+function flattenChildNodes(children) {
+  const out = [];
+  for (const c of children) {
+    if (c.type === NodeTypes.IF) {
+      const branches = c.branches ?? [];
+      for (const b of branches) out.push(...flattenChildNodes(b.children));
+    } else if (c.type === NodeTypes.FOR) {
+      out.push(...flattenChildNodes(c.children));
+    } else {
+      out.push(c);
+    }
+  }
+  return out;
+}
+function exprContent(exp) {
+  if (exp && typeof exp === "object" && "content" in exp && typeof exp.content === "string") {
+    return exp.content;
+  }
+  return null;
+}
+function elementToRenderNode(el, acc) {
+  const props = {};
+  for (const attr of el.props) {
+    if (attr.type === NodeTypes.ATTRIBUTE) {
+      const a = attr;
+      if (a.name === "class" || a.name === "style" || a.name === "id" || a.name === "key" || a.name === "ref") continue;
+      props[a.name] = a.value?.content ?? true;
+      continue;
+    }
+    const d = attr;
+    const arg = d.arg && "content" in d.arg ? d.arg.content : void 0;
+    const exp = exprContent(d.exp);
+    if (d.name === "bind") {
+      const key = camelize(arg ?? "");
+      props[key] = exp !== null ? { expr: exp } : true;
+    } else if (d.name === "on") {
+      acc.handlers.push({ name: arg ?? "tap", target: exp ?? "" });
+    } else if (d.name === "model") {
+      acc.models.push({ name: arg ?? "modelValue", expr: exp ?? "" });
+    } else {
+      props[`v-${d.name}`] = exp !== null ? exp : true;
+    }
+  }
+  return {
+    type: el.tag,
+    // ★G-31 语义链接：p-* 标签 → TAG_SEMANTIC_MAP 语义（渲染树 semantic 与 C-IR 树同源）；非 p- → undefined（Layer 1 兼容层）
+    semantic: el.tag.startsWith("p-") ? TAG_SEMANTIC_MAP2[el.tag] : void 0,
+    props,
+    children: flattenChildNodes(el.children).filter((c) => c.type === NodeTypes.ELEMENT).map((c) => elementToRenderNode(c, acc)),
+    loc: { line: el.loc.start.line, column: el.loc.start.column }
+  };
+}
+function pickConstraintProps(props) {
+  const out = {};
+  for (const k of Object.keys(props)) {
+    if (k.startsWith("v-")) continue;
+    out[k] = props[k];
+  }
+  return out;
+}
+function renderToComponentIR(node) {
+  if (!node.type.startsWith("p-")) return null;
+  const children = node.children.map(renderToComponentIR).filter(Boolean);
+  return toComponentIR(node.type, pickConstraintProps(node.props), children);
+}
+function buildIR(template) {
+  const root = domParse(template, { onError: () => void 0 });
+  const rootEl = flattenChildNodes(root.children).find((c) => c.type === NodeTypes.ELEMENT);
+  if (!rootEl) {
+    return {
+      render: { type: "template", props: {}, children: [], loc: { line: 1, column: 1 } },
+      semantic: { tree: null, semanticCount: 0, compatCount: 0 },
+      bindings: { capabilities: [], models: [], handlers: [] }
+    };
+  }
+  const acc = { capabilities: [], models: [], handlers: [] };
+  const render = elementToRenderNode(rootEl, acc);
+  const tree = renderToComponentIR(render);
+  const semanticCount = tree ? countCIR2(tree) : 0;
+  const compatCount = countCompat(render);
+  if (tree) {
+    collectCapabilities(tree, acc);
+  }
+  return { render, semantic: { tree, semanticCount, compatCount }, bindings: acc };
+}
+function countCIR2(node) {
+  return 1 + node.children.reduce((acc, c) => acc + countCIR2(c), 0);
+}
+function countCompat(node) {
+  let n = 0;
+  if (node.type !== "#text" && node.type !== "#interpolation" && node.type !== "#comment" && !node.semantic) n++;
+  for (const c of node.children) n += countCompat(c);
+  return n;
+}
+function collectCapabilities(node, acc) {
+  if (node.semantic.startsWith("capability.")) {
+    acc.capabilities.push({ name: node.semantic.slice("capability.".length), semantic: node.semantic });
+  }
+  for (const c of node.children) collectCapabilities(c, acc);
+}
+function renderToTemplateNode(node) {
+  return {
+    type: node.type === "#text" ? "text" : node.type === "#interpolation" ? "interpolation" : node.type === "#comment" ? "comment" : "element",
+    tag: node.type,
+    props: { ...node.props },
+    children: node.children.map(renderToTemplateNode),
+    line: node.loc.line
+  };
+}
+function createNodeCompilerBackend() {
+  return {
+    id: "node",
+    version: "0.1.0",
+    minCompatVersion: 1,
+    capabilities: NODE_CAPABILITIES,
+    compile(sfc) {
+      const { descriptor } = sfcParse(sfc.source, { filename: sfc.filename ?? "anonymous.vue" });
+      const template = descriptor.template?.content ?? "";
+      const { render, semantic, bindings } = buildIR(template);
+      return { version: 1, render: { root: render }, semantic, bindings };
+    },
+    parse(template) {
+      const ir = buildIR(template);
+      return { root: renderToTemplateNode(ir.render) };
+    },
+    generate(ir) {
+      return { code: JSON.stringify(ir, null, 2), warnings: [] };
+    }
+  };
+}
+
+// src/dual-check.ts
+import { execFileSync } from "node:child_process";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { createRequire } from "node:module";
+var require2 = createRequire(import.meta.url);
+function semanticSeq(node) {
+  const out = [];
+  const walk = (n) => {
+    out.push(n.semantic ?? n.type ?? "");
+    for (const c of n.children ?? []) walk(c);
+  };
+  walk(node);
+  return out;
+}
+function normHandlerName(name) {
+  return name.split(".")[0];
+}
+function verifyDualCompilerEquivalence(source, opts) {
+  if (!opts.rustBin) {
+    return {
+      status: "skipped",
+      details: [],
+      reason: "Rust \u540E\u7AEF\u4E8C\u8FDB\u5236\u672A\u627E\u5230\uFF08\u5B89\u88C5 @proteus-vue/compiler-backend-rust \u6216\u8BBE PROTEUS_CC_RUST\uFF09\u2014\u2014\u964D\u7EA7 Node \u6821\u9A8C"
+    };
+  }
+  const nodeIr = createNodeCompilerBackend().compile({ filename: opts.filename ?? "dual-check.vue", source });
+  let rustRaw;
+  try {
+    rustRaw = opts.runRust ? opts.runRust(opts.rustBin, source) : runRustCli(opts.rustBin, source);
+  } catch (e) {
+    return {
+      status: "mismatch",
+      details: [`Rust CLI \u6267\u884C\u5931\u8D25\uFF1A${e.message.slice(0, 160)}`],
+      reason: "rust-cli-error"
+    };
+  }
+  let rustIr;
+  try {
+    rustIr = JSON.parse(rustRaw);
+  } catch {
+    return { status: "mismatch", details: ["Rust CLI \u8F93\u51FA\u975E\u6CD5 JSON\uFF08\u975E CompilerIR\uFF09"], reason: "rust-invalid-json" };
+  }
+  const details = [];
+  const nodeRenderSeq = semanticSeq(nodeIr.render.root);
+  const rustRoot = rustIr.render?.root;
+  if (!rustRoot) {
+    details.push("Rust render.root \u7F3A\u5931");
+  } else if (JSON.stringify(semanticSeq(rustRoot)) !== JSON.stringify(nodeRenderSeq)) {
+    details.push("render \u6811\u8BED\u4E49\u5E8F\u5217\u4E0D\u4E00\u81F4\uFF08G-29.1\uFF09");
+  }
+  const rustSem = rustIr.semantic;
+  const nodeSem = nodeIr.semantic;
+  if (!rustSem || rustSem.semantic_count !== nodeSem.semanticCount) {
+    details.push(`semanticCount \u4E0D\u4E00\u81F4\uFF08Node ${nodeSem.semanticCount} vs Rust ${rustSem?.semantic_count ?? "?"}\uFF09`);
+  }
+  if (!rustSem || rustSem.compat_count !== nodeSem.compatCount) {
+    details.push(`compatCount \u4E0D\u4E00\u81F4\uFF08Node ${nodeSem.compatCount} vs Rust ${rustSem?.compat_count ?? "?"}\uFF09`);
+  }
+  const nodeTreeNull = nodeIr.semantic.tree == null;
+  const rustTreeNull = rustSem == null || rustSem.tree == null;
+  if (rustTreeNull !== nodeTreeNull) {
+    details.push(`C-IR tree null \u4E0E\u5426\u4E0D\u4E00\u81F4\uFF08Node ${nodeTreeNull} vs Rust ${rustTreeNull}\uFF09`);
+  }
+  const rb = rustIr.bindings;
+  const nb = nodeIr.bindings;
+  if (!rb || JSON.stringify(rb.handlers?.map((h) => ({ name: normHandlerName(h.name), target: h.target })) ?? []) !== JSON.stringify(nb.handlers.map((h) => ({ name: normHandlerName(h.name), target: h.target })))) {
+    details.push("bindings.handlers \u4E0D\u4E00\u81F4");
+  }
+  if (!rb || JSON.stringify(rb.models ?? []) !== JSON.stringify(nb.models)) {
+    details.push("bindings.models \u4E0D\u4E00\u81F4");
+  }
+  if (!rb || JSON.stringify(rb.capabilities ?? []) !== JSON.stringify(nb.capabilities)) {
+    details.push("bindings.capabilities \u4E0D\u4E00\u81F4");
+  }
+  return details.length ? { status: "mismatch", details, reason: "ir-drift" } : { status: "ok", details: [] };
+}
+function runRustCli(bin, source) {
+  const tmp = path.join(os.tmpdir(), `proteus-dual-${Math.random().toString(36).slice(2)}.vue`);
+  fs.writeFileSync(tmp, source, "utf-8");
+  try {
+    return execFileSync(process.execPath, [bin, "compile", tmp], { encoding: "utf-8", timeout: 3e4 });
+  } finally {
+    fs.rmSync(tmp, { force: true });
+  }
+}
+function resolveRustCliBin(projectRoot) {
+  const explicit = process.env.PROTEUS_CC_RUST;
+  if (explicit && fs.existsSync(explicit)) return explicit;
+  try {
+    const pkgJson = require2.resolve("@proteus-vue/compiler-backend-rust/package.json", {
+      paths: [projectRoot, process.cwd()]
+    });
+    const bin = path.join(path.dirname(pkgJson), "bin", "cli.js");
+    return fs.existsSync(bin) ? bin : null;
+  } catch {
+    return null;
+  }
+}
+
+// src/g38.ts
+import { parse as sfcParse2 } from "@vue/compiler-sfc";
+import { parse as domParse2, NodeTypes as NodeTypes2 } from "@vue/compiler-dom";
+import { TAG_SEMANTIC_MAP as TAG_SEMANTIC_MAP3 } from "@proteus-vue/component-ir";
+
+// src/g38-session.ts
+function createG38IncrementalSession(backend, cacheDir, opts = {}) {
+  void cacheDir;
+  const sessionId = opts.id ?? "incr";
+  const tracked = /* @__PURE__ */ new Map();
+  const dependents = /* @__PURE__ */ new Map();
+  const invalidated = /* @__PURE__ */ new Set();
+  let committed = null;
+  let cacheHits = 0;
+  let recomputes = 0;
+  const regDeps = (file, deps) => {
+    for (const d of deps) {
+      if (!dependents.has(d)) dependents.set(d, /* @__PURE__ */ new Set());
+      dependents.get(d).add(file);
+    }
+  };
+  const trackFile = (file, content, deps = []) => {
+    const sig = g38Hash(`${content}|${backend.version}`);
+    const prev = tracked.get(file);
+    if (prev && prev.signature === sig) {
+      cacheHits++;
+      return;
+    }
+    recomputes++;
+    const ast = backend.parse({ content, path: file });
+    const moduleHash = ast.diagnostics?.length ? null : g38Hash(JSON.stringify(backend.transform(ast)));
+    if (prev) {
+      for (const d of prev.deps) {
+        const set = dependents.get(d);
+        if (set) {
+          set.delete(file);
+          if (!set.size) dependents.delete(d);
+        }
+      }
+    }
+    tracked.set(file, { signature: sig, content, deps, moduleHash });
+    regDeps(file, deps);
+    invalidated.delete(file);
+  };
+  const session = {
+    id: sessionId,
+    /** ★宿主驱动：注册文件内容 + 依赖（首次全量构建逐文件调用；同签名 → 缓存命中跳过重算） */
+    track: trackFile,
+    invalidate(file) {
+      invalidated.add(file);
+    },
+    invalidateAll() {
+      for (const f of tracked.keys()) invalidated.add(f);
+    },
+    /** ★局部重算：脏文件（+ 反向依赖闭包）re-track——无内容提供者时用已 track 内容比对签名 */
+    recompute() {
+      const changed = [];
+      const removed = [];
+      const added = [];
+      const affected = /* @__PURE__ */ new Set();
+      const dirty = invalidated.size ? [...invalidated] : [];
+      for (const file of dirty) {
+        let content = tracked.get(file)?.content ?? null;
+        if (opts.getContent) {
+          content = opts.getContent(file);
+          if (content == null) {
+            removed.push(file);
+            tracked.delete(file);
+            continue;
+          }
+        }
+        if (content == null) continue;
+        const sig = g38Hash(`${content}|${backend.version}`);
+        const prev = tracked.get(file);
+        if (prev && prev.signature === sig) {
+          cacheHits++;
+          invalidated.delete(file);
+          continue;
+        }
+        trackFile(file, content, prev?.deps ?? []);
+        changed.push(file);
+        affected.add(file);
+        const visitDependents = (f) => {
+          const set = dependents.get(f);
+          if (!set) return;
+          for (const dep of set) {
+            if (!affected.has(dep)) {
+              affected.add(dep);
+              changed.push(dep);
+              visitDependents(dep);
+            }
+          }
+        };
+        visitDependents(file);
+      }
+      invalidated.clear();
+      return { changed, removed, added, affectedFiles: [...affected] };
+    },
+    getDependencies(file) {
+      return [...tracked.get(file)?.deps ?? []];
+    },
+    getDependents(file) {
+      return [...dependents.get(file) ?? []];
+    },
+    commit() {
+      committed = {
+        tracked: new Map(tracked),
+        dependents: new Map([...dependents].map(([k, v]) => [k, new Set(v)]))
+      };
+    },
+    rollback() {
+      if (committed) {
+        tracked.clear();
+        dependents.clear();
+        for (const [f, t] of committed.tracked) tracked.set(f, { ...t, deps: [...t.deps] });
+        for (const [d, set] of committed.dependents) dependents.set(d, new Set(set));
+      } else {
+        tracked.clear();
+        dependents.clear();
+      }
+      invalidated.clear();
+    },
+    getStats() {
+      return { incremental: true, mode: "tracking", files: tracked.size, cacheHits, recomputes, hitRate: tracked.size ? Number((cacheHits / (cacheHits + recomputes) * 100).toFixed(1)) : 0 };
+    },
+    dispose() {
+      tracked.clear();
+      dependents.clear();
+      invalidated.clear();
+    }
+  };
+  return session;
+}
+function scanSfcImports(source) {
+  const script = source.includes("<script") ? source.match(/<script[^>]*>([\s\S]*?)<\/script>/i)?.[1] ?? "" : source;
+  const out = [];
+  for (const m of script.matchAll(/from\s+['"]([^'"]+)['"]/g)) {
+    if (m[1] && !m[1].startsWith("@proteus-vue/types")) out.push(m[1]);
+  }
+  return out;
+}
+
+// src/g38.ts
+function g38Hash(s) {
+  let h = 5381;
+  for (let i = 0; i < s.length; i++) h = (h << 5) + h + s.charCodeAt(i) >>> 0;
+  return h.toString(16).padStart(8, "0");
+}
+function camelize2(s) {
+  return s.replace(/-([a-z])/g, (_, c) => c.toUpperCase());
+}
+function exprContent2(exp) {
+  if (exp && typeof exp === "object" && "content" in exp && typeof exp.content === "string") {
+    return exp.content;
+  }
+  return null;
+}
+function flattenChildNodes2(children) {
+  const out = [];
+  for (const c of children) {
+    if (c.type === NodeTypes2.IF) {
+      const branches = c.branches ?? [];
+      for (const b of branches) out.push(...flattenChildNodes2(b.children));
+    } else if (c.type === NodeTypes2.FOR) {
+      out.push(...flattenChildNodes2(c.children));
+    } else {
+      out.push(c);
+    }
+  }
+  return out;
+}
+function elementToG38(el, diagnostics) {
+  const attributes = {};
+  for (const attr of el.props) {
+    if (attr.type === NodeTypes2.ATTRIBUTE) {
+      const a = attr;
+      if (a.name === "class" || a.name === "style" || a.name === "id" || a.name === "key" || a.name === "ref") continue;
+      attributes[a.name] = a.value?.content ?? true;
+      continue;
+    }
+    const d = attr;
+    const arg = d.arg && "content" in d.arg ? d.arg.content : void 0;
+    const exp = exprContent2(d.exp);
+    if (d.name === "bind") {
+      attributes[camelize2(arg ?? "")] = exp !== null ? { expr: exp } : true;
+    } else if (d.name === "model" || d.name === "on" || d.name === "slot") {
+      continue;
+    } else {
+      attributes[`v-${d.name}`] = exp !== null ? exp : true;
+    }
+  }
+  void diagnostics;
+  return {
+    kind: "element",
+    tag: el.tag,
+    attributes,
+    children: flattenChildNodes2(el.children).filter((c) => c.type === NodeTypes2.ELEMENT).map((c) => elementToG38(c, diagnostics)),
+    loc: { line: el.loc.start.line, column: el.loc.start.column }
+  };
+}
+function parseToProgram(source) {
+  const diagnostics = [];
+  let template = "";
+  const head = source.content.trimStart();
+  const looksLikeSfc = /^(?:<!--[\s\S]*?-->\s*)*<(?:template|script)\b/.test(head);
+  if (!looksLikeSfc) {
+    template = source.content;
+  } else {
+    try {
+      const { descriptor, errors } = sfcParse2(source.content, { filename: source.path ?? "anonymous.vue" });
+      for (const e of errors) {
+        diagnostics.push({ code: "sfc-parse", message: e.message, loc: { line: 0, column: 0 }, severity: "error" });
+      }
+      template = descriptor.template?.content ?? "";
+      if (!descriptor.template && (descriptor.script || descriptor.scriptSetup)) {
+        diagnostics.push({ code: "no-template", message: "SFC \u7F3A\u5C11 <template> \u5757", loc: { line: 0, column: 0 }, severity: "warning" });
+      }
+    } catch {
+      template = source.content;
+    }
+  }
+  const root = domParse2(template, {
+    onError: (e) => {
+      diagnostics.push({
+        code: `template-${e.code}`,
+        message: e.message,
+        loc: { line: e.loc?.start.line ?? 0, column: e.loc?.start.column ?? 0 },
+        severity: "error"
+      });
+    }
+  });
+  const nodes = flattenChildNodes2(root.children).filter((c) => c.type === NodeTypes2.ELEMENT).map((c) => elementToG38(c, diagnostics));
+  return { nodes, diagnostics };
+}
+function toComponentIRNode(el) {
+  if (!el.tag.startsWith("p-")) return null;
+  const semantic = TAG_SEMANTIC_MAP3[el.tag];
+  if (!semantic) return null;
+  const children = [];
+  for (const c of el.children) {
+    const ci = toComponentIRNode(c);
+    if (ci) children.push(ci);
+  }
+  const props = {};
+  for (const k of Object.keys(el.attributes)) {
+    if (k.startsWith("v-")) continue;
+    props[k] = el.attributes[k];
+  }
+  return { tag: el.tag, semantic, props, children };
+}
+function countComponentNodes(c) {
+  return 1 + c.children.reduce((n, ch) => n + countComponentNodes(ch), 0);
+}
+function createG38NodeBackend() {
+  let initialized = false;
+  const backend = {
+    id: "node",
+    version: "0.1.0",
+    capabilities: {
+      incremental: true,
+      // ★决策 #336：真增量会话（g38-session.ts——依赖图+签名缓存+局部重算）
+      aot: false,
+      sourceMap: false,
+      minify: false,
+      treeShake: false,
+      targetPlatforms: ["web"],
+      supportedLanguages: ["sfc", "vue"],
+      backend: "js",
+      deterministic: true
+    },
+    async initialize() {
+      initialized = true;
+    },
+    dispose() {
+      initialized = false;
+    },
+    parse(source, ctx) {
+      if (ctx?.filename?.endsWith(".tsx") || ctx?.filename?.endsWith(".jsx")) {
+        throw new Error(`G-38 parse\uFF1A\u4E0D\u652F\u6301\u8BED\u8A00 ${ctx.filename}\uFF08capabilities.supportedLanguages=['sfc','vue']\u2014\u2014TSX/JSX \u5C5E swc/oxc \u751F\u6001\u540E\u7AEF\uFF09`);
+      }
+      return parseToProgram(source);
+    },
+    transform(ast) {
+      const components = [];
+      const capabilities = [];
+      const collectCap = (c) => {
+        if (c.semantic.startsWith("capability.")) capabilities.push({ name: c.semantic.slice("capability.".length), semantic: c.semantic });
+        for (const ch of c.children) collectCap(ch);
+      };
+      const semanticOf = (tag) => tag.startsWith("p-") ? TAG_SEMANTIC_MAP3[tag] : void 0;
+      const collect = (el) => {
+        if (semanticOf(el.tag)) {
+          const ci = toComponentIRNode(el);
+          if (ci) {
+            components.push(ci);
+            collectCap(ci);
+          }
+          return;
+        }
+        for (const c of el.children) collect(c);
+      };
+      for (const el of ast.nodes) collect(el);
+      const countCompatOf = (el) => {
+        let n = semanticOf(el.tag) ? 0 : 1;
+        for (const c of el.children) n += countCompatOf(c);
+        return n;
+      };
+      const compatCount = ast.nodes.reduce((n, el) => n + countCompatOf(el), 0);
+      const semanticCount = components.reduce((n, c) => n + countComponentNodes(c), 0);
+      return {
+        id: `m-${ast.nodes.map((n) => n.tag).join("-") || "empty"}`,
+        imports: [],
+        components,
+        capabilities,
+        metadata: { semanticCount, compatCount, componentCount: components.length }
+      };
+    },
+    emit(module, ctx) {
+      const format = ctx?.format ?? "list";
+      let code;
+      if (format === "ir-json") {
+        code = JSON.stringify(module.components, null, 2);
+      } else if (format === "bundle") {
+        code = `/* proteus g38 bundle */
+${module.components.map((c) => `create('${c.semantic}')`).join("\n")}`;
+      } else {
+        code = module.components.map((c) => `\u251C\u2500 ${c.semantic}\uFF08${c.tag}\uFF09`).join("\n");
+      }
+      return { code, map: null, hash: g38Hash(code) };
+    },
+    createIncrementalSession(cacheDir, opts) {
+      return createG38IncrementalSession(backend, cacheDir, opts);
+    },
+    reportDiagnostics(module) {
+      void module;
+      return [];
+    },
+    getCacheKey(input) {
+      return g38Hash(`${input.content}|${backend.version}`);
+    },
+    getArtifactHash(artifact) {
+      return artifact.hash ?? g38Hash(artifact.code ?? "");
+    }
+  };
+  return backend;
+}
+
+// src/g38-fallback.ts
+async function defaultLoader(id) {
+  if (id === "node") return createG38NodeBackend();
+  return null;
+}
+async function createG38FallbackBackend(opts) {
+  const load = opts.load ?? defaultLoader;
+  const fallbackTo = opts.fallback ?? "node";
+  try {
+    const preferred = await load(opts.preferred);
+    if (preferred) {
+      return { backend: preferred, fallback: null, isDegraded: false };
+    }
+    const log = { from: opts.preferred, to: fallbackTo, reason: `preferred backend '${opts.preferred}' \u4E0D\u53EF\u7528\uFF08\u672A\u5B89\u88C5/\u672A\u63A5\u5165\uFF09` };
+    opts.onFallback?.(log);
+    return { backend: await load(fallbackTo) ?? createG38NodeBackend(), fallback: log, isDegraded: true };
+  } catch (e) {
+    const log = { from: opts.preferred, to: fallbackTo, reason: `preferred backend '${opts.preferred}' \u52A0\u8F7D\u5931\u8D25\uFF1A${e.message.slice(0, 120)}` };
+    opts.onFallback?.(log);
+    return { backend: createG38NodeBackend(), fallback: log, isDegraded: true };
+  }
+}
+
+// src/g38-conformance.ts
+function createG38TerminalBackend() {
+  const backend = {
+    id: "terminal",
+    version: "0.1.0",
+    capabilities: {
+      incremental: false,
+      aot: false,
+      sourceMap: false,
+      minify: false,
+      treeShake: false,
+      targetPlatforms: ["web"],
+      supportedLanguages: ["sfc"],
+      backend: "js",
+      deterministic: true
+    },
+    async initialize() {
+      backend._init = true;
+    },
+    dispose() {
+      backend._init = false;
+    },
+    parse(source) {
+      const nodes = [];
+      const re = /<(p-[a-z]+)([^>]*)>/g;
+      let m;
+      const content = source.content;
+      while ((m = re.exec(content)) !== null) {
+        nodes.push({ kind: "element", tag: m[1], loc: { line: 1, column: m.index } });
+      }
+      if (content.includes("<unclosed")) {
+        return { nodes: [], diagnostics: [{ code: "unclosed", message: "unclosed tag", loc: { line: 0, column: 0 }, severity: "error" }] };
+      }
+      return { nodes, diagnostics: [] };
+    },
+    transform(ast) {
+      if (ast.diagnostics?.length) return { id: "m-empty", imports: [], components: [], capabilities: [], metadata: { semanticCount: 0, compatCount: 0, componentCount: 0 } };
+      const map = { "p-grid": "layout.grid", "p-stack": "layout.stack", "p-scroll": "layout.scroll", "p-text": "ui.text", "p-button": "ui.button" };
+      const components = ast.nodes.map((n) => ({
+        tag: n.tag,
+        semantic: map[n.tag] ?? `unknown.${n.tag}`,
+        props: {},
+        children: []
+      }));
+      return { id: "m-term", imports: [], components, capabilities: [], metadata: { semanticCount: components.length, compatCount: 0, componentCount: components.length } };
+    },
+    emit(module) {
+      const code = module.components.map((c) => `\u251C\u2500 ${c.semantic}`).join("\n");
+      return { code, map: null, hash: g38Hash(code) };
+    },
+    createIncrementalSession() {
+      return {
+        id: "noop",
+        invalidate() {
+        },
+        invalidateAll() {
+        },
+        recompute() {
+          return { changed: [], removed: [], added: [], affectedFiles: [] };
+        },
+        getDependencies() {
+          return [];
+        },
+        getDependents() {
+          return [];
+        },
+        commit() {
+        },
+        rollback() {
+        },
+        getStats() {
+          return {};
+        },
+        dispose() {
+        }
+      };
+    },
+    reportDiagnostics() {
+      return [];
+    },
+    getCacheKey(source) {
+      return g38Hash(source.content);
+    },
+    getArtifactHash(artifact) {
+      return artifact.hash;
+    }
+  };
+  return backend;
+}
+var tests = [];
+var register = (group) => (id, fn) => tests.push({ id: `${group}-${id}`, group, fn });
+var C01 = register("C-01");
+var C02 = register("C-02");
+var C03 = register("C-03");
+var C04 = register("C-04");
+var C05 = register("C-05");
+var C06 = register("C-06");
+var C07 = register("C-07");
+var C08 = register("C-08");
+var C09 = register("C-09");
+var C10 = register("C-10");
+var REQUIRED = ["id", "version", "capabilities", "initialize", "dispose", "parse", "transform", "emit", "createIncrementalSession", "reportDiagnostics", "getCacheKey", "getArtifactHash"];
+C01("01", (b) => {
+  for (const m of REQUIRED) {
+    if (typeof b[m] === "undefined" && m !== "version") throw new Error(`missing ${m}`);
+  }
+});
+C01("02", (b) => {
+  if (typeof b.id !== "string" || !b.id) throw new Error("id");
+});
+C01("03", (b) => {
+  if (!b.capabilities || typeof b.capabilities !== "object") throw new Error("capabilities");
+});
+C01("04", (b) => {
+  for (const m of ["parse", "transform", "emit"]) {
+    if (typeof b[m] !== "function") throw new Error(`not fn: ${m}`);
+  }
+});
+C01("05", (b) => {
+  if (typeof b.createIncrementalSession !== "function") throw new Error("no session");
+});
+C01("06", (b) => {
+  b.reportDiagnostics({});
+  b.getCacheKey?.({ content: "" });
+  b.getArtifactHash?.({});
+});
+C02("01", async (b) => {
+  await b.initialize();
+  if (!b._init && b.id !== "node") throw new Error("not init");
+});
+C02("02", (b) => {
+  b.dispose();
+  if (b._init) throw new Error("not disposed");
+});
+C02("03", async (b) => {
+  await b.initialize();
+  await b.initialize();
+});
+C02("04", (b) => {
+  b.dispose();
+});
+C02("05", async (b) => {
+  await Promise.all([b.initialize(), b.initialize()]);
+});
+C03("01", (b) => {
+  const ir = b.parse({ content: "<p-grid><p-text></p-text></p-grid>" });
+  if (!ir.nodes.find((n) => n.tag === "p-grid")) throw new Error("no grid");
+});
+C03("02", (b) => {
+  const ir = b.parse({ content: "<p-stack></p-stack>" });
+  if (!ir.nodes.find((n) => n.tag === "p-stack")) throw new Error("no stack");
+});
+C03("03", (b) => {
+  const ir = b.parse({ content: "<unclosed" });
+  if (!ir.diagnostics?.length) throw new Error("should diagnose, not throw");
+});
+C03("04", (b) => {
+  const ir = b.parse({ content: "<p-grid></p-grid>" });
+  if (!ir.nodes[0].loc) throw new Error("no loc info");
+});
+C03("05", (b) => {
+  try {
+    b.parse({ content: "<p-unsupported-xxx></p-unsupported-xxx>" });
+  } catch (e) {
+    throw new Error("must diagnose, not throw");
+  }
+});
+C04("01", (b) => {
+  const ir = b.transform(b.parse({ content: "<p-grid></p-grid>" }));
+  if (ir.components[0]?.semantic !== "layout.grid") throw new Error("semantic");
+});
+C04("02", (b) => {
+  const ir = b.transform(b.parse({ content: '<p-stack snap="mandatory"></p-stack>' }));
+  if (ir.components[0]?.semantic !== "layout.stack") throw new Error("stack");
+});
+C04("03", (b) => {
+  const ir = b.transform(b.parse({ content: "<p-button></p-button>" }));
+  if (ir.components[0]?.semantic !== "ui.button") throw new Error("button");
+});
+C04("04", (b) => {
+  const ir = b.transform(b.parse({ content: "<p-grid></p-grid>" }));
+  if (!Object.prototype.hasOwnProperty.call(ir.components[0], "semantic")) throw new Error("no semantic field");
+});
+C04("05", (b) => {
+  const a = b.transform(b.parse({ content: "<p-text></p-text>" }));
+  const c = b.transform(b.parse({ content: "<p-text></p-text>" }));
+  if (JSON.stringify(a) !== JSON.stringify(c)) throw new Error("not deterministic in transform");
+});
+C04("06", (b) => {
+  const ir = b.transform(b.parse({ content: "<p-grid></p-grid>" }));
+  if (ir.components[0]?.semantic === "unknown.p-grid") throw new Error("should map");
+});
+C05("01", (b) => {
+  const m = b.transform(b.parse({ content: "<p-grid></p-grid>" }));
+  const a = b.emit(m);
+  if (!a.code) throw new Error("no code");
+});
+C05("02", (b) => {
+  if (!b.capabilities.sourceMap) return "SKIP";
+  const m = b.transform(b.parse({ content: "<p-grid></p-grid>" }));
+  const a = b.emit(m);
+  if (!a.map) throw new Error("no sourcemap");
+});
+C05("03", (b) => {
+  const m = b.transform(b.parse({ content: "<p-grid></p-grid>" }));
+  const a = b.emit(m);
+  if (!a.hash) throw new Error("no hash");
+});
+C05("04", (b) => {
+  if (!b.capabilities.treeShake) return "SKIP";
+});
+C05("05", (b) => {
+  const m = b.transform(b.parse({ content: "<p-grid></p-grid>" }));
+  const a1 = b.emit(m);
+  const a2 = b.emit(m);
+  if (a1.code !== a2.code) throw new Error("not deterministic emit");
+});
+C06("01", (b) => {
+  const s = b.createIncrementalSession("/tmp");
+  if (!s.id) throw new Error("no id");
+});
+C06("02", (b) => {
+  if (!b.capabilities.incremental) return "SKIP";
+  const s = b.createIncrementalSession("/tmp");
+  s.invalidate("a.sfc");
+  const diff = s.recompute();
+  if (!diff.affectedFiles) throw new Error("no diff");
+});
+C06("03", (b) => {
+  if (!b.capabilities.incremental) return "SKIP";
+  const s = b.createIncrementalSession("/tmp");
+  const k = s.getDependencies("a.sfc");
+  if (!Array.isArray(k)) throw new Error("no deps");
+});
+C06("04", (b) => {
+  if (!b.capabilities.incremental) return "SKIP";
+  const s = b.createIncrementalSession("/tmp");
+  s.invalidate("a.sfc");
+  s.recompute();
+  s.commit();
+});
+C06("05", (b) => {
+  if (!b.capabilities.incremental) return "SKIP";
+  const s = b.createIncrementalSession("/tmp");
+  s.rollback();
+});
+C07("01", (b) => {
+  if (b.id !== "node") return "SKIP";
+});
+C07("02", (b) => {
+  if (b.id !== "node") return "SKIP";
+});
+C07("03", (b) => {
+  const m = b.transform(b.parse({ content: "<p-grid></p-grid>" }));
+  const a = b.emit(m);
+  if (!a.code) throw new Error("no artifact");
+});
+C08("01", (b) => {
+  if (typeof b.benchmark !== "function") return "SKIP";
+});
+C08("02", (b) => {
+  if (b.id !== "rust") return "SKIP";
+});
+C08("03", (b) => {
+  if (b.id !== "wasm") return "SKIP";
+});
+C09("01", (b) => {
+  const m = b.transform(b.parse({ content: "<p-grid></p-grid>" }));
+  const h1 = b.getArtifactHash(b.emit(m));
+  const h2 = b.getArtifactHash(b.emit(m));
+  if (h1 !== h2) throw new Error(`not deterministic: ${h1} != ${h2}`);
+});
+C09("02", () => {
+  return "SKIP";
+});
+C10("01", (b) => {
+  const d = b.reportDiagnostics({});
+  if (!Array.isArray(d)) throw new Error("not array");
+});
+C10("02", (b) => {
+  const s = b.createIncrementalSession("/tmp");
+  if (typeof s.getStats !== "function") throw new Error("no stats");
+});
+async function runG38Conformance(backend, opts) {
+  const results = [];
+  await backend.initialize();
+  for (const t of tests) {
+    if (opts?.only && !t.group.startsWith(opts.only)) continue;
+    try {
+      const ret = await t.fn(backend);
+      results.push({ id: t.id, status: ret === "SKIP" ? "SKIP" : "PASS" });
+    } catch (e) {
+      results.push({ id: t.id, status: "FAIL", error: e.message });
+    }
+  }
+  backend.dispose();
+  return {
+    total: results.length,
+    pass: results.filter((r) => r.status === "PASS").length,
+    fail: results.filter((r) => r.status === "FAIL").length,
+    skip: results.filter((r) => r.status === "SKIP").length,
+    results
+  };
+}
+function formatG38Conformance(name, s) {
+  const lines = [`[${name} \u540E\u7AEF]`];
+  for (const r of s.results) {
+    const icon = r.status === "PASS" ? "\u2705" : r.status === "SKIP" ? "\u23ED\uFE0F " : "\u274C";
+    lines.push(`  ${icon} ${r.id}${r.status === "FAIL" ? ` \u2014 ${r.error ?? ""}` : ""}`);
+  }
+  lines.push("\u2500".repeat(30));
+  lines.push(`\u603B\u8BA1\uFF1APASS=${s.pass} FAIL=${s.fail} SKIP=${s.skip}\uFF08${s.total} \u9879 C-01~C-10\uFF09`);
+  return lines.join("\n");
+}
+export {
+  DEFAULT_CONFORMANCE_SFC,
+  createG38FallbackBackend,
+  createG38IncrementalSession,
+  createG38NodeBackend,
+  createG38TerminalBackend,
+  createNodeCompilerBackend,
+  formatG38Conformance,
+  g38Hash,
+  resolveRustCliBin,
+  runCompilerConformance,
+  runG38Conformance,
+  scanSfcImports,
+  verifyDualCompilerEquivalence
+};