@proteus-vue/render-backend 0.1.0

package/dist/index.js

@@ -0,0 +1,4291 @@
+// src/conformance.ts
+var LAYOUT_VALUES = ["yoga", "native", "none"];
+var GLASS_VALUES = ["L3", "L2", "L1", "none"];
+var BLUR_VALUES = ["true", "approximate", "none"];
+var ANIMATION_VALUES = ["native", "js", "none"];
+var INPUT_VALUES = ["touch", "cursor", "remote", "dial", "voice"];
+var REQUIRED_METHODS = ["createElement", "insert", "remove", "patchProp", "setText"];
+var OPTIONAL_METHODS = [
+  "querySelector",
+  "measure",
+  "layout",
+  "scheduleFrame",
+  "flush",
+  "dispatchInput",
+  "onMount",
+  "onUnmount",
+  "registerExternalTexture",
+  "unregisterExternalTexture"
+];
+function runBackendConformance(backend) {
+  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)}`);
+  for (const m of REQUIRED_METHODS) {
+    const fn = backend[m];
+    check(`method.${String(m)}`, typeof fn === "function", typeof fn === "function" ? void 0 : `\u7F3A\u5931\u65B9\u6CD5 ${String(m)}`);
+  }
+  let unique = true;
+  try {
+    const a = backend.createElement({ type: "view", props: {}, children: [] });
+    const b = backend.createElement({ type: "view", props: {}, children: [] });
+    unique = a !== b;
+  } catch (e) {
+    unique = false;
+    check("createElement.unique", false, "createElement \u629B\u9519: " + e.message);
+  }
+  if (!checks.some((c) => c.name === "createElement.unique")) {
+    check("createElement.unique", unique, unique ? void 0 : "\u4E24\u6B21\u8C03\u7528\u8FD4\u56DE\u76F8\u540C\u53E5\u67C4\uFF08\u975E\u552F\u4E00\uFF09");
+  }
+  const caps = backend.capabilities;
+  if (!caps) {
+    check("capabilities", false, "\u7F3A\u5931 capabilities \u58F0\u660E");
+  } else {
+    check("capabilities.layout", LAYOUT_VALUES.indexOf(caps.layout) >= 0, `layout=${String(caps.layout)}`);
+    check("capabilities.glass", GLASS_VALUES.indexOf(caps.glass) >= 0, `glass=${String(caps.glass)}`);
+    check("capabilities.blur", BLUR_VALUES.indexOf(caps.blur) >= 0, `blur=${String(caps.blur)}`);
+    check("capabilities.animation", ANIMATION_VALUES.indexOf(caps.animation) >= 0, `animation=${String(caps.animation)}`);
+    const badInput = (caps.input || []).filter((i) => INPUT_VALUES.indexOf(i) < 0);
+    check("capabilities.input", badInput.length === 0, badInput.length ? `\u975E\u6CD5 input \u7C7B\u578B: ${badInput.join(",")}` : void 0);
+  }
+  for (const m of OPTIONAL_METHODS) {
+    const fn = backend[m];
+    if (fn !== void 0 && fn !== null && typeof fn !== "function") {
+      check(`optional.${String(m)}`, false, `\u53EF\u9009\u65B9\u6CD5 ${String(m)} \u975E\u51FD\u6570`);
+    }
+  }
+  return { ok: checks.every((c) => c.pass), checks };
+}
+
+// src/headless.ts
+function toPlainTree(root) {
+  return {
+    id: root.id,
+    type: root.type,
+    props: { ...root.props },
+    text: root.text,
+    children: root.children.map(toPlainTree)
+  };
+}
+var SEMANTIC_HEADLESS_MAP = {
+  "layout.box": "box",
+  "layout.stack": "stack",
+  "layout.grid": "grid",
+  "layout.fluid": "fluid",
+  "layout.adaptive": "adaptive",
+  "layout.fit": "fit",
+  "layout.split": "split",
+  "layout.safe": "safe",
+  "layout.sidebar": "sidebar",
+  "ui.text": "text",
+  "ui.button": "button",
+  "ui.image": "image",
+  "ui.input": "input",
+  "ui.list": "list",
+  "ui.nav": "nav",
+  "capability.scan-qr": "scan-qr",
+  "capability.pick-photo": "pick-photo",
+  "capability.location": "location",
+  // ★G-32 B1：新增 implemented 语义（与 component-ir SEMANTIC_BACKEND_MAP headless 列同源）
+  "layout.inline": "inline",
+  "layout.spacer": "spacer",
+  "layout.divider": "divider",
+  "layout.scroll": "scroll",
+  "layout.virtual-list": "virtual-list",
+  "layout.masonry": "masonry",
+  "ui.heading": "heading",
+  "ui.icon": "icon",
+  "ui.textarea": "textarea",
+  "ui.switch": "switch",
+  "ui.slider": "slider",
+  "shell.nav": "nav",
+  "shell.tabbar": "tabbar",
+  "shell.drawer": "drawer",
+  "shell.modal": "modal",
+  // ★G-32 B4：Shell 补齐 + UI 补齐（与 SEMANTIC_BACKEND_MAP headless 列同源）
+  "shell.page": "page",
+  "shell.segment": "segment",
+  "shell.popover": "popover",
+  "shell.action-sheet": "action-sheet",
+  "ui.rich-text": "rich-text",
+  "ui.avatar": "avatar",
+  "ui.media": "media",
+  "ui.canvas": "canvas",
+  "ui.svg": "svg",
+  "ui.select": "select",
+  "ui.checkbox": "checkbox",
+  "ui.radio": "radio",
+  "ui.picker": "picker",
+  "ui.form": "form",
+  "gesture.draggable": "draggable",
+  "gesture.scrollable": "scrollable",
+  // ★G-32 B5 尾巴：E18 声明式导航（p-router-link）
+  "engineering.router-link": "router-link",
+  // ★G-32 B5 续二：工程原语动画组件形态（E19/E20）
+  "engineering.transition": "transition",
+  "engineering.animate": "animate"
+};
+var HEADLESS_CAPABILITIES = {
+  layout: "none",
+  // 框架 IR 求解（headless 无布局器）
+  glass: "none",
+  blur: "none",
+  animation: "js",
+  textureSharing: false,
+  remoteRendering: false,
+  ssr: true,
+  input: ["touch"]
+};
+function createHeadlessBackend() {
+  let nextId = 1;
+  const nodes = /* @__PURE__ */ new Map();
+  function ensureNode(handle) {
+    const n = handle;
+    if (!n || typeof n.id !== "number") throw new Error("HeadlessBackend: \u975E\u6CD5\u53E5\u67C4");
+    return n;
+  }
+  return {
+    id: "headless",
+    version: "0.1.0",
+    capabilities: HEADLESS_CAPABILITIES,
+    createElement(node) {
+      const viewType = node.semantic ? SEMANTIC_HEADLESS_MAP[node.semantic] ?? node.type : node.type;
+      const n = {
+        id: nextId++,
+        type: viewType,
+        props: { ...node.props },
+        children: [],
+        parent: null,
+        text: ""
+      };
+      nodes.set(n.id, n);
+      return n;
+    },
+    insert(child, parent, anchor) {
+      const c = ensureNode(child);
+      const p = ensureNode(parent);
+      if (c.parent) {
+        const oldIdx = c.parent.children.indexOf(c);
+        if (oldIdx >= 0) c.parent.children.splice(oldIdx, 1);
+      }
+      if (anchor) {
+        const a = ensureNode(anchor);
+        const idx = p.children.indexOf(a);
+        p.children.splice(idx >= 0 ? idx : p.children.length, 0, c);
+      } else {
+        p.children.push(c);
+      }
+      c.parent = p;
+    },
+    remove(child) {
+      const c = ensureNode(child);
+      if (c.parent) {
+        const idx = c.parent.children.indexOf(c);
+        if (idx >= 0) c.parent.children.splice(idx, 1);
+        c.parent = null;
+      }
+      nodes.delete(c.id);
+    },
+    patchProp(el, key, prev, next) {
+      const n = ensureNode(el);
+      if (next === null || next === void 0) {
+        delete n.props[key];
+      } else {
+        n.props[key] = next;
+      }
+    },
+    setText(el, text) {
+      ensureNode(el).text = text;
+    },
+    measure() {
+      return { width: 0, height: 0 };
+    }
+  };
+}
+
+// src/vue-dom.ts
+function defaultDocument() {
+  const g = globalThis;
+  if (g.document && typeof g.document.createElement === "function") {
+    return g.document;
+  }
+  throw new Error("VueDomBackend: \u65E0 document \u73AF\u5883\uFF08SSR/Node\u2014\u2014\u8BF7\u6CE8\u5165 documentLike \u6216\u6539\u7528 HeadlessBackend\uFF09");
+}
+var VUE_DOM_CAPABILITIES = {
+  layout: "native",
+  // 浏览器原生布局
+  glass: "L1",
+  // backdrop-filter（基础玻璃）
+  blur: "approximate",
+  animation: "js",
+  textureSharing: false,
+  remoteRendering: false,
+  ssr: false,
+  input: ["touch", "cursor"]
+};
+var SEMANTIC_WEB_MAP = {
+  "layout.box": { tag: "div", className: "proteus-box" },
+  "layout.stack": { tag: "div", className: "proteus-stack" },
+  "layout.grid": { tag: "div", className: "proteus-grid" },
+  "layout.fluid": { tag: "div", className: "proteus-fluid" },
+  "layout.adaptive": { tag: "div", className: "proteus-adaptive" },
+  "layout.fit": { tag: "div", className: "proteus-fit" },
+  "layout.split": { tag: "div", className: "proteus-split" },
+  "layout.safe": { tag: "div", className: "proteus-safe" },
+  "layout.sidebar": { tag: "div", className: "proteus-sidebar" },
+  "ui.text": { tag: "span" },
+  "ui.button": { tag: "button" },
+  "ui.image": { tag: "img" },
+  "ui.input": { tag: "input" },
+  "ui.list": { tag: "div", className: "proteus-list" },
+  "ui.nav": { tag: "nav" },
+  // ★G-31 B5：能力入口（G-28 组件化）——Web 端用标准元素承载，能力实现由 useNative 注入
+  "capability.scan-qr": { tag: "button", className: "proteus-scan-qr" },
+  "capability.pick-photo": { tag: "input", className: "proteus-pick-photo" },
+  "capability.location": { tag: "button", className: "proteus-location" },
+  // ★G-32 B1：新增 implemented 语义（与 component-ir SEMANTIC_BACKEND_MAP vue-dom 列同源）
+  "layout.inline": { tag: "div", className: "proteus-inline" },
+  "layout.spacer": { tag: "div", className: "proteus-spacer" },
+  "layout.divider": { tag: "hr", className: "proteus-divider" },
+  "layout.scroll": { tag: "div", className: "proteus-scroll" },
+  "layout.virtual-list": { tag: "div", className: "proteus-virtual-list" },
+  "layout.masonry": { tag: "div", className: "proteus-masonry" },
+  "ui.heading": { tag: "div", className: "proteus-heading" },
+  "ui.icon": { tag: "span", className: "proteus-icon" },
+  "ui.textarea": { tag: "textarea" },
+  "ui.switch": { tag: "div", className: "proteus-switch" },
+  "ui.slider": { tag: "div", className: "proteus-slider" },
+  "shell.nav": { tag: "nav", className: "proteus-nav" },
+  "shell.tabbar": { tag: "nav", className: "proteus-tabbar" },
+  "shell.drawer": { tag: "aside", className: "proteus-drawer" },
+  "shell.modal": { tag: "div", className: "proteus-modal" },
+  // ★G-32 B4：Shell 补齐 + UI 补齐（与 SEMANTIC_BACKEND_MAP vue-dom 列同源）
+  "shell.page": { tag: "div", className: "proteus-page" },
+  "shell.segment": { tag: "div", className: "proteus-segment" },
+  "shell.popover": { tag: "div", className: "proteus-popover" },
+  "shell.action-sheet": { tag: "div", className: "proteus-action-sheet" },
+  "ui.rich-text": { tag: "div", className: "proteus-rich-text" },
+  "ui.avatar": { tag: "div", className: "proteus-avatar" },
+  "ui.media": { tag: "div", className: "proteus-media" },
+  "ui.canvas": { tag: "canvas" },
+  "ui.svg": { tag: "svg" },
+  "ui.select": { tag: "div", className: "proteus-select" },
+  "ui.checkbox": { tag: "div", className: "proteus-checkbox" },
+  "ui.radio": { tag: "div", className: "proteus-radio" },
+  "ui.picker": { tag: "div", className: "proteus-picker" },
+  "ui.form": { tag: "form" },
+  // ★G-32 B4 ④ Gesture 组件形态
+  "gesture.draggable": { tag: "div", className: "proteus-draggable" },
+  "gesture.scrollable": { tag: "div", className: "proteus-scrollable" },
+  // ★G-32 B5 尾巴：E18 声明式导航（p-router-link——a 元素语义）
+  "engineering.router-link": { tag: "a", className: "proteus-router-link" },
+  // ★G-32 B5 续二：工程原语动画组件形态（E19/E20——纯 CSS 声明）
+  "engineering.transition": { tag: "div", className: "proteus-transition" },
+  "engineering.animate": { tag: "div", className: "proteus-animate" }
+};
+function createVueDomBackend(doc) {
+  const documentLike = doc ?? defaultDocument();
+  function ensureEl(handle) {
+    const el = handle;
+    if (!el || typeof el.tagName !== "string") throw new Error("VueDomBackend: \u975E\u6CD5\u53E5\u67C4");
+    return el;
+  }
+  return {
+    id: "vue-dom",
+    version: "0.1.0",
+    capabilities: VUE_DOM_CAPABILITIES,
+    createElement(node) {
+      if (node.semantic) {
+        const mapped = SEMANTIC_WEB_MAP[node.semantic];
+        if (mapped) {
+          const el = documentLike.createElement(mapped.tag);
+          if (mapped.className) el.setAttribute("class", mapped.className);
+          return el;
+        }
+      }
+      return documentLike.createElement(node.type);
+    },
+    insert(child, parent, anchor) {
+      const c = ensureEl(child);
+      const p = ensureEl(parent);
+      if (anchor) {
+        const a = ensureEl(anchor);
+        if (a.parentNode === p) {
+          p.insertBefore(c, a);
+          return;
+        }
+      }
+      p.appendChild(c);
+    },
+    remove(child) {
+      const c = ensureEl(child);
+      if (c.parentNode) c.parentNode.removeChild(c);
+    },
+    patchProp(el, key, prev, next) {
+      const target = ensureEl(el);
+      if (key.startsWith("on") && key.length > 2) {
+        const eventName = key.slice(2).toLowerCase();
+        if (typeof next === "function") {
+          if (prev !== next) target.addEventListener(eventName, next);
+        } else {
+          target.removeEventListener(eventName, prev);
+        }
+        return;
+      }
+      if (key === "style" && next && typeof next === "object") {
+        const style = next;
+        for (const k of Object.keys(style)) {
+          ;
+          target.style[k] = style[k];
+        }
+        return;
+      }
+      if (next === null || next === void 0) {
+        target.removeAttribute(key);
+      } else {
+        target.setAttribute(key, String(next));
+      }
+    },
+    setText(el, text) {
+      ensureEl(el).textContent = text;
+    },
+    measure(node, constraints) {
+      const el = ensureEl(node);
+      const w = constraints?.width ?? el.clientWidth ?? 0;
+      const h = constraints?.height ?? el.clientHeight ?? 0;
+      return { width: w, height: h };
+    }
+  };
+}
+
+// src/native.ts
+function createMockNativeAdapter() {
+  const ops = [];
+  return {
+    ops,
+    createView(descriptor) {
+      ops.push(`create:${descriptor.type}`);
+      return descriptor;
+    },
+    updateView(_handle, key, _prev, next) {
+      ops.push(`update:${key}=${String(next)}`);
+    },
+    insertView(child, _parent, _anchor) {
+      ops.push(`insert:${String(child.type)}`);
+    },
+    removeView(child) {
+      ops.push(`remove:${String(child.type)}`);
+    },
+    setViewText(_handle, text) {
+      ops.push(`setText:${text}`);
+    }
+  };
+}
+var NATIVE_CAPABILITIES = {
+  layout: "native",
+  // 原生布局（AutoLayout / ConstraintLayout / ArkUI 约束）
+  glass: "L3",
+  // iOS UIGlassEffect / 鸿蒙 fractal（G-07 系统级玻璃语义）
+  blur: "true",
+  animation: "native",
+  // 系统原生转场/动画
+  textureSharing: true,
+  // PlatformView / TextureView 混合
+  remoteRendering: false,
+  ssr: false,
+  input: ["touch", "cursor", "remote"]
+};
+var SEMANTIC_NATIVE_MAPS = {
+  ios: {
+    "layout.box": "UIView",
+    "layout.stack": "UIStackView",
+    "layout.grid": "UICollectionView",
+    "layout.fluid": "UIView.fluid",
+    "layout.adaptive": "UISheet",
+    "layout.fit": "UIView.fit",
+    "layout.split": "UISplitViewController",
+    "layout.safe": "safeAreaLayoutGuide",
+    "layout.sidebar": "UISplitViewController.side",
+    "ui.text": "UILabel",
+    "ui.button": "UIButton",
+    "ui.image": "UIImageView",
+    "ui.input": "UITextField",
+    "ui.list": "UITableView",
+    "ui.nav": "UINavigationController",
+    "capability.scan-qr": "AVCaptureSession",
+    "capability.pick-photo": "UIImagePicker",
+    "capability.location": "CLLocationManager",
+    // ★G-32 B1：新增 implemented 语义
+    "layout.inline": "UITextAttachment",
+    "layout.spacer": "UILayoutGuide",
+    "layout.divider": "UIView.divider",
+    "layout.scroll": "UIScrollView",
+    "layout.virtual-list": "UICollectionView",
+    "layout.masonry": "UICollectionView.masonry",
+    "ui.heading": "UILabel.heading",
+    "ui.icon": "UIImageView.icon",
+    "ui.textarea": "UITextView",
+    "ui.switch": "UISwitch",
+    "ui.slider": "UISlider",
+    "shell.nav": "UINavigationBar",
+    "shell.tabbar": "UITabBar",
+    "shell.drawer": "UIView.drawer",
+    "shell.modal": "UIAlertController",
+    // ★G-32 B4：Shell 补齐 + UI 补齐
+    "shell.page": "UIViewController",
+    "shell.segment": "UISegmentedControl",
+    "shell.popover": "UIPopoverController",
+    "shell.action-sheet": "UIAlertController.actionSheet",
+    "ui.rich-text": "UITextView.attributed",
+    "ui.avatar": "UIImageView.avatar",
+    "ui.media": "AVPlayerView",
+    "ui.canvas": "UIView.canvas",
+    "ui.svg": "UIView.svg",
+    "ui.select": "UIPickerView",
+    "ui.checkbox": "UIButton.checkbox",
+    "ui.radio": "UIButton.radio",
+    "ui.picker": "UIDatePicker",
+    "ui.form": "UIView.form",
+    "gesture.draggable": "UIPanGestureRecognizer",
+    "gesture.scrollable": "UIScrollView.gesture",
+    // ★G-32 B5 尾巴：E18 声明式导航（p-router-link）
+    "engineering.router-link": "UIButton.link",
+    // ★G-32 B5 续二：工程原语动画组件形态（E19/E20）
+    "engineering.transition": "UIView.transition",
+    "engineering.animate": "CAKeyframeAnimation"
+  },
+  android: {
+    "layout.box": "FrameLayout",
+    "layout.stack": "LinearLayout",
+    "layout.grid": "GridLayoutManager",
+    "layout.fluid": "ConstraintLayout",
+    "layout.adaptive": "BottomSheetDialog",
+    "layout.fit": "wrapContent",
+    "layout.split": "SlidingPaneLayout",
+    "layout.safe": "WindowInsets",
+    "layout.sidebar": "NavigationRail",
+    "ui.text": "TextView",
+    "ui.button": "Button",
+    "ui.image": "ImageView",
+    "ui.input": "EditText",
+    "ui.list": "RecyclerView",
+    "ui.nav": "NavigationRail",
+    "capability.scan-qr": "CameraX",
+    "capability.pick-photo": "PhotoPicker",
+    "capability.location": "FusedLocation",
+    // ★G-32 B1：新增 implemented 语义
+    "layout.inline": "TextView.inline",
+    "layout.spacer": "Space",
+    "layout.divider": "View.divider",
+    "layout.scroll": "ScrollView",
+    "layout.virtual-list": "RecyclerView",
+    "layout.masonry": "StaggeredGridLayoutManager",
+    "ui.heading": "TextView.heading",
+    "ui.icon": "ImageView.icon",
+    "ui.textarea": "EditText.multiline",
+    "ui.switch": "Switch",
+    "ui.slider": "SeekBar",
+    "shell.nav": "Toolbar",
+    "shell.tabbar": "BottomNavigationView",
+    "shell.drawer": "DrawerLayout",
+    "shell.modal": "Dialog",
+    // ★G-32 B4：Shell 补齐 + UI 补齐
+    "shell.page": "Activity",
+    "shell.segment": "TabLayout",
+    "shell.popover": "PopupWindow",
+    "shell.action-sheet": "BottomSheet",
+    "ui.rich-text": "TextView.html",
+    "ui.avatar": "ImageView.avatar",
+    "ui.media": "VideoView",
+    "ui.canvas": "SurfaceView",
+    "ui.svg": "VectorDrawable",
+    "ui.select": "Spinner",
+    "ui.checkbox": "CheckBox",
+    "ui.radio": "RadioButton",
+    "ui.picker": "DatePicker",
+    "ui.form": "LinearLayout.form",
+    "gesture.draggable": "GestureDetector",
+    "gesture.scrollable": "NestedScrollView",
+    // ★G-32 B5 尾巴：E18 声明式导航（p-router-link）
+    "engineering.router-link": "TextView.link",
+    // ★G-32 B5 续二：工程原语动画组件形态（E19/E20）
+    "engineering.transition": "View.animate.transition",
+    "engineering.animate": "ValueAnimator"
+  },
+  harmony: {
+    "layout.box": "Stack",
+    "layout.stack": "Flex",
+    "layout.grid": "Grid",
+    "layout.fluid": "Flex.fluid",
+    "layout.adaptive": "Sheet",
+    "layout.fit": "fitContent",
+    "layout.split": "SideBarContainer",
+    "layout.safe": "getAvoidArea",
+    "layout.sidebar": "SideBarContainer",
+    "ui.text": "Text",
+    "ui.button": "Button",
+    "ui.image": "Image",
+    "ui.input": "TextInput",
+    "ui.list": "List",
+    "ui.nav": "Navigation",
+    "capability.scan-qr": "ScanKit",
+    "capability.pick-photo": "PhotoViewPicker",
+    "capability.location": "geoLocationManager",
+    // ★G-32 B1：新增 implemented 语义
+    "layout.inline": "Span",
+    "layout.spacer": "Blank",
+    "layout.divider": "Divider",
+    "layout.scroll": "Scroll",
+    "layout.virtual-list": "List",
+    "layout.masonry": "WaterFlow",
+    "ui.heading": "Text.heading",
+    "ui.icon": "SymbolGlyph",
+    "ui.textarea": "TextArea",
+    "ui.switch": "Toggle",
+    "ui.slider": "Slider",
+    "shell.nav": "NavigationBar",
+    "shell.tabbar": "Tabs",
+    "shell.drawer": "Panel",
+    "shell.modal": "CustomDialog",
+    // ★G-32 B4：Shell 补齐 + UI 补齐
+    "shell.page": "Page",
+    "shell.segment": "Segmented",
+    "shell.popover": "Popup",
+    "shell.action-sheet": "ActionSheet",
+    "ui.rich-text": "RichText",
+    "ui.avatar": "Image.avatar",
+    "ui.media": "Video",
+    "ui.canvas": "Canvas",
+    "ui.svg": "Shape",
+    "ui.select": "Select",
+    "ui.checkbox": "Checkbox",
+    "ui.radio": "Radio",
+    "ui.picker": "DatePicker",
+    "ui.form": "FormComponent",
+    "gesture.draggable": "PanGesture",
+    "gesture.scrollable": "Scroll.gesture",
+    // ★G-32 B5 尾巴：E18 声明式导航（p-router-link）
+    "engineering.router-link": "Text.link",
+    // ★G-32 B5 续二：工程原语动画组件形态（E19/E20）
+    "engineering.transition": "animateTo.transition",
+    "engineering.animate": "Animator.transition"
+  }
+};
+function createNativeBackend(adapter, platform = "ios") {
+  const viewAdapter = adapter ?? createMockNativeAdapter();
+  const semanticMap = SEMANTIC_NATIVE_MAPS[platform];
+  const id = platform === "ios" ? "native-ios" : platform === "android" ? "native-android" : "native-harmony";
+  let nextId = 1;
+  const nodes = /* @__PURE__ */ new Map();
+  function ensureNode(handle) {
+    const n = handle;
+    if (!n || typeof n.id !== "number") throw new Error("NativeBackend: \u975E\u6CD5\u53E5\u67C4");
+    return n;
+  }
+  return {
+    id,
+    version: "0.1.0",
+    capabilities: NATIVE_CAPABILITIES,
+    createElement(node) {
+      const viewType = node.semantic ? semanticMap[node.semantic] ?? node.type : node.type;
+      const descriptor = {
+        id: nextId++,
+        type: viewType,
+        props: { ...node.props },
+        children: [],
+        parent: null,
+        text: "",
+        handle: null
+      };
+      descriptor.handle = viewAdapter.createView(descriptor);
+      nodes.set(descriptor.id, descriptor);
+      return descriptor;
+    },
+    insert(child, parent, anchor) {
+      const c = ensureNode(child);
+      const p = ensureNode(parent);
+      if (c.parent) {
+        const oldIdx = c.parent.children.indexOf(c);
+        if (oldIdx >= 0) c.parent.children.splice(oldIdx, 1);
+      }
+      if (anchor) {
+        const a = ensureNode(anchor);
+        const idx = p.children.indexOf(a);
+        p.children.splice(idx >= 0 ? idx : p.children.length, 0, c);
+      } else {
+        p.children.push(c);
+      }
+      c.parent = p;
+      viewAdapter.insertView(c.handle, p.handle, anchor ? ensureNode(anchor).handle : void 0);
+    },
+    remove(child) {
+      const c = ensureNode(child);
+      if (c.parent) {
+        const idx = c.parent.children.indexOf(c);
+        if (idx >= 0) c.parent.children.splice(idx, 1);
+        c.parent = null;
+      }
+      nodes.delete(c.id);
+      viewAdapter.removeView(c.handle);
+    },
+    patchProp(el, key, prev, next) {
+      const n = ensureNode(el);
+      if (next === null || next === void 0) {
+        delete n.props[key];
+      } else {
+        n.props[key] = next;
+      }
+      viewAdapter.updateView(n.handle, key, prev, next);
+    },
+    setText(el, text) {
+      const n = ensureNode(el);
+      n.text = text;
+      viewAdapter.setViewText(n.handle, text);
+    },
+    measure() {
+      return { width: 0, height: 0 };
+    }
+  };
+}
+
+// src/flutter.ts
+var WIDGET_MAP = {
+  view: "Container",
+  text: "Text",
+  button: "FilledButton",
+  image: "Image",
+  input: "TextField",
+  textarea: "TextField",
+  "scroll-view": "SingleChildScrollView",
+  switch: "Switch",
+  slider: "Slider",
+  icon: "Icon",
+  progress: "LinearProgressIndicator",
+  navigator: "GestureDetector",
+  "p-grid": "Wrap",
+  "p-stack": "Flex",
+  "p-split": "Row"
+};
+var SEMANTIC_FLUTTER_MAP = {
+  "layout.box": "Container",
+  "layout.stack": "Flex",
+  "layout.grid": "GridView",
+  "layout.fluid": "Wrap",
+  "layout.adaptive": "showModal",
+  "layout.fit": "IntrinsicWidth",
+  "layout.split": "Row",
+  "layout.safe": "SafeArea",
+  "layout.sidebar": "NavigationRail",
+  "ui.text": "Text",
+  "ui.button": "FilledButton",
+  "ui.image": "Image",
+  "ui.input": "TextField",
+  "ui.list": "ListView",
+  "ui.nav": "Navigator",
+  "capability.scan-qr": "scanQR",
+  "capability.pick-photo": "pickPhoto",
+  "capability.location": "getLocation",
+  // ★G-32 B1：新增 implemented 语义
+  "layout.inline": "InlineSpan",
+  "layout.spacer": "Spacer",
+  "layout.divider": "Divider",
+  "layout.scroll": "ScrollView",
+  "layout.virtual-list": "ListView",
+  "layout.masonry": "SliverMasonryGrid",
+  "ui.heading": "Text.heading",
+  "ui.icon": "Icon",
+  "ui.textarea": "TextField.multiline",
+  "ui.switch": "Switch",
+  "ui.slider": "Slider",
+  "shell.nav": "AppBar",
+  "shell.tabbar": "BottomNavigationBar",
+  "shell.drawer": "Drawer",
+  "shell.modal": "showDialog",
+  // ★G-32 B4：Shell 补齐 + UI 补齐
+  "shell.page": "Scaffold",
+  "shell.segment": "SegmentedButton",
+  "shell.popover": "showMenu",
+  "shell.action-sheet": "showModalBottomSheet",
+  "ui.rich-text": "RichText",
+  "ui.avatar": "CircleAvatar",
+  "ui.media": "VideoPlayer",
+  "ui.canvas": "CustomPaint",
+  "ui.svg": "SvgPicture",
+  "ui.select": "DropdownButton",
+  "ui.checkbox": "Checkbox",
+  "ui.radio": "Radio",
+  "ui.picker": "showDatePicker",
+  "ui.form": "Form",
+  "gesture.draggable": "Draggable",
+  "gesture.scrollable": "Scrollable",
+  // ★G-32 B5 尾巴：E18 声明式导航（p-router-link）
+  "engineering.router-link": "TextButton",
+  // ★G-32 B5 续二：工程原语动画组件形态（E19/E20）
+  "engineering.transition": "AnimatedOpacity",
+  "engineering.animate": "AnimationController"
+};
+function mapWidgetType(type) {
+  return WIDGET_MAP[type] ?? type;
+}
+function toWidgetTree(root) {
+  return {
+    id: root.id,
+    widget: root.widget,
+    props: { ...root.props },
+    text: root.text,
+    children: root.children.map(toWidgetTree)
+  };
+}
+var FLUTTER_CAPABILITIES = {
+  layout: "yoga",
+  // Flutter 自带布局引擎（Yoga/C++——后端可选，spike 标注）
+  glass: "L3",
+  // Skia/Impeller 绘制玻璃（系统级渲染语义）
+  blur: "true",
+  animation: "native",
+  // Flutter 动画管线
+  textureSharing: true,
+  // Texture/PlatformView 混合
+  remoteRendering: false,
+  ssr: false,
+  input: ["touch", "cursor", "remote"]
+};
+function createFlutterBackend() {
+  let nextId = 1;
+  const nodes = /* @__PURE__ */ new Map();
+  function ensureNode(handle) {
+    const n = handle;
+    if (!n || typeof n.id !== "number") throw new Error("FlutterBackend: \u975E\u6CD5\u53E5\u67C4");
+    return n;
+  }
+  return {
+    id: "flutter",
+    version: "0.1.0",
+    capabilities: FLUTTER_CAPABILITIES,
+    createElement(node) {
+      const widget = node.semantic ? SEMANTIC_FLUTTER_MAP[node.semantic] ?? mapWidgetType(node.type) : mapWidgetType(node.type);
+      const descriptor = {
+        id: nextId++,
+        widget,
+        props: { ...node.props },
+        children: [],
+        parent: null,
+        text: ""
+      };
+      nodes.set(descriptor.id, descriptor);
+      return descriptor;
+    },
+    insert(child, parent, anchor) {
+      const c = ensureNode(child);
+      const p = ensureNode(parent);
+      if (c.parent) {
+        const oldIdx = c.parent.children.indexOf(c);
+        if (oldIdx >= 0) c.parent.children.splice(oldIdx, 1);
+      }
+      if (anchor) {
+        const a = ensureNode(anchor);
+        const idx = p.children.indexOf(a);
+        p.children.splice(idx >= 0 ? idx : p.children.length, 0, c);
+      } else {
+        p.children.push(c);
+      }
+      c.parent = p;
+    },
+    remove(child) {
+      const c = ensureNode(child);
+      if (c.parent) {
+        const idx = c.parent.children.indexOf(c);
+        if (idx >= 0) c.parent.children.splice(idx, 1);
+        c.parent = null;
+      }
+      nodes.delete(c.id);
+    },
+    patchProp(el, key, prev, next) {
+      const n = ensureNode(el);
+      if (next === null || next === void 0) {
+        delete n.props[key];
+      } else {
+        n.props[key] = next;
+      }
+    },
+    setText(el, text) {
+      ensureNode(el).text = text;
+    },
+    measure() {
+      return { width: 0, height: 0 };
+    }
+  };
+}
+
+// src/conformance-component.ts
+function createControlReader(backendId) {
+  switch (backendId) {
+    case "vue-dom":
+      return (h) => {
+        const el = h;
+        const cls = el.getAttribute?.("class") ?? "";
+        return el.tagName.toLowerCase() + (cls ? "." + cls : "");
+      };
+    case "native-ios":
+    case "native-android":
+    case "native-harmony":
+      return (h) => h.type;
+    case "flutter":
+      return (h) => h.widget;
+    case "headless":
+      return (h) => h.type;
+    default:
+      return (h) => String(h?.type ?? h);
+  }
+}
+function renderComponentSnapshot(backend, ir, readControl) {
+  const snapOf = /* @__PURE__ */ new Map();
+  function visit(node) {
+    const handle = backend.createElement(node);
+    for (const key of Object.keys(node.props)) {
+      backend.patchProp(handle, key, void 0, node.props[key]);
+    }
+    const snap = {
+      type: node.type,
+      semantic: node.semantic ?? node.type,
+      control: readControl(handle),
+      props: { ...node.props },
+      text: "",
+      children: []
+    };
+    snapOf.set(handle, snap);
+    for (const child of node.children) {
+      const childHandle = visit(child);
+      backend.insert(childHandle, handle);
+      const childSnap = snapOf.get(childHandle);
+      if (childSnap) snap.children.push(childSnap);
+    }
+    return handle;
+  }
+  const rootHandle = visit(ir);
+  return snapOf.get(rootHandle);
+}
+
+// src/hybrid.ts
+function createHybridRenderer(options) {
+  const { defaultBackend } = options;
+  const regions = options.regions ?? [];
+  const devtools = options.devtools !== false;
+  const nodeBackend = /* @__PURE__ */ new WeakMap();
+  const traceList = [];
+  function routeFor(node) {
+    for (const r of regions) {
+      if (r.match(node)) return r.backend;
+    }
+    return defaultBackend;
+  }
+  function regionName(node) {
+    for (const r of regions) {
+      if (r.match(node)) return r.name ?? "region";
+    }
+    return "default";
+  }
+  function backendOf(handle) {
+    if (typeof handle !== "object" || handle === null) return void 0;
+    return nodeBackend.get(handle)?.backend;
+  }
+  function textureBackends() {
+    const sharing = regions.map((r) => r.backend).concat([defaultBackend]).filter((b) => b.capabilities.textureSharing === true);
+    return sharing.length ? sharing : [defaultBackend];
+  }
+  const defaultId = "hybrid";
+  const hybrid = {
+    id: defaultId,
+    version: "0.1.0",
+    capabilities: {
+      layout: "none",
+      // 无自带布局器——委托各后端（框架 IR 求解）
+      glass: "L1",
+      blur: "none",
+      animation: "js",
+      textureSharing: true,
+      remoteRendering: false,
+      ssr: true,
+      input: ["touch", "cursor", "remote"]
+    },
+    createElement(node) {
+      const backend = routeFor(node);
+      const handle = backend.createElement(node);
+      if (typeof handle === "object" && handle !== null) {
+        nodeBackend.set(handle, { backend, region: regionName(node) });
+      }
+      if (devtools) {
+        traceList.push({ semantic: node.semantic, type: node.type, backendId: backend.id, region: regionName(node) });
+      }
+      return handle;
+    },
+    insert(child, parent, anchor) {
+      const b = backendOf(child);
+      if (!b) return;
+      b.insert(child, parent, anchor);
+    },
+    remove(child) {
+      const b = backendOf(child);
+      if (b) b.remove(child);
+    },
+    patchProp(el, key, prev, next) {
+      const b = backendOf(el);
+      if (b) b.patchProp(el, key, prev, next);
+    },
+    setText(el, text) {
+      const b = backendOf(el);
+      if (b) b.setText(el, text);
+    },
+    // —— 可选方法：委托归属后端（存在时） ——
+    querySelector(selector) {
+      return defaultBackend.querySelector ? defaultBackend.querySelector(selector) : null;
+    },
+    measure(node, constraints) {
+      const b = backendOf(node);
+      if (b && b.measure) return b.measure(node, constraints);
+      return { width: 0, height: 0 };
+    },
+    layout(root, constraints) {
+      const b = backendOf(root);
+      if (b && b.layout) b.layout(root, constraints);
+    },
+    scheduleFrame(task) {
+      defaultBackend.scheduleFrame ? defaultBackend.scheduleFrame(task) : task();
+    },
+    flush() {
+      defaultBackend.flush ? defaultBackend.flush() : void 0;
+    },
+    dispatchInput(event) {
+      const b = backendOf(event.target);
+      if (b && b.dispatchInput) b.dispatchInput(event);
+    },
+    onMount(root) {
+      const b = backendOf(root);
+      if (b && b.onMount) b.onMount(root);
+    },
+    onUnmount(root) {
+      const b = backendOf(root);
+      if (b && b.onUnmount) b.onUnmount(root);
+    },
+    // —— ★B6 纹理共享：广播注册/注销（跨后端全局 id） ——
+    registerExternalTexture(id, texture) {
+      for (const b of textureBackends()) {
+        if (b.registerExternalTexture) b.registerExternalTexture(id, texture);
+      }
+    },
+    unregisterExternalTexture(id) {
+      for (const b of textureBackends()) {
+        if (b.unregisterExternalTexture) b.unregisterExternalTexture(id);
+      }
+    },
+    // —— 混合专属 ——
+    routeFor,
+    backendOf,
+    traces: () => traceList.slice(),
+    clearTraces: () => {
+      traceList.length = 0;
+    }
+  };
+  return hybrid;
+}
+function textureRef(textureId) {
+  return { textureId };
+}
+function runHybridConformance(renderer) {
+  const checks = [];
+  function check(name, pass, detail) {
+    checks.push({ name, pass, detail });
+  }
+  check("id", typeof renderer.id === "string" && renderer.id.length > 0, `id=${String(renderer.id)}`);
+  check("method.createElement", typeof renderer.createElement === "function");
+  check("method.insert", typeof renderer.insert === "function");
+  check("method.remove", typeof renderer.remove === "function");
+  check("method.patchProp", typeof renderer.patchProp === "function");
+  check("method.setText", typeof renderer.setText === "function");
+  const probe = { type: "p-box", semantic: "layout.box", props: {}, children: [] };
+  const routed = renderer.routeFor(probe);
+  check("route.default-non-null", routed !== void 0 && routed !== null);
+  const handle = renderer.createElement(probe);
+  const owned = renderer.backendOf(handle);
+  check("route.backendOf-owned", owned !== void 0, "createElement \u540E backendOf \u5E94\u6709\u5F52\u5C5E");
+  if (owned) check("route.consistent", owned === routed, "routeFor \u4E0E backendOf \u5E94\u4E00\u81F4");
+  check("optional.registerExternalTexture", typeof renderer.registerExternalTexture === "function");
+  check("optional.unregisterExternalTexture", typeof renderer.unregisterExternalTexture === "function");
+  check("devtools.trace-recorded", renderer.traces().length > 0, `traces=${renderer.traces().length}`);
+  return { ok: checks.every((c) => c.pass), checks };
+}
+
+// ../component-ir/dist/index.js
+var TAG_SEMANTIC_MAP = {
+  // G-32 ① 布局原语（12）
+  "p-box": "layout.box",
+  "p-inline": "layout.inline",
+  "p-stack": "layout.stack",
+  "p-grid": "layout.grid",
+  "p-fluid": "layout.fluid",
+  "p-adaptive": "layout.adaptive",
+  "p-fit": "layout.fit",
+  "p-spacer": "layout.spacer",
+  "p-divider": "layout.divider",
+  "p-scroll": "layout.scroll",
+  "p-virtual-list": "layout.virtual-list",
+  "p-masonry": "layout.masonry",
+  // G-32 ② UI 原语（18）
+  "p-text": "ui.text",
+  "p-heading": "ui.heading",
+  "p-rich-text": "ui.rich-text",
+  "p-icon": "ui.icon",
+  "p-image": "ui.image",
+  "p-avatar": "ui.avatar",
+  "p-media": "ui.media",
+  "p-canvas": "ui.canvas",
+  "p-svg": "ui.svg",
+  "p-input": "ui.input",
+  "p-textarea": "ui.textarea",
+  "p-select": "ui.select",
+  "p-checkbox": "ui.checkbox",
+  "p-radio": "ui.radio",
+  "p-switch": "ui.switch",
+  "p-slider": "ui.slider",
+  "p-picker": "ui.picker",
+  "p-form": "ui.form",
+  "p-button": "ui.button",
+  // 既有按钮
+  // G-32 ③ Shell 原语（10）
+  "p-page": "shell.page",
+  "p-nav": "shell.nav",
+  "p-tabbar": "shell.tabbar",
+  "p-segment": "shell.segment",
+  "p-drawer": "shell.drawer",
+  "p-modal": "shell.modal",
+  "p-popover": "shell.popover",
+  "p-toast": "shell.toast",
+  "p-action-sheet": "shell.action-sheet",
+  "p-split": "layout.split",
+  // ★已落地绑定（G-32 S10 分栏语义——layout.split 承载）
+  // G-32 ④ Gesture 组件形态（2）
+  "p-draggable": "gesture.draggable",
+  "p-scrollable": "gesture.scrollable",
+  // G-32 ⑥ Engineering 组件形态（3）
+  "p-router-link": "engineering.router-link",
+  // ★E18 组件形态（p- 前缀产 C-IR）
+  "router-link": "engineering.router-link",
+  // ★兼容别名（Vue Router 风格 <router-link> 标签；非 catalog 条目——p-view 先例 G-31 B4）
+  "p-transition": "engineering.transition",
+  "p-animate": "engineering.animate",
+  // G-31 能力入口
+  "p-scan-qr": "capability.scan-qr",
+  "p-pick-photo": "capability.pick-photo",
+  "p-location": "capability.location",
+  // ★G-31 B4 现有组件对齐（src/components 实际标签 → L1 语义）
+  "p-view": "layout.box",
+  // 原子容器 = p-box 角色
+  "p-list-view": "ui.list",
+  "p-nav-bar": "ui.nav",
+  // ★G-31 B4 Fluid 体系扩展语义（有明确系统原生对应——原则 #10.8）
+  "p-safe": "layout.safe",
+  "p-sidebar": "layout.sidebar"
+};
+function toComponentIR(tag, props = {}, children = []) {
+  if (!tag.startsWith("p-")) return null;
+  const semantic = TAG_SEMANTIC_MAP[tag];
+  if (!semantic) return null;
+  return { tag, semantic, props: { ...props }, children };
+}
+var LAYOUT = [
+  { id: "L1", kind: "layout", semantic: "layout.box", tag: "p-box", props: ["aspectRatio", "overflow"], mpEquiv: "<view>", tier: "L1", status: "implemented" },
+  { id: "L2", kind: "layout", semantic: "layout.inline", tag: "p-inline", props: ["wrap"], mpEquiv: "<text> \u5185\u8054", tier: "L1", status: "implemented" },
+  { id: "L3", kind: "layout", semantic: "layout.stack", tag: "p-stack", props: ["direction", "gap", "align", "wrap", "snap", "loop"], mpEquiv: "flex + scroll-view + swiper", tier: "L1", status: "implemented" },
+  { id: "L4", kind: "layout", semantic: "layout.grid", tag: "p-grid", props: ["minColWidth", "maxCols", "gap", "autoFlow"], mpEquiv: "<view> + CSS Grid", tier: "L1", status: "implemented" },
+  { id: "L5", kind: "layout", semantic: "layout.fluid", tag: "p-fluid", props: ["breakpoints", "minItemWidth"], mpEquiv: "\u54CD\u5E94\u5F0F CSS", tier: "L1", status: "implemented" },
+  { id: "L6", kind: "layout", semantic: "layout.adaptive", tag: "p-adaptive", props: ["sheet", "dialog", "popover", "drawer"], mpEquiv: "\u65E0\uFF08\u5BB9\u5668\u5BBD\u5EA6\u8BED\u4E49\u65AD\u70B9\uFF09", tier: "L1", status: "implemented" },
+  { id: "L7", kind: "layout", semantic: "layout.fit", tag: "p-fit", props: ["mode"], mpEquiv: "fit-content", tier: "L1", status: "implemented" },
+  { id: "L8", kind: "layout", semantic: "layout.spacer", tag: "p-spacer", props: ["grow", "shrink"], mpEquiv: "flex:1", tier: "L1", status: "implemented" },
+  { id: "L9", kind: "layout", semantic: "layout.divider", tag: "p-divider", props: ["orientation", "inset"], mpEquiv: "<view> + border", tier: "L1", status: "implemented" },
+  { id: "L10", kind: "layout", semantic: "layout.scroll", tag: "p-scroll", props: ["axis", "paging", "refresh", "indicator"], mpEquiv: "<scroll-view>", tier: "L1", status: "implemented" },
+  { id: "L11", kind: "layout", semantic: "layout.virtual-list", tag: "p-virtual-list", props: ["itemSize", "buffer", "direction"], mpEquiv: "<scroll-view> + \u624B\u52A8\u56DE\u6536", tier: "L1", status: "implemented" },
+  { id: "L12", kind: "layout", semantic: "layout.masonry", tag: "p-masonry", props: ["colCount", "gap"], mpEquiv: "\u7B2C\u4E09\u65B9\u7011\u5E03\u6D41", tier: "L1", status: "implemented" }
+];
+var UI = [
+  { id: "U1", kind: "ui", semantic: "ui.text", tag: "p-text", props: ["content", "selectable", "truncate", "align"], mpEquiv: "<text>", tier: "L1", status: "implemented" },
+  { id: "U2", kind: "ui", semantic: "ui.heading", tag: "p-heading", props: ["level"], mpEquiv: "<h1>-<h6>", tier: "L1", status: "implemented" },
+  { id: "U3", kind: "ui", semantic: "ui.rich-text", tag: "p-rich-text", props: ["source", "schema"], mpEquiv: "<rich-text>", tier: "L1", status: "implemented" },
+  { id: "U4", kind: "ui", semantic: "ui.icon", tag: "p-icon", props: ["name", "size", "color", "spin"], mpEquiv: "<icon>", tier: "L1", status: "implemented" },
+  { id: "U5", kind: "ui", semantic: "ui.image", tag: "p-image", props: ["src", "fit", "placeholder", "lazy"], mpEquiv: "<image>", tier: "L1", status: "implemented" },
+  { id: "U6", kind: "ui", semantic: "ui.avatar", tag: "p-avatar", props: ["src", "shape", "size", "fallback"], mpEquiv: "\u7EC4\u5408", tier: "L1", status: "implemented" },
+  { id: "U7", kind: "ui", semantic: "ui.media", tag: "p-media", props: ["kind", "controls", "autoplay", "poster", "loop", "muted", "pictureInPicture"], mpEquiv: "<video>+<audio>", tier: "L1", status: "implemented" },
+  { id: "U8", kind: "ui", semantic: "ui.canvas", tag: "p-canvas", props: ["engine", "resolution"], mpEquiv: "<canvas>", tier: "L1", status: "implemented" },
+  { id: "U9", kind: "ui", semantic: "ui.svg", tag: "p-svg", props: ["path", "viewbox"], mpEquiv: "\u65E0", tier: "L1", status: "implemented" },
+  { id: "U10", kind: "ui", semantic: "ui.input", tag: "p-input", props: ["type", "mask", "validation", "clearable"], mpEquiv: "<input>", tier: "L1", status: "implemented" },
+  { id: "U11", kind: "ui", semantic: "ui.textarea", tag: "p-textarea", props: ["autosize", "maxLength", "count"], mpEquiv: "<textarea>", tier: "L1", status: "implemented" },
+  { id: "U12", kind: "ui", semantic: "ui.select", tag: "p-select", props: ["options", "multiple", "searchable", "cascader"], mpEquiv: "<picker> \u90E8\u5206", tier: "L1", status: "implemented" },
+  { id: "U13", kind: "ui", semantic: "ui.checkbox", tag: "p-checkbox", props: ["checked", "indeterminate", "group"], mpEquiv: "<checkbox>", tier: "L1", status: "implemented" },
+  { id: "U14", kind: "ui", semantic: "ui.radio", tag: "p-radio", props: ["value", "group"], mpEquiv: "<radio>", tier: "L1", status: "implemented" },
+  { id: "U15", kind: "ui", semantic: "ui.switch", tag: "p-switch", props: ["checked", "loading"], mpEquiv: "<switch>", tier: "L1", status: "implemented" },
+  { id: "U16", kind: "ui", semantic: "ui.slider", tag: "p-slider", props: ["min", "max", "step", "range"], mpEquiv: "<slider>", tier: "L1", status: "implemented" },
+  { id: "U17", kind: "ui", semantic: "ui.picker", tag: "p-picker", props: ["mode", "start", "end"], mpEquiv: "<picker>", tier: "L1", status: "implemented" },
+  { id: "U18", kind: "ui", semantic: "ui.form", tag: "p-form", props: ["model", "rules", "layout"], mpEquiv: "\u7EC4\u5408", tier: "L1", status: "implemented" }
+];
+var SHELL = [
+  { id: "S1", kind: "shell", semantic: "shell.page", tag: "p-page", props: ["title", "statusBar", "pullRefresh"], mpEquiv: "<page>", tier: "L1", status: "implemented" },
+  { id: "S2", kind: "shell", semantic: "shell.nav", tag: "p-nav", props: ["title", "transparent"], mpEquiv: "\u5BFC\u822A\u680F\u914D\u7F6E", tier: "L1", status: "implemented" },
+  { id: "S3", kind: "shell", semantic: "shell.tabbar", tag: "p-tabbar", props: ["tabs", "active", "badge"], mpEquiv: "<tabbar>", tier: "L1", status: "implemented" },
+  { id: "S4", kind: "shell", semantic: "shell.segment", tag: "p-segment", props: ["options", "active"], mpEquiv: "<segment>", tier: "L1", status: "implemented" },
+  { id: "S5", kind: "shell", semantic: "shell.drawer", tag: "p-drawer", props: ["side", "width", "overlay"], mpEquiv: "\u7EC4\u5408", tier: "L1", status: "implemented" },
+  { id: "S6", kind: "shell", semantic: "shell.modal", tag: "p-modal", props: ["open", "dismissible", "sheet", "dialog", "alert"], mpEquiv: "<modal>+wx.showModal", tier: "L1", status: "implemented" },
+  { id: "S7", kind: "shell", semantic: "shell.popover", tag: "p-popover", props: ["trigger", "placement"], mpEquiv: "\u7EC4\u5408", tier: "L1", status: "implemented" },
+  { id: "S8", kind: "shell", semantic: "shell.toast", tag: "p-toast", props: ["message", "duration", "type"], mpEquiv: "wx.showToast", tier: "L1", status: "planned" },
+  { id: "S9", kind: "shell", semantic: "shell.action-sheet", tag: "p-action-sheet", props: ["actions", "cancel"], mpEquiv: "wx.showActionSheet", tier: "L1", status: "implemented" },
+  { id: "S10", kind: "shell", semantic: "layout.split", tag: "p-split", props: ["breakpoint", "ratio", "collapse"], mpEquiv: "\u65E0\uFF08\u5206\u680F\u5E03\u5C40\uFF09", tier: "L1", status: "implemented" }
+  // ★已落地绑定：分栏语义由 layout.split 承载（G-32 文档为 shell.split——机器事实以实现为准）
+];
+var GESTURE = [
+  { id: "G1", kind: "gesture", semantic: "gesture.tap", api: "v-gesture:tap", props: ["count"], mpEquiv: "bindtap", tier: "L1", status: "planned" },
+  { id: "G2", kind: "gesture", semantic: "gesture.longpress", api: "v-gesture:longpress", props: ["duration", "onEnd"], mpEquiv: "bindlongpress", tier: "L1", status: "planned" },
+  { id: "G3", kind: "gesture", semantic: "gesture.swipe", api: "v-gesture:swipe", props: ["direction", "threshold"], mpEquiv: "bindswipe", tier: "L1", status: "planned" },
+  { id: "G4", kind: "gesture", semantic: "gesture.pan", api: "v-gesture:pan", props: ["axis", "bounds"], mpEquiv: "bindtouchmove", tier: "L1", status: "planned" },
+  { id: "G5", kind: "gesture", semantic: "gesture.pinch", api: "v-gesture:pinch", props: ["scale", "onChange"], mpEquiv: "touchstart/move \u7EC4\u5408", tier: "L1", status: "planned" },
+  { id: "G6", kind: "gesture", semantic: "gesture.rotate", api: "v-gesture:rotate", props: ["angle"], mpEquiv: "\u7EC4\u5408", tier: "L1", status: "planned" },
+  { id: "G7", kind: "gesture", semantic: "gesture.press", api: "v-gesture:press", props: ["force"], mpEquiv: "3D Touch", tier: "L1", status: "planned" },
+  { id: "G8", kind: "gesture", semantic: "gesture.draggable", tag: "p-draggable", props: ["ghost", "snapToGrid", "onDrop"], mpEquiv: "movable-view", tier: "L1", status: "implemented" },
+  { id: "G9", kind: "gesture", semantic: "gesture.scrollable", tag: "p-scrollable", props: ["bounce", "refresh", "loadMore"], mpEquiv: "<scroll-view>", tier: "L1", status: "implemented" },
+  { id: "G10", kind: "gesture", semantic: "gesture.use-gesture", api: "useGesture()", props: ["recognizers", "simultaneous"], mpEquiv: "\u65E0", tier: "L1", status: "planned" }
+];
+function cap(id, name, api, mpEquiv, returnType) {
+  return { id, kind: "capability", semantic: `capability.${name}`, api, props: [returnType], mpEquiv, tier: "L1", status: "planned" };
+}
+var CAPABILITY = [
+  // 7.1 设备/硬件（15）
+  cap("C1", "camera", "useCamera()", "wx.createCameraContext", "Result<Media>"),
+  cap("C2", "microphone", "useMicrophone()", "RecorderManager", "Result<AudioBuffer>"),
+  { id: "C3", kind: "capability", semantic: "capability.location", api: "useLocation()", props: ["Result<Coords>"], mpEquiv: "wx.getLocation", tier: "L1", status: "implemented" },
+  cap("C4", "map", "useMap()", "wx.createMapContext", "MapController"),
+  cap("C5", "sensor", "useSensor()", "onAccelerometer/onCompass/onGyroscope", "SensorStream"),
+  cap("C6", "vibrate", "useVibrate()", "wx.vibrateShort/Long", "void"),
+  cap("C7", "battery", "useBattery()", "wx.getBatteryInfo", "BatteryInfo"),
+  cap("C8", "network", "useNetwork()", "wx.getNetworkType", "NetworkType"),
+  cap("C9", "clipboard", "useClipboard()", "wx.set/getClipboardData", "Result<string>"),
+  cap("C10", "screen", "useScreen()", "wx.getSystemInfo", "ScreenInfo"),
+  cap("C11", "device", "useDevice()", "wx.getSystemInfo", "DeviceInfo"),
+  cap("C12", "orientation", "useOrientation()", "wx.onDeviceOrientationChange", "Orientation"),
+  cap("C13", "brightness", "useBrightness()", "wx.setScreenBrightness", "Result<void>"),
+  cap("C14", "keyboard", "useKeyboard()", "wx.onKeyboardHeightChange", "KeyboardInfo"),
+  cap("C15", "storage", "useStorage()", "wx.set/getStorage", "StorageAPI"),
+  // 7.2 系统/OS（10）
+  cap("C16", "permission", "usePermission()", "wx.authorize", "Result<PermissionStatus>"),
+  cap("C17", "notification", "useNotification()", "wx.requestSubscribeMessage", "NotificationAPI"),
+  cap("C18", "share", "useShare()", "wx.shareAppMessage", "Result<void>"),
+  cap("C19", "contact", "useContact()", "wx.chooseContact", "Result<Contact[]>"),
+  cap("C20", "calendar", "useCalendar()", "wx.addPhoneCalendar", "CalendarAPI"),
+  cap("C21", "phone-call", "usePhoneCall()", "wx.makePhoneCall", "Result<void>"),
+  cap("C22", "sms", "useSMS()", "wx.??\uFF08\u53D7\u9650\uFF09", "Result<void>"),
+  cap("C23", "app-lifecycle", "useAppLifecycle()", "App.onLaunch/onShow", "LifecycleHooks"),
+  cap("C24", "page-lifecycle", "usePageLifecycle()", "Page.onLoad/onShow", "LifecycleHooks"),
+  cap("C25", "background", "useBackground()", "wx.onBackground", "BackgroundAPI"),
+  // 7.3 通信/数据（10）
+  cap("C26", "fetch", "useFetch()", "wx.request", "Promise<T>"),
+  cap("C27", "websocket", "useWebSocket()", "wx.connectSocket", "WSConnection"),
+  cap("C28", "socket-task", "useSocketTask()", "wx.SocketTask", "SocketTask"),
+  cap("C29", "upload", "useUpload()", "wx.uploadFile", "Progress<Result>"),
+  cap("C30", "download", "useDownload()", "wx.downloadFile", "Progress<Result>"),
+  cap("C31", "data-channel", "useDataChannel()", "wx...\uFF08\u76F4\u64AD/\u5B9E\u65F6\uFF09", "Channel"),
+  cap("C32", "cookie", "useCookie()", "\u65E0", "CookieJar"),
+  cap("C33", "auth", "useAuth()", "\u7EC4\u5408", "AuthState"),
+  cap("C34", "analytics", "useAnalytics()", "wx.reportEvent", "TrackAPI"),
+  cap("C35", "log", "useLog()", "console + \u4E0A\u62A5", "Logger"),
+  // 7.4 扩展能力（10）
+  cap("C36", "bluetooth", "useBluetooth()", "wx.openBluetoothAdapter", "BluetoothAPI"),
+  cap("C37", "nfc", "useNFC()", "wx.getHCEState", "NFCAPI"),
+  cap("C38", "biometric", "useBiometric()", "wx.checkIsSupportFingerPrint", "Result<boolean>"),
+  cap("C39", "face-id", "useFaceID()", "\u7EC4\u5408", "Result<boolean>"),
+  cap("C40", "payment", "usePayment()", "wx.requestPayment", "Result<PayResult>"),
+  cap("C41", "login", "useLogin()", "wx.login", "Result<Token>"),
+  cap("C42", "qr-code", "useQRCode()", "wx.scanCode + canvas", "Result<string>"),
+  cap("C43", "file-system", "useFileSystem()", "wx.getFileSystemManager", "FSAdapter"),
+  cap("C44", "archive", "useArchive()", "wx.compressFile", "Result<void>"),
+  cap("C45", "shortcut", "useShortcut()", "wx.addToDesktop", "Result<void>"),
+  cap("C46", "in-app-purchase", "useInAppPurchase()", "wx.requestPayment \u6269\u5C55", "Result<Receipt>"),
+  // 7.5 平台特有（4——C47-C50，此前 7.4 末 C46，总 50）
+  { id: "C47", kind: "capability", semantic: "capability.mini-program", api: "useMiniProgram()", props: ["MPContext"], mpEquiv: "wx.navigateToMiniProgram", tier: "L1", status: "planned" },
+  { id: "C48", kind: "capability", semantic: "capability.embedded", api: "useEmbedded()", props: ["HostContext"], mpEquiv: "\u65E0\uFF08\u88AB\u5BBF\u4E3B\u5D4C\u5165\uFF09", tier: "L1", status: "planned" },
+  { id: "C49", kind: "capability", semantic: "capability.live", api: "useLive()", props: ["LiveRoom"], mpEquiv: "wx...\uFF08\u76F4\u64AD\u7EC4\u4EF6\uFF09", tier: "L1", status: "planned" },
+  { id: "C50", kind: "capability", semantic: "capability.extension", api: "useExtension()", props: ["ExtensionAPI"], mpEquiv: "\u65E0\uFF08\u63D2\u4EF6/\u6269\u5C55\u70B9 G-21\uFF09", tier: "L1", status: "planned" }
+];
+var ENGINEERING = [
+  { id: "E1", kind: "engineering", semantic: "engineering.state", api: "useState()", mpEquiv: "data", tier: "L1", status: "planned" },
+  { id: "E2", kind: "engineering", semantic: "engineering.computed", api: "useComputed()", mpEquiv: "computed", tier: "L1", status: "planned" },
+  { id: "E3", kind: "engineering", semantic: "engineering.watch", api: "useWatch()", mpEquiv: "watch", tier: "L1", status: "planned" },
+  { id: "E4", kind: "engineering", semantic: "engineering.store", api: "useStore()", mpEquiv: "getApp().globalData", tier: "L1", status: "planned" },
+  { id: "E5", kind: "engineering", semantic: "engineering.provide-inject", api: "useProvide()/useInject()", mpEquiv: "\u65E0", tier: "L1", status: "planned" },
+  { id: "E6", kind: "engineering", semantic: "engineering.lifecycle", api: "useLifecycle()", mpEquiv: "onLoad/onShow/onHide/onUnload", tier: "L1", status: "planned" },
+  { id: "E7", kind: "engineering", semantic: "engineering.ready", api: "useReady()", mpEquiv: "onReady", tier: "L1", status: "planned" },
+  { id: "E8", kind: "engineering", semantic: "engineering.error-boundary", api: "useErrorBoundary()", mpEquiv: "onError", tier: "L1", status: "planned" },
+  { id: "E9", kind: "engineering", semantic: "engineering.page-param", api: "usePageParam()", mpEquiv: "onLoad(options)", tier: "L1", status: "planned" },
+  { id: "E10", kind: "engineering", semantic: "engineering.route", api: "useRoute()", mpEquiv: "getCurrentPages()", tier: "L1", status: "planned" },
+  { id: "E11", kind: "engineering", semantic: "engineering.router-push", api: "router.push()", mpEquiv: "wx.navigateTo", tier: "L1", status: "planned" },
+  { id: "E12", kind: "engineering", semantic: "engineering.router-replace", api: "router.replace()", mpEquiv: "wx.redirectTo", tier: "L1", status: "planned" },
+  { id: "E13", kind: "engineering", semantic: "engineering.router-back", api: "router.back()", mpEquiv: "wx.navigateBack", tier: "L1", status: "planned" },
+  { id: "E14", kind: "engineering", semantic: "engineering.router-switch-tab", api: "router.switchTab()", mpEquiv: "wx.switchTab", tier: "L1", status: "planned" },
+  { id: "E15", kind: "engineering", semantic: "engineering.router-relaunch", api: "router.reLaunch()", mpEquiv: "wx.reLaunch", tier: "L1", status: "planned" },
+  { id: "E16", kind: "engineering", semantic: "engineering.router-before-each", api: "router.beforeEach()", mpEquiv: "onLaunch \u624B\u52A8", tier: "L1", status: "planned" },
+  { id: "E17", kind: "engineering", semantic: "engineering.router-after-each", api: "router.afterEach()", mpEquiv: "\u65E0", tier: "L1", status: "planned" },
+  { id: "E18", kind: "engineering", semantic: "engineering.router-link", tag: "p-router-link", props: ["to", "replace", "switchTab"], mpEquiv: "<navigator>", tier: "L1", status: "implemented" },
+  { id: "E19", kind: "engineering", semantic: "engineering.transition", tag: "p-transition", props: ["name", "mode"], mpEquiv: "transition CSS", tier: "L1", status: "implemented" },
+  { id: "E20", kind: "engineering", semantic: "engineering.animate", tag: "p-animate", props: ["keyframes", "duration"], mpEquiv: "animation CSS", tier: "L1", status: "implemented" },
+  { id: "E21", kind: "engineering", semantic: "engineering.animation", api: "useAnimation()", mpEquiv: "wx.createAnimation", tier: "L1", status: "planned" },
+  { id: "E22", kind: "engineering", semantic: "engineering.gesture-animation", api: "useGestureAnimation()", mpEquiv: "\u7EC4\u5408", tier: "L1", status: "planned" },
+  { id: "E23", kind: "engineering", semantic: "engineering.scroll-animation", api: "useScrollAnimation()", mpEquiv: "\u7EC4\u5408", tier: "L1", status: "planned" },
+  { id: "E24", kind: "engineering", semantic: "engineering.devtools", api: "useDevTools()", mpEquiv: "\u5C0F\u7A0B\u5E8F DevTools", tier: "L1", status: "planned" },
+  { id: "E25", kind: "engineering", semantic: "engineering.inspector", api: "useInspector()", mpEquiv: "\u65E0", tier: "L1", status: "planned" },
+  { id: "E26", kind: "engineering", semantic: "engineering.performance", api: "usePerformance()", mpEquiv: "wx.reportPerformance", tier: "L1", status: "planned" },
+  { id: "E27", kind: "engineering", semantic: "engineering.define-component", api: "defineComponent()", mpEquiv: "Component()", tier: "L1", status: "planned" },
+  { id: "E28", kind: "engineering", semantic: "engineering.define-capability", api: "defineCapability()", mpEquiv: "\u65E0", tier: "L1", status: "planned" }
+];
+var PRIMITIVE_CATALOG = [...LAYOUT, ...UI, ...SHELL, ...GESTURE, ...CAPABILITY, ...ENGINEERING];
+var MP_COMPONENTS = [
+  { mp: "<view>", proteus: "layout.box / layout.stack", status: "ok", group: "component" },
+  { mp: "<text>", proteus: "ui.text / ui.heading", status: "ok", group: "component" },
+  { mp: "<image>", proteus: "ui.image", status: "ok", group: "component" },
+  { mp: "<scroll-view>", proteus: "layout.scroll / layout.virtual-list", status: "ok", group: "component" },
+  { mp: "<swiper>", proteus: "layout.stack snap/loop\uFF08\u6D88\u706D\u4E3A\u5C5E\u6027\uFF09", status: "ok", group: "component" },
+  { mp: "<swiper-item>", proteus: "layout.stack \u5B50\u9879", status: "ok", group: "component" },
+  { mp: "<movable-area>", proteus: "gesture.scrollable \u5BB9\u5668", status: "ok", group: "component" },
+  { mp: "<movable-view>", proteus: "gesture.draggable", status: "ok", group: "component" },
+  { mp: "<cover-view>", proteus: "p-overlay (L2)", status: "compat", group: "component" },
+  { mp: "<cover-image>", proteus: "p-overlay + ui.image", status: "compat", group: "component" },
+  { mp: "<icon>", proteus: "ui.icon", status: "ok", group: "component" },
+  { mp: "<progress>", proteus: "p-progress (L2)", status: "compat", group: "component" },
+  { mp: "<rich-text>", proteus: "ui.rich-text", status: "ok", group: "component" },
+  { mp: "<button>", proteus: "ui.button", status: "ok", group: "component" },
+  { mp: "<form>", proteus: "ui.form", status: "ok", group: "component" },
+  { mp: "<input>", proteus: "ui.input", status: "ok", group: "component" },
+  { mp: "<textarea>", proteus: "ui.textarea", status: "ok", group: "component" },
+  { mp: "<checkbox>", proteus: "ui.checkbox", status: "ok", group: "component" },
+  { mp: "<radio>", proteus: "ui.radio", status: "ok", group: "component" },
+  { mp: "<picker>", proteus: "ui.picker / ui.select", status: "ok", group: "component" },
+  { mp: "<picker-view>", proteus: "ui.picker mode=wheel", status: "ok", group: "component" },
+  { mp: "<slider>", proteus: "ui.slider", status: "ok", group: "component" },
+  { mp: "<switch>", proteus: "ui.switch", status: "ok", group: "component" },
+  { mp: "<label>", proteus: "p-label (L2)", status: "compat", group: "component" },
+  { mp: "<navigator>", proteus: "engineering.router-link / router.*", status: "ok", group: "component" },
+  { mp: "<audio>", proteus: "ui.media kind=audio\uFF08\u6D88\u706D\u4E3A\u5C5E\u6027\uFF09", status: "ok", group: "component" },
+  { mp: "<video>", proteus: "ui.media kind=video\uFF08\u6D88\u706D\u4E3A\u5C5E\u6027\uFF09", status: "ok", group: "component" },
+  { mp: "<camera>", proteus: "p-camera (L2) + capability.camera", status: "ok", group: "component" },
+  { mp: "<live-player>", proteus: "ui.media kind=live\uFF08\u6D88\u706D\u4E3A\u5C5E\u6027\uFF09", status: "ok", group: "component" },
+  { mp: "<live-pusher>", proteus: "ui.media kind=live mode=push", status: "ok", group: "component" },
+  { mp: "<canvas>", proteus: "ui.canvas", status: "ok", group: "component" },
+  { mp: "<map>", proteus: "p-map (L2) + capability.map", status: "ok", group: "component" },
+  { mp: "<web-view>", proteus: "p-webview (L2)", status: "compat", group: "component" },
+  { mp: "<editor>", proteus: "ui.rich-text editable", status: "ok", group: "component" },
+  { mp: "<ad>", proteus: "p-ad (L2)", status: "compat", group: "component" },
+  { mp: "<official-account>", proteus: "capability.mini-program\uFF08\u5FAE\u4FE1\u79C1\u6709\uFF09", status: "private", group: "component" },
+  { mp: "<open-data>", proteus: "capability.mini-program\uFF08\u5FAE\u4FE1\u79C1\u6709\uFF09", status: "private", group: "component" },
+  { mp: "<share-element>", proteus: "p-share-element (L2)", status: "compat", group: "component" },
+  { mp: "<aria-component>", proteus: "p-aria (L2)", status: "compat", group: "component" },
+  { mp: "<page-container>", proteus: "p-page-container (L2)", status: "compat", group: "component" },
+  { mp: "<voip-room>", proteus: "capability.mini-program\uFF08\u5FAE\u4FE1 VOIP\uFF09", status: "private", group: "component" },
+  { mp: "<guild-room>", proteus: "capability.mini-program\uFF08\u5FAE\u4FE1\u6E38\u620F\uFF09", status: "private", group: "component" }
+];
+var MP_API_GROUPS = [
+  { mp: "wx.request/upload/download/websocket\uFF08\u7F51\u7EDC\uFF09", proteus: "capability.fetch/upload/download/websocket", status: "ok", group: "api" },
+  { mp: "wx.requestPayment", proteus: "capability.payment", status: "ok", group: "api" },
+  { mp: "wx.chooseImage/chooseMedia/previewImage\uFF08\u5A92\u4F53\uFF09", proteus: "capability.camera + ui.image preview", status: "ok", group: "api" },
+  { mp: "wx.startRecord/RecorderManager\uFF08\u5F55\u97F3\uFF09", proteus: "capability.microphone", status: "ok", group: "api" },
+  { mp: "wx.createVideoContext/CameraContext", proteus: "capability.media + ui.media", status: "ok", group: "api" },
+  { mp: "wx.scanCode", proteus: "capability.qr-code / capability.scan-qr", status: "ok", group: "api" },
+  { mp: "wx.saveImageToPhotosAlbum", proteus: "capability.album (L2)", status: "compat", group: "api" },
+  { mp: "wx.getFileSystemManager/*\uFF08\u6587\u4EF6 30+\uFF09", proteus: "capability.file-system", status: "ok", group: "api" },
+  { mp: "wx.compressFile/unzip", proteus: "capability.archive", status: "ok", group: "api" },
+  { mp: "wx.set/get/remove/clearStorage(+Sync)", proteus: "capability.storage", status: "ok", group: "api" },
+  { mp: "wx.getLocation/chooseLocation/openLocation", proteus: "capability.location", status: "ok", group: "api" },
+  { mp: "wx.createMapContext", proteus: "capability.map", status: "ok", group: "api" },
+  { mp: "wx.getSystemInfo\uFF08\u8BBE\u5907/\u5C4F\u5E55/\u7F51\u7EDC/\u7535\u91CF/\u4EAE\u5EA6/\u65B9\u5411/\u9707\u52A8/\u4F20\u611F\u5668/\u526A\u8D34\u677F/\u7535\u8BDD\uFF09", proteus: "capability.device/screen/network/battery/brightness/orientation/vibrate/sensor/clipboard/phone-call", status: "ok", group: "api" },
+  { mp: "wx.openBluetoothAdapter\uFF08\u84DD\u7259 20+\uFF09", proteus: "capability.bluetooth", status: "ok", group: "api" },
+  { mp: "wx.getHCEState\uFF08NFC\uFF09", proteus: "capability.nfc", status: "ok", group: "api" },
+  { mp: "wx.checkIsSupportFingerPrint/FaceID", proteus: "capability.biometric / face-id", status: "ok", group: "api" },
+  { mp: "wx.showToast/showLoading/showModal/showActionSheet", proteus: "shell.toast + capability.toast/loading + shell.modal + shell.action-sheet", status: "ok", group: "api" },
+  { mp: "wx.setNavigationBarTitle/Color", proteus: "shell.nav", status: "ok", group: "api" },
+  { mp: "wx.setTabBarItem/Style/hide/show", proteus: "shell.tabbar", status: "ok", group: "api" },
+  { mp: "wx.pageScrollTo", proteus: "capability.page-scroll", status: "ok", group: "api" },
+  { mp: "wx.createAnimation", proteus: "engineering.animation", status: "ok", group: "api" },
+  { mp: "wx.createSelectorQuery/IntersectionObserver", proteus: "capability.element / intersection", status: "ok", group: "api" },
+  { mp: "wx.navigateTo/redirectTo/navigateBack/switchTab/reLaunch", proteus: "engineering.router-push/replace/back/switch-tab/relaunch", status: "ok", group: "api" },
+  { mp: "wx.getCurrentPages", proteus: "engineering.route", status: "ok", group: "api" },
+  { mp: "App()/Page() \u751F\u547D\u5468\u671F/getApp()", proteus: "engineering.lifecycle + capability.app-lifecycle/page-lifecycle", status: "ok", group: "api" },
+  { mp: "wx.shareAppMessage/requestSubscribeMessage", proteus: "capability.share / notification", status: "ok", group: "api" },
+  { mp: "wx.login/checkSession/getUserInfo/authorize", proteus: "capability.login / auth / permission", status: "ok", group: "api" },
+  { mp: "wx.getUpdateManager", proteus: "capability.update (L2)", status: "compat", group: "api" },
+  { mp: "wx.requestWeChatPay/navigateToMiniProgram/\u6A21\u677F\u6D88\u606F/\u5BA2\u670D\uFF08\u5FAE\u4FE1\u79C1\u6709\uFF09", proteus: "capability.mini-program", status: "private", group: "api" }
+];
+var MP_MAPPING_MATRIX = [...MP_COMPONENTS, ...MP_API_GROUPS];
+
+// src/dispatcher.ts
+var DispatcherError = class extends Error {
+  constructor(code, detail) {
+    super(`unknown primitive tag: ${detail.type}\uFF08\u987B\u5728 G-32 \u539F\u8BED\u8868\u5185\uFF0C\u7F16\u8BD1\u671F\u62E6\u622A\uFF1B\u8FD0\u884C\u671F\u515C\u5E95\uFF09`);
+    this.code = code;
+    this.detail = detail;
+    this.name = "DispatcherError";
+  }
+};
+function createNodeOpsDispatcher(initialBackend) {
+  let current = initialBackend;
+  const history = [];
+  const trace = [];
+  let seq = 0;
+  let handleIds = /* @__PURE__ */ new WeakMap();
+  let nextHandleId = 1;
+  function idOf(handle) {
+    if (handle && typeof handle === "object") {
+      let id = handleIds.get(handle);
+      if (id === void 0) {
+        id = nextHandleId++;
+        handleIds.set(handle, id);
+      }
+      return id;
+    }
+    return 0;
+  }
+  function toIRNode(type, props = {}) {
+    const cir = toComponentIR(type, props);
+    if (!cir) throw new DispatcherError("unknown.primitive", { type });
+    return { type: cir.tag, semantic: cir.semantic, props: { ...cir.props }, children: [] };
+  }
+  const nodeOps = {
+    createElement(type, props = {}) {
+      const ir = toIRNode(type, props);
+      const handle = current.createElement(ir);
+      trace.push({ seq: ++seq, op: "createElement", type, semantic: ir.semantic ?? type });
+      return handle;
+    },
+    insert(child, parent, anchor) {
+      current.insert(child, parent, anchor);
+      trace.push({ seq: ++seq, op: "insert", child: idOf(child), parent: parent ? idOf(parent) : null, anchor: anchor ? idOf(anchor) : null });
+    },
+    remove(child) {
+      current.remove(child);
+      trace.push({ seq: ++seq, op: "remove", child: idOf(child) });
+    },
+    patchProp(el, key, prev, next) {
+      current.patchProp(el, key, prev, next);
+      trace.push({ seq: ++seq, op: "patchProp", el: idOf(el), key, next });
+    },
+    setText(el, text) {
+      current.setText(el, text);
+      trace.push({ seq: ++seq, op: "setText", el: idOf(el), text });
+    },
+    createText(text) {
+      const handle = current.createElement({ type: "text", props: {}, children: [], semantic: void 0 });
+      trace.push({ seq: ++seq, op: "createText", text });
+      return handle;
+    },
+    createComment(text) {
+      const handle = current.createElement({ type: "comment", props: {}, children: [] });
+      trace.push({ seq: ++seq, op: "createComment", text });
+      return handle;
+    },
+    parentNode(node) {
+      const fn = current.parentNode;
+      const r = fn ? fn(node) : null;
+      trace.push({ seq: ++seq, op: "parentNode", node: idOf(node), result: r ? idOf(r) : null });
+      return r ?? null;
+    },
+    nextSibling(node) {
+      const fn = current.nextSibling;
+      const r = fn ? fn(node) : null;
+      trace.push({ seq: ++seq, op: "nextSibling", node: idOf(node), result: r ? idOf(r) : null });
+      return r ?? null;
+    }
+  };
+  return {
+    get currentBackend() {
+      return current;
+    },
+    switchBackend(next, opts) {
+      const strategy = opts?.strategy ?? "rebuild";
+      history.push(current);
+      trace.push({ seq: ++seq, op: "switchBackend", from: current.id, to: next.id, strategy });
+      current = next;
+    },
+    get switchHistory() {
+      return history;
+    },
+    nodeOps,
+    toIRNode,
+    trace,
+    clearTrace() {
+      trace.length = 0;
+      seq = 0;
+      handleIds = /* @__PURE__ */ new WeakMap();
+    }
+  };
+}
+function renderIRTree(backend, ir, insertInto) {
+  const root = backend.createElement(ir);
+  for (const child of ir.children) {
+    const c = renderIRTree(backend, child);
+    if (insertInto) insertInto(c, root);
+    else backend.insert(c, root);
+  }
+  return root;
+}
+function semanticSequence(ir) {
+  return [ir.semantic ?? ir.type, ...ir.children.flatMap(semanticSequence)];
+}
+
+// src/host-conformance.ts
+function createHostRuntimeStub() {
+  const rt = {
+    id: "terminal",
+    state: "created",
+    threads: ["main"],
+    workers: [],
+    queue: [],
+    bootstrap() {
+      rt.state = "running";
+      return rt;
+    },
+    suspend() {
+      rt.state = "suspended";
+    },
+    resume() {
+      rt.state = "running";
+    },
+    destroy() {
+      rt.state = "destroyed";
+      rt.queue = [];
+      rt.workers = [];
+    },
+    createWorker() {
+      const w = { id: `w${rt.workers.length + 1}`, thread: `worker${rt.workers.length + 1}` };
+      rt.workers.push(w);
+      rt.threads.push(w.thread);
+      return w;
+    },
+    postMessage() {
+      return true;
+    },
+    enqueue(task, priority = 2) {
+      rt.queue.push({ task, priority });
+    },
+    nextTick(fn) {
+      rt.queue.push({ task: fn, priority: 0 });
+    },
+    drain() {
+      rt.queue.sort((a, b) => a.priority - b.priority);
+      const out = [];
+      while (rt.queue.length) rt.queue.shift();
+      return out;
+    }
+  };
+  return rt;
+}
+function createCarrierStub(kind) {
+  return {
+    id: kind,
+    boundaries: 0,
+    capabilities: kind === "jsi" ? { threadAffinity: true, trueConcurrency: false, realtime: { capable: false } } : { threadAffinity: false, trueConcurrency: true, realtime: { capable: true } },
+    cross() {
+      if (kind === "aot") return 0;
+      this.boundaries++;
+      return this.boundaries;
+    }
+  };
+}
+function buildProductIR(dispatch) {
+  const grid = dispatch.toIRNode("p-grid", { minColWidth: 160 });
+  const box1 = dispatch.toIRNode("p-box", {});
+  const box2 = dispatch.toIRNode("p-box", {});
+  const text = dispatch.toIRNode("p-text", { content: "\u5546\u54C1 A" });
+  const button = dispatch.toIRNode("p-button", { variant: "primary" });
+  return {
+    ...dispatch.toIRNode("p-page", { title: "Product" }),
+    children: [
+      { ...grid, children: [{ ...box1, children: [text] }, { ...box2, children: [button] }] }
+    ]
+  };
+}
+var tests = [];
+var register = (group) => (id, fn) => tests.push({ id: `${group}-${id}`, group, fn });
+var H01 = register("H-01");
+var H02 = register("H-02");
+var H03 = register("H-03");
+var H04 = register("H-04");
+var H05 = register("H-05");
+var H06 = register("H-06");
+var H07 = register("H-07");
+var H08 = register("H-08");
+var assert = (c, m) => {
+  if (!c) throw new Error(m ?? "assertion failed");
+};
+H01("01", ({ host }) => assert(host.state === "running", "Runtime \u5E94\u5DF2 bootstrap"));
+H01("02", ({ carrier }) => assert(carrier && carrier.id === "jsi", "Carrier \u5E94\u5DF2\u6CE8\u518C"));
+H01("03", ({ dispatch, backendA }) => assert(dispatch.currentBackend === backendA, "Backend \u5E94\u5DF2\u6CE8\u518C"));
+H01("04", ({ host, dispatch, backendA }) => assert(host.state === "running" && dispatch.currentBackend === backendA, "\u6CE8\u518C\u5148\u4E8E bootstrap\uFF08G-41.6\uFF09"));
+H02("01", ({ host }) => {
+  host.suspend();
+  assert(host.state === "suspended");
+  host.resume();
+});
+H02("02", ({ host }) => assert(host.state === "running"));
+H02("03", ({ host }) => {
+  const w = host.createWorker();
+  assert(host.threads.includes(w.thread), "createWorker \u5E94\u4EA7\u751F\u72EC\u7ACB\u7EBF\u7A0B");
+});
+H02("04", ({}) => {
+  const r2 = createHostRuntimeStub();
+  r2.bootstrap();
+  r2.enqueue(() => 1);
+  r2.destroy();
+  assert(r2.state === "destroyed" && r2.queue.length === 0, "destroy \u5E94\u6E05\u7406\u961F\u5217");
+});
+var snapA;
+var snapB;
+H03("01", ({ backendA, productIR }) => {
+  const root = renderIRTree(backendA, productIR);
+  snapA = JSON.stringify(toPlainTree(root));
+  assert(snapA.includes("grid"), "Backend A \u6E32\u67D3\u5E94\u542B grid");
+});
+H03("02", ({ dispatch, backendB }) => {
+  dispatch.switchBackend(backendB);
+  assert(dispatch.currentBackend === backendB, "switchBackend \u5E94\u751F\u6548");
+});
+H03("03", ({ backendB, productIR }) => {
+  const root = renderIRTree(backendB, productIR);
+  snapB = JSON.stringify(toWidgetTree(root));
+  assert(snapB.includes("GridView"), "Backend B \u6E32\u67D3\u5E94\u542B GridView");
+});
+H03("04", () => {
+  assert(snapA && snapB, "\u53CC\u5F15\u64CE\u5FEB\u7167\u7F3A\u5931");
+  assert(snapA.length > 0 && snapB.length > 0);
+});
+H04("01", ({ backendA, productIR }) => {
+  const root = renderIRTree(backendA, productIR);
+  const tree = JSON.stringify(toPlainTree(root));
+  assert(tree.includes('"grid"'), "\u540E\u7AEF\u5E94\u57FA\u4E8E semantic \u5206\u53D1\uFF08G-37.1\uFF1Alayout.grid \u2192 grid\uFF09");
+});
+H04("02", ({ dispatch }) => {
+  let threw = false;
+  try {
+    dispatch.toIRNode("p-unknown-thing", {});
+  } catch (e) {
+    threw = e instanceof DispatcherError;
+  }
+  assert(threw, "\u672A\u77E5\u539F\u8BED\u5E94\u88AB\u62E6\u622A\uFF08G-32.2\uFF1B\u7F16\u8BD1\u671F\u62E6\u622A\uFF0C\u8FD0\u884C\u671F\u5151\u5E95\uFF09");
+});
+H04("03", ({ host }) => {
+  const before = host.threads.length;
+  host.createWorker();
+  assert(host.threads.length === before + 1, "\u6846\u67B6\u4E0D\u5F97\u76F4\u63A5\u5EFA\u7EBF\u7A0B\uFF0C\u987B\u59D4\u6258 runtime.createWorker\uFF08G-41.1\uFF09");
+});
+H04("04", () => {
+  const src = createHeadlessBackend.toString() + createFlutterBackend.toString();
+  assert(!/from ['"]vue['"]/.test(src) && !/@vue\/runtime/.test(src), "\u5F15\u64CE\u4E0D\u5F97 import vue\uFF08G-41.3\uFF09");
+});
+H04("05", ({ host }) => {
+  const src = (host.constructor?.toString?.() ?? "") + createHostRuntimeStub.toString();
+  assert(!/semantic\s*===/.test(src), "\u5BBF\u4E3B\u4E0D\u5F97\u89E3\u6790 IR \u5B57\u6BB5\uFF08G-41.2\uFF09");
+});
+H05("01", ({ dispatch, backendB }) => {
+  dispatch.switchBackend(backendB);
+  assert(dispatch.currentBackend === backendB, "\u70ED\u5207\u6362\u540E currentBackend \u5E94\u53D8\u66F4");
+});
+H05("02", ({ backendB, productIR }) => {
+  const root = renderIRTree(backendB, productIR);
+  assert(JSON.stringify(toWidgetTree(root)).includes("FilledButton"), "\u70ED\u5207\u6362\u540E\u53EF\u91CD\u65B0\u6E32\u67D3");
+});
+H05("03", ({ dispatch, backendA, productIR }) => {
+  dispatch.switchBackend(backendA);
+  const root = renderIRTree(backendA, productIR);
+  assert(JSON.stringify(toPlainTree(root)).includes("button"), "\u5207\u56DE Backend A \u4ECD\u6B63\u786E");
+});
+H05("04", ({ backendA }) => {
+  const cap2 = backendA.capabilities;
+  assert(cap2 && typeof cap2 === "object", "\u540E\u7AEF\u5FC5\u987B\u58F0\u660E capabilities \u5BF9\u8C61");
+  for (const key of ["layout", "glass", "blur", "animation", "textureSharing", "remoteRendering", "ssr", "input"]) {
+    assert(key in cap2, `capabilities \u7F3A\u5931\u5B57\u6BB5: ${key}\uFF08G-37.3 \u8BDA\u5B9E\u58F0\u660E\uFF09`);
+  }
+});
+H06("01", ({ backendA, backendB }) => assert(backendA !== backendB, "\u540C\u9875\u9762\u53EF\u6301\u6709\u591A\u4E2A Backend \u5B9E\u4F8B"));
+H06("02", ({}) => {
+  const cir = toComponentIR("p-canvas", { engine: "skia", resolution: 2 });
+  assert(cir !== null && cir.semantic === "ui.canvas" && cir.props.engine === "skia", "\u5F15\u64CE/\u5C5E\u6027\u5E94\u4F5C\u4E3A\u8BED\u4E49\u5C5E\u6027\u8FDB C-IR");
+});
+H06("03", ({}) => {
+  const cir = toComponentIR("p-grid", { minColWidth: 160 });
+  assert(cir !== null && cir.props.minColWidth === 160, "\u539F\u8BED\u5C5E\u6027\u5E94\u900F\u4F20\u8FDB C-IR");
+});
+H06("04", ({ dispatch, backendB }) => {
+  dispatch.switchBackend(backendB);
+  assert(dispatch.currentBackend === backendB, "Dispatcher \u5355\u5B9E\u4F8B\u652F\u6301\u591A\u540E\u7AEF\uFF08\u65B9\u6848 B\uFF09");
+});
+H07("01", ({ carrier }) => assert(typeof carrier.capabilities.threadAffinity === "boolean", "Carrier \u5E94\u58F0\u660E threadAffinity"));
+H07("02", ({}) => {
+  const jsi = createCarrierStub("jsi");
+  const aot = createCarrierStub("aot");
+  assert(jsi.capabilities.trueConcurrency === false && aot.capabilities.trueConcurrency === true, "JSI \u53D7\u9650\u3001AOT \u4E0D\u53D7\u9650\uFF08G-40\uFF09");
+});
+H07("03", ({}) => {
+  const aot = createCarrierStub("aot");
+  aot.cross();
+  aot.cross();
+  assert(aot.boundaries === 0, "AOT \u8DE8\u754C\u6210\u672C\u4E3A 0");
+});
+H07("04", ({}) => {
+  const jsi = createCarrierStub("jsi");
+  const aot = createCarrierStub("aot");
+  assert(jsi.capabilities.realtime.capable === false && aot.capabilities.realtime.capable === true, "realtime \u80FD\u529B\u4EC5\u5728 AOT \u53EF\u7528");
+});
+H08("01", ({ dispatch }) => {
+  let ok = false;
+  try {
+    dispatch.toIRNode("div", {});
+  } catch {
+    ok = true;
+  }
+  assert(ok, "\u672A\u77E5\u539F\u8BED\u5E94\u629B\u9519\u800C\u975E\u9759\u9ED8");
+});
+H08("02", ({ dispatch }) => {
+  const ir = dispatch.toIRNode("p-grid", { minColWidth: 160 });
+  assert(ir.semantic === "layout.grid", "\u6846\u67B6\u8DEF\u5F84 semantic \u6052\u5B58\u5728\uFF08G-37.1\uFF1A\u540E\u7AEF\u6309 semantic \u5206\u53D1\u7684\u524D\u63D0\uFF09");
+});
+H08("03", ({}) => {
+  const r = createHostRuntimeStub();
+  r.bootstrap();
+  r.destroy();
+  assert(r.state === "destroyed", "destroy \u540E\u72B6\u6001\u5E94\u4E3A destroyed");
+});
+function runHostConformance(opts = {}) {
+  const host = opts.host ?? createHostRuntimeStub();
+  const carrier = opts.carrier ?? createCarrierStub("jsi");
+  const backendA = opts.backendA ?? createHeadlessBackend();
+  const backendB = opts.backendB ?? createFlutterBackend();
+  const dispatch = createNodeOpsDispatcher(backendA);
+  const productIR = buildProductIR(dispatch);
+  const ctx = { host, carrier, backendA, backendB, dispatch, productIR };
+  const results = [];
+  host.bootstrap();
+  snapA = "";
+  snapB = "";
+  for (const t of tests) {
+    if (opts.only && !t.group.startsWith(opts.only)) continue;
+    try {
+      const ret = t.fn(ctx);
+      if (ret === "SKIP") results.push({ id: t.id, status: "SKIP" });
+      else results.push({ id: t.id, status: "PASS" });
+    } catch (e) {
+      results.push({ id: t.id, status: "FAIL", error: e.message });
+    }
+  }
+  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 formatHostConformance(s) {
+  const lines = ["[G-41 Host Conformance\uFF08H-01~H-08\uFF09]"];
+  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\uFF09\u2014\u2014CMP058\uFF1Afailed=0 \u624D\u5141\u8BB8\u4E0A\u7EBF`);
+  return lines.join("\n");
+}
+
+// src/vue-bridge.ts
+import { createRenderer } from "@vue/runtime-core";
+function createVueRendererOptions(dispatch) {
+  const d = dispatch.nodeOps;
+  return {
+    // Vue 真实签名：createElement(type, namespace?, isCustomizedBuiltIn?, vnodeProps?)
+    createElement(type, _namespace, _isCustomizedBuiltIn, vnodeProps) {
+      return d.createElement(type, vnodeProps ?? {});
+    },
+    createText(text) {
+      return d.createText(text);
+    },
+    createComment(text) {
+      return d.createComment(text);
+    },
+    setText(node, text) {
+      d.setText(node, text);
+    },
+    // 元素直接文本内容（Vue 清空子树时调用）——语义等价 setText
+    setElementText(el, text) {
+      d.setText(el, text);
+    },
+    insert(child, parent, anchor) {
+      d.insert(child, parent, anchor ?? void 0);
+    },
+    remove(node) {
+      d.remove(node);
+    },
+    parentNode(node) {
+      return d.parentNode(node) ?? null;
+    },
+    nextSibling(node) {
+      return d.nextSibling(node) ?? null;
+    },
+    patchProp(el, key, prev, next) {
+      d.patchProp(el, key, prev, next);
+    },
+    // —— 以下对齐 renderer-app host.ts 语义降级（非核心渲染路径） ——
+    querySelector() {
+      return null;
+    },
+    setScopeId() {
+    },
+    cloneNode() {
+      return d.createComment("");
+    },
+    insertStaticContent(_content, parent, anchor) {
+      const c = d.createComment("");
+      if (parent) d.insert(c, parent, anchor ?? void 0);
+      return [c, c];
+    }
+  };
+}
+function createProteusRenderer(dispatch) {
+  const renderer = createRenderer(createVueRendererOptions(dispatch));
+  return { dispatch, renderer };
+}
+function createProteusRendererForBackend(backend) {
+  return createProteusRenderer(createNodeOpsDispatcher(backend));
+}
+
+// src/web-host.ts
+function defaultWorkerFactory(scriptUrl) {
+  const g = globalThis;
+  if (typeof g.Worker === "function") {
+    try {
+      const w = new g.Worker(scriptUrl ?? "");
+      return { raw: w, terminate: () => w.terminate() };
+    } catch {
+    }
+  }
+  return { raw: null, terminate() {
+  } };
+}
+function createWebHostRuntime(opts = {}) {
+  const createWorkerImpl = opts.createWorkerImpl ?? defaultWorkerFactory;
+  const g = opts.env ?? globalThis;
+  const rt = {
+    id: "web",
+    state: "created",
+    threads: ["main"],
+    workers: [],
+    queue: [],
+    bootstrap() {
+      rt.state = "running";
+      return rt;
+    },
+    suspend() {
+      rt.state = "suspended";
+    },
+    resume() {
+      rt.state = "running";
+    },
+    destroy() {
+      rt.state = "destroyed";
+      rt.queue = [];
+      for (const w of rt.workers) w.terminate();
+      rt.workers = [];
+      rt.threads = ["main"];
+    },
+    createWorker(scriptUrl) {
+      const impl = createWorkerImpl(scriptUrl);
+      const w = {
+        id: `w${rt.workers.length + 1}`,
+        thread: `worker${rt.workers.length + 1}`,
+        raw: impl.raw,
+        terminate: impl.terminate
+      };
+      rt.workers.push(w);
+      rt.threads.push(w.thread);
+      return w;
+    },
+    postMessage() {
+      return true;
+    },
+    enqueue(task, priority = 2) {
+      rt.queue.push({ task, priority });
+    },
+    nextTick(fn) {
+      rt.queue.push({ task: fn, priority: 0 });
+    },
+    drain() {
+      rt.queue.sort((a, b) => a.priority - b.priority);
+      const out = [];
+      while (rt.queue.length) {
+        const { task } = rt.queue.shift();
+        out.push(task());
+      }
+      return out;
+    },
+    async flush() {
+      if (!rt.queue.length) return;
+      const tasks = rt.queue.splice(0).sort((a, b) => a.priority - b.priority);
+      for (const { task } of tasks) {
+        await Promise.resolve();
+        task();
+      }
+    },
+    bindPageVisibility() {
+      const doc = g.document;
+      if (!doc || typeof doc.visibilityState !== "string") {
+        return () => {
+        };
+      }
+      const onVis = () => {
+        if (doc.visibilityState === "hidden") rt.suspend();
+        else rt.resume();
+      };
+      doc.addEventListener("visibilitychange", onVis);
+      return () => doc.removeEventListener("visibilitychange", onVis);
+    }
+  };
+  return rt;
+}
+
+// src/hot-switch.ts
+function createBackendSwitcher(dispatch) {
+  let currentIR = null;
+  let root = null;
+  return {
+    get dispatch() {
+      return dispatch;
+    },
+    get currentIR() {
+      return currentIR;
+    },
+    get root() {
+      return root;
+    },
+    mount(ir) {
+      currentIR = ir;
+      root = renderIRTree(dispatch.currentBackend, ir);
+      return root;
+    },
+    switchBackend(next, opts = {}) {
+      const strategy = opts.strategy ?? "rebuild";
+      const from = dispatch.currentBackend;
+      opts.onBeforeSwitch?.(from, next);
+      dispatch.switchBackend(next, { strategy });
+      if (strategy === "rehydrate" && currentIR) {
+        root = renderIRTree(next, currentIR);
+      } else {
+        root = null;
+      }
+      opts.onAfterSwitch?.(from, next, root);
+      return root;
+    },
+    destroy() {
+      currentIR = null;
+      root = null;
+    }
+  };
+}
+
+// src/container-spi.ts
+var CONTAINER_PROFILES = {
+  singlepage: { pageStack: false, multiBusiness: false, crashIsolation: 0, resourceQuota: false, keepAlive: false, windowManagement: false, embedded: false },
+  stack: { pageStack: true, multiBusiness: false, crashIsolation: 0, resourceQuota: true, keepAlive: true, windowManagement: false, embedded: false },
+  superapp: { pageStack: true, multiBusiness: true, crashIsolation: 2, resourceQuota: true, keepAlive: true, windowManagement: false, embedded: false },
+  miniprogram: { pageStack: true, multiBusiness: true, crashIsolation: 1, resourceQuota: true, keepAlive: true, windowManagement: false, embedded: false },
+  window: { pageStack: true, multiBusiness: false, crashIsolation: 0, resourceQuota: true, keepAlive: true, windowManagement: true, embedded: false },
+  embedded: { pageStack: false, multiBusiness: false, crashIsolation: 0, resourceQuota: false, keepAlive: false, windowManagement: false, embedded: true }
+};
+var PAGE_STATE_TRANSITIONS = {
+  created: ["mounted", "destroyed"],
+  mounted: ["hidden", "destroyed", "crashed"],
+  hidden: ["mounted", "destroyed"],
+  crashed: ["destroyed"],
+  destroyed: ["recycled"],
+  recycled: []
+};
+function canTransitionPageState(from, to) {
+  return PAGE_STATE_TRANSITIONS[from].includes(to);
+}
+var FIVE_ATOMIC_STEPS = ["unmount", "unbindEvents", "releaseResources", "destroyIR", "releaseQuota"];
+function assertAtomicDestroy(report) {
+  if (report.steps.length !== 5) {
+    throw new Error(`G-42.2 \u8FDD\u53CD\uFF1A\u9875\u9762\u9500\u6BC1\u5FC5\u987B\u4E94\u539F\u5B50\uFF08\u5B9E\u9645 ${report.steps.length} \u6B65\uFF1A${report.steps.join("\u2192") || "\u65E0"}\uFF09`);
+  }
+  for (let i = 0; i < FIVE_ATOMIC_STEPS.length; i++) {
+    if (report.steps[i] !== FIVE_ATOMIC_STEPS[i]) {
+      throw new Error(`G-42.2 \u8FDD\u53CD\uFF1A\u4E94\u539F\u5B50\u6B65\u9AA4\u987A\u5E8F\u9519\u8BEF\uFF08\u7B2C ${i + 1} \u6B65\u5E94\u4E3A ${FIVE_ATOMIC_STEPS[i]}\uFF0C\u5B9E\u9645 ${report.steps[i]}\uFF09`);
+    }
+  }
+}
+function createDestroyReport(pageId, reclaimedBytes = 0, durationMs = 0) {
+  return { pageId, steps: [...FIVE_ATOMIC_STEPS], leaked: [], reclaimedBytes, durationMs };
+}
+var DEFAULT_STACK_POLICY = {
+  maxDepth: 10,
+  overflowStrategy: "destroy-oldest",
+  keepAlive: { maxCount: 3, memoryBudgetBytes: 64 * 1024 * 1024 }
+};
+function profileOfContainer(id) {
+  return CONTAINER_PROFILES[id] ?? { pageStack: false, multiBusiness: false, crashIsolation: 0, resourceQuota: false, keepAlive: false, windowManagement: false, embedded: false };
+}
+
+// src/ownership.ts
+var OwnershipError = class extends Error {
+  constructor(code, message, extra) {
+    super(message);
+    this.name = "OwnershipError";
+    this.code = code;
+    this.resourceId = extra.resourceId;
+  }
+};
+var OWNERSHIP_ERRORS = {
+  useAfterMove: (id, movedTo) => new OwnershipError("use_after_move", `\u8D44\u6E90 ${id} \u5DF2\u8F6C\u79FB\u7ED9 ${movedTo}\uFF0C\u4E0D\u53EF\u518D\u8BBF\u95EE`, { resourceId: id }),
+  useAfterDrop: (id) => new OwnershipError("use_after_drop", `\u8D44\u6E90 ${id} \u5DF2\u91CA\u653E\uFF0C\u4E0D\u53EF\u518D\u8BBF\u95EE`, { resourceId: id }),
+  doubleMove: (id) => new OwnershipError("double_move", `\u8D44\u6E90 ${id} \u5DF2\u8F6C\u79FB\u8FC7\uFF0C\u4E0D\u53EF\u91CD\u590D\u8F6C\u79FB`, { resourceId: id }),
+  hasActiveBorrows: (id, count) => new OwnershipError("has_active_borrows", `\u8D44\u6E90 ${id} \u6709 ${count} \u4E2A\u6D3B\u8DC3\u501F\u7528\uFF0C\u4E0D\u53EF\u91CA\u653E`, { resourceId: id }),
+  alreadyDropped: (id) => new OwnershipError("already_dropped", `\u8D44\u6E90 ${id} \u5DF2\u91CA\u653E`, { resourceId: id }),
+  notTransferable: (id, reason) => new OwnershipError("resource_not_transferable", `\u8D44\u6E90 ${id} \u4E0D\u53EF\u8F6C\u79FB\uFF1A${reason}`, { resourceId: id })
+};
+var OwnershipGraph = class {
+  constructor(opts = {}) {
+    this.nodes = /* @__PURE__ */ new Map();
+    this.edges = [];
+    this._nextId = 1;
+    this._listeners = /* @__PURE__ */ new Set();
+    if (opts.onMutate) this._listeners.add(opts.onMutate);
+  }
+  nextId() {
+    return `res_${this._nextId++}`;
+  }
+  /** ★G-43 B4：动态订阅图 mutation（可任意时刻挂接；返回解绑） */
+  subscribe(cb) {
+    this._listeners.add(cb);
+    return () => {
+      this._listeners.delete(cb);
+    };
+  }
+  _emit(m) {
+    for (const fn of this._listeners) fn(m);
+  }
+  register(opts) {
+    const node = {
+      id: opts.id,
+      type: opts.type,
+      byteSize: opts.byteSize,
+      owner: opts.owner ?? null,
+      state: "alive",
+      createdAt: Date.now(),
+      sourceLocation: opts.sourceLocation ?? null
+    };
+    this.nodes.set(opts.id, node);
+    if (opts.owner) {
+      this.edges.push({ kind: "owns", from: opts.owner, to: opts.id });
+    }
+    this._emit({ kind: "register", id: opts.id, owner: node.owner, type: node.type, byteSize: node.byteSize, sourceLocation: node.sourceLocation, ts: Date.now() });
+    return node;
+  }
+  addEdge(edge) {
+    this.edges.push(edge);
+    this._emit({ kind: "edge", edge, ts: Date.now() });
+  }
+  setState(id, state) {
+    const node = this.nodes.get(id);
+    if (node) node.state = state;
+    this._emit({ kind: "state", id, state, ts: Date.now() });
+  }
+  resourcesOf(owner) {
+    return [...this.nodes.values()].filter((n) => n.owner === owner && n.state === "alive");
+  }
+  /** 无主资源检测（G-43.1——owner === null 的存活节点数为 0） */
+  findOrphans() {
+    return [...this.nodes.values()].filter((n) => n.owner === null && n.state === "alive");
+  }
+  /** 泄漏检测：页面销毁后仍存活的资源 + 反向引用链（谁还持有它——DevTools 泄漏定位） */
+  detectLeaks(destroyedScope) {
+    return this.resourcesOf(destroyedScope).map((n) => ({
+      resourceId: n.id,
+      type: n.type,
+      byteSize: n.byteSize,
+      sourceLocation: n.sourceLocation,
+      referenceChain: this.backTrace(n.id)
+    }));
+  }
+  /** 反向引用链（资源 ← 谁持有 ← 谁又持有……） */
+  backTrace(resourceId) {
+    const chain = [];
+    const visited = /* @__PURE__ */ new Set();
+    const walk = (id) => {
+      if (visited.has(id)) return;
+      visited.add(id);
+      for (const e of this.edges) {
+        if (e.to === id && e.from !== id) {
+          chain.push(`${e.from} --${e.kind}--> ${id}`);
+          walk(e.from);
+        }
+      }
+    };
+    walk(resourceId);
+    return chain;
+  }
+  stats() {
+    const alive = [...this.nodes.values()].filter((n) => n.state === "alive");
+    return {
+      total: this.nodes.size,
+      alive: alive.length,
+      moved: [...this.nodes.values()].filter((n) => n.state === "moved").length,
+      dropped: [...this.nodes.values()].filter((n) => n.state === "dropped").length,
+      totalBytes: alive.reduce((s, n) => s + n.byteSize, 0),
+      edges: this.edges.length
+    };
+  }
+};
+function createQuotaTracker() {
+  const usage = /* @__PURE__ */ new Map();
+  return {
+    request(owner, bytes) {
+      usage.set(owner, (usage.get(owner) ?? 0) + bytes);
+      return usage.get(owner);
+    },
+    release(owner, bytes) {
+      usage.set(owner, Math.max(0, (usage.get(owner) ?? 0) - bytes));
+      return usage.get(owner);
+    },
+    usageOf(owner) {
+      return usage.get(owner) ?? 0;
+    }
+  };
+}
+var Owned = class _Owned {
+  constructor(opts) {
+    this._state = "alive";
+    this._movedTo = null;
+    this._activeBorrows = 0;
+    this._borrows = /* @__PURE__ */ new Set();
+    this._listeners = /* @__PURE__ */ new Set();
+    this.id = opts.id;
+    this.resourceType = opts.resourceType;
+    this.byteSize = opts.byteSize;
+    this.owner = opts.owner;
+    this._value = opts.value;
+    this._graph = opts.graph;
+    this._transferable = opts.transferable ?? false;
+    this._releaseHook = opts.releaseHook ?? null;
+    this._sourceLocation = opts.sourceLocation ?? null;
+    this._graph.register({ id: opts.id, type: opts.resourceType, byteSize: opts.byteSize, owner: opts.owner, sourceLocation: this._sourceLocation });
+  }
+  get state() {
+    return this._state;
+  }
+  get activeBorrows() {
+    return this._activeBorrows;
+  }
+  /** ★G-43 B5：订阅状态变化（moved/dropped 时通知——返回解绑） */
+  subscribe(cb) {
+    this._listeners.add(cb);
+    return () => {
+      this._listeners.delete(cb);
+    };
+  }
+  _notify() {
+    for (const fn of this._listeners) fn(this._state);
+  }
+  /** 存活断言（G-43.2/43.6：Move/Drop 后禁访问） */
+  _assertAlive(op) {
+    if (this._state === "moved") {
+      throw OWNERSHIP_ERRORS.useAfterMove(this.id, this._movedTo ?? "?");
+    }
+    if (this._state === "dropped") {
+      throw OWNERSHIP_ERRORS.useAfterDrop(this.id);
+    }
+    void op;
+  }
+  /** 读取（G-43.2：Move/Drop 后禁访问——use-after-move 拦截） */
+  read() {
+    this._assertAlive("read");
+    return this._value;
+  }
+  /** ★Move 语义：转移所有权后原所有者不可再访问 */
+  transferTo(targetOwner) {
+    this._assertAlive("transferTo");
+    if (this._state === "moved") throw OWNERSHIP_ERRORS.doubleMove(this.id);
+    if (this._activeBorrows > 0) throw OWNERSHIP_ERRORS.hasActiveBorrows(this.id, this._activeBorrows);
+    this._state = "moved";
+    this._movedTo = targetOwner;
+    this._graph.setState(this.id, "moved");
+    this._graph.addEdge({ kind: "moved-from", from: targetOwner, to: this.id });
+    this._notify();
+    return new _Owned({
+      id: `${this.id}@${targetOwner}`,
+      resourceType: this.resourceType,
+      byteSize: this.byteSize,
+      owner: targetOwner,
+      value: this._value,
+      graph: this._graph,
+      transferable: this._transferable,
+      releaseHook: this._releaseHook ?? void 0,
+      sourceLocation: this._sourceLocation
+    });
+  }
+  /** ★Borrow：临时借用（G-43.3 不逃逸作用域——drop 后失效） */
+  borrow(scopeName = "anonymous") {
+    this._assertAlive("borrow");
+    const b = new Borrow(this, scopeName, this._graph);
+    this._activeBorrows++;
+    this._borrows.add(b);
+    this._graph.addEdge({ kind: "borrows", from: scopeName, to: this.id, since: Date.now() });
+    return b;
+  }
+  /** ★Weak：弱引用（打破循环） */
+  weak() {
+    return new Weak(this);
+  }
+  /** ★确定性 Drop（五阶段协议） */
+  drop(opts = {}) {
+    const { force = false } = opts;
+    if (this._state === "dropped") return { ok: false, freedBytes: 0, freedHandles: 0, invalidatedBorrows: 0, error: OWNERSHIP_ERRORS.alreadyDropped(this.id) };
+    if (this._state === "moved") return { ok: false, freedBytes: 0, freedHandles: 0, invalidatedBorrows: 0, error: OWNERSHIP_ERRORS.useAfterMove(this.id, this._movedTo ?? "?") };
+    if (!force && this._activeBorrows > 0) {
+      return { ok: false, freedBytes: 0, freedHandles: 0, invalidatedBorrows: 0, error: OWNERSHIP_ERRORS.hasActiveBorrows(this.id, this._activeBorrows) };
+    }
+    let invalidated = 0;
+    for (const b of this._borrows) {
+      if (b.valid) {
+        b.invalidate();
+        invalidated++;
+      }
+    }
+    this._borrows.clear();
+    this._activeBorrows = 0;
+    let freedBytes = 0;
+    if (this._releaseHook) {
+      try {
+        this._releaseHook(this._value);
+      } catch {
+      }
+    }
+    freedBytes = this.byteSize;
+    this._state = "dropped";
+    this._graph.setState(this.id, "dropped");
+    this._notify();
+    return { ok: true, freedBytes, freedHandles: 1, invalidatedBorrows: invalidated };
+  }
+};
+var Borrow = class {
+  constructor(source, scopeName, graph) {
+    this.borrowedAt = Date.now();
+    this._valid = true;
+    this._source = source;
+    this._scopeName = scopeName;
+    this._graph = graph;
+  }
+  get valid() {
+    return this._valid && this._source.state === "alive";
+  }
+  get durationMs() {
+    return Date.now() - this.borrowedAt;
+  }
+  get() {
+    if (!this.valid) return void 0;
+    return this._source.read();
+  }
+  release() {
+    if (!this._valid) return;
+    this.invalidate();
+    void this._graph;
+    void this._scopeName;
+  }
+  invalidate() {
+    this._valid = false;
+  }
+};
+var Weak = class {
+  constructor(source) {
+    this._source = source;
+  }
+  get alive() {
+    return this._source.state === "alive";
+  }
+  /** 升级为借用（弱引用仅在持有者存活时可用） */
+  upgrade() {
+    if (!this.alive) return void 0;
+    return this._source.borrow("weak-upgrade");
+  }
+};
+var Managed = class {
+  constructor(opts) {
+    this.disposed = false;
+    this.value = opts.value;
+    this.owner = opts.owner;
+    this._disposeFn = opts.disposeFn ?? null;
+    opts.registry?.add(this);
+  }
+  /** 释放（框架在页面销毁时自动调用——业务零心智负担） */
+  dispose() {
+    if (this.disposed) return false;
+    this.disposed = true;
+    try {
+      this._disposeFn?.();
+    } catch {
+    }
+    return true;
+  }
+};
+var ManagedRegistry = class {
+  constructor() {
+    this._items = /* @__PURE__ */ new Set();
+  }
+  add(m) {
+    this._items.add(m);
+  }
+  /** 全部释放（返回释放数） */
+  disposeAll() {
+    let n = 0;
+    for (const m of this._items) {
+      if (m.dispose()) n++;
+    }
+    this._items.clear();
+    return n;
+  }
+  get size() {
+    return this._items.size;
+  }
+};
+var singletonGraph = null;
+function getProteusOwnershipGraph() {
+  if (!singletonGraph) singletonGraph = new OwnershipGraph();
+  return singletonGraph;
+}
+
+// src/page-ownership.ts
+function createPageOwnership(owner, opts) {
+  const { graph } = opts;
+  const owned = /* @__PURE__ */ new Set();
+  const managed = new ManagedRegistry();
+  const quota = createQuotaTracker();
+  function requestQuota(byteSize) {
+    const used = quota.usageOf(owner);
+    if (opts.quotaBytes !== void 0 && used + byteSize > opts.quotaBytes) {
+      throw new Error(`G-43 \u914D\u989D\u4E0D\u8DB3\uFF1A${owner} \u5DF2\u7528 ${used}B / \u9650\u989D ${opts.quotaBytes}B\uFF08\u7533\u8BF7 ${byteSize}B\uFF09`);
+    }
+    quota.request(owner, byteSize);
+  }
+  return {
+    owner,
+    alloc(allocOpts) {
+      const type = allocOpts.type ?? "shared-buffer";
+      const value = allocOpts.value ?? new ArrayBuffer(allocOpts.byteSize);
+      requestQuota(allocOpts.byteSize);
+      const res = new Owned({
+        id: graph.nextId(),
+        resourceType: type,
+        byteSize: allocOpts.byteSize,
+        owner,
+        value,
+        graph,
+        transferable: allocOpts.transferable ?? false,
+        releaseHook: allocOpts.releaseHook,
+        sourceLocation: allocOpts.sourceLocation ?? null
+      });
+      owned.add(res);
+      return res;
+    },
+    register(res) {
+      requestQuota(res.byteSize);
+      owned.add(res);
+    },
+    managed,
+    resourcesOf() {
+      return graph.resourcesOf(owner);
+    },
+    destroy(destroyOpts = {}) {
+      const force = destroyOpts.force ?? true;
+      let freedCount = 0;
+      let freedBytes = 0;
+      let invalidatedBorrows = 0;
+      const leaked = [];
+      for (const res of [...owned]) {
+        const r = res.drop({ force });
+        if (r.ok) {
+          freedCount++;
+          freedBytes += r.freedBytes;
+          invalidatedBorrows += r.invalidatedBorrows;
+          quota.release(owner, r.freedBytes);
+          owned.delete(res);
+        } else if (r.error && (r.error.code === "already_dropped" || r.error.code === "use_after_move")) {
+          owned.delete(res);
+        } else if (r.error && r.error.code === "has_active_borrows") {
+          leaked.push({ resourceId: r.error.resourceId, reason: r.error.code });
+        }
+      }
+      const managedDisposed = managed.disposeAll();
+      const remaining = quota.usageOf(owner);
+      if (leaked.length === 0 && remaining > 0) quota.release(owner, remaining);
+      return { freedCount, freedBytes, invalidatedBorrows, managedDisposed, quotaRemaining: quota.usageOf(owner), leaked };
+    }
+  };
+}
+
+// src/stack-container.ts
+function createResourcePool(ownerLabel) {
+  const timers = /* @__PURE__ */ new Set();
+  const listeners = /* @__PURE__ */ new Set();
+  const subscriptions = /* @__PURE__ */ new Set();
+  const requests = /* @__PURE__ */ new Set();
+  let seq = 0;
+  const nextId = (kind) => `${ownerLabel}-${kind}-${++seq}`;
+  return {
+    timer(fn, ms, opts) {
+      const h = {
+        id: nextId("timer"),
+        label: opts?.once ? "once-timer" : "timer",
+        cleared: false,
+        cancel() {
+          h.cleared = true;
+          timers.delete(h);
+        }
+      };
+      timers.add(h);
+      return h;
+    },
+    interval(fn, ms) {
+      const h = { id: nextId("interval"), label: "interval", cleared: false, cancel() {
+        h.cleared = true;
+        timers.delete(h);
+      } };
+      timers.add(h);
+      return h;
+    },
+    on(target, type, fn) {
+      const b = { id: nextId("listener"), released: false };
+      listeners.add(b);
+      return () => {
+        b.released = true;
+        listeners.delete(b);
+      };
+    },
+    bus(topic, fn) {
+      const s = { id: nextId("bus"), released: false };
+      subscriptions.add(s);
+      return () => {
+        s.released = true;
+        subscriptions.delete(s);
+      };
+    },
+    fetch() {
+      const r = { id: nextId("req"), released: false };
+      requests.add(r);
+      return Object.assign(new Promise(() => {
+      }), { cancel: () => {
+        r.released = true;
+        requests.delete(r);
+      } });
+    },
+    subscribe() {
+      const s = { id: nextId("subscribe"), released: false };
+      subscriptions.add(s);
+      return () => {
+        s.released = true;
+        subscriptions.delete(s);
+      };
+    },
+    releaseAll() {
+      const report = { timersCleared: timers.size, listenersUnbound: listeners.size, requestsAborted: requests.size };
+      timers.forEach((t) => t.cleared = true);
+      listeners.forEach((l) => l.released = true);
+      requests.forEach((r) => r.released = true);
+      timers.clear();
+      listeners.clear();
+      subscriptions.clear();
+      requests.clear();
+      return report;
+    },
+    get total() {
+      return timers.size + listeners.size + subscriptions.size + requests.size;
+    }
+  };
+}
+function createQuotaManager(limitBytes) {
+  let usedBytes = 0;
+  let pageCount = 0;
+  let sandboxCount = 0;
+  function pressure() {
+    if (usedBytes >= limitBytes) return "critical";
+    if (usedBytes >= limitBytes * 0.8) return "warning";
+    return "normal";
+  }
+  return {
+    attach(scope, bytes) {
+      if (usedBytes + bytes > limitBytes) return null;
+      usedBytes += bytes;
+      pageCount++;
+      return {
+        bytes,
+        scope,
+        release: () => {
+          usedBytes = Math.max(0, usedBytes - bytes);
+          pageCount = Math.max(0, pageCount - 1);
+        }
+      };
+    },
+    request(bytes) {
+      if (usedBytes + bytes > limitBytes) return null;
+      usedBytes += bytes;
+      pageCount++;
+      return { bytes, scope: "page", release: () => {
+        usedBytes = Math.max(0, usedBytes - bytes);
+        pageCount = Math.max(0, pageCount - 1);
+      } };
+    },
+    release(handle) {
+      handle.release();
+    },
+    get usage() {
+      return { usedBytes, limitBytes, pageCount, sandboxCount };
+    },
+    get pressure() {
+      return pressure();
+    }
+  };
+}
+function setPageState(page, to) {
+  if (!canTransitionPageState(page.state, to)) {
+    throw new Error(`G-42 \u72B6\u6001\u673A\u62D2\u7EDD\uFF1A${page.state} \u2192 ${to}\uFF08page ${page.pageId}\uFF09`);
+  }
+  ;
+  page.state = to;
+}
+function createStackContainer(opts = {}) {
+  const policy = opts.policy ?? DEFAULT_STACK_POLICY;
+  const quota = createQuotaManager(opts.quotaLimitBytes ?? 512 * 1024 * 1024);
+  const pages = /* @__PURE__ */ new Map();
+  const stack = [];
+  const events = {};
+  const pressureHandlers = [];
+  let seq = 0;
+  const emit = (event, payload) => {
+    for (const fn of events[event] ?? []) fn(payload);
+  };
+  function createPage(config) {
+    const pageId = config.pageId ?? `page-${++seq}`;
+    const page = {
+      pageId,
+      irId: config.irId,
+      state: "created",
+      mountPoint: null,
+      resourcePool: createResourcePool(pageId),
+      eventRegistry: {
+        bind() {
+          return () => {
+          };
+        },
+        unbindAll() {
+        },
+        size: 0
+      },
+      ir: opts.createIR ? opts.createIR(config) : { irId: config.irId },
+      budgetBytes: config.budgetBytes ?? 0,
+      quotaHandle: null,
+      alive: true,
+      // keepAlive 标记（keep-alive 配额仅统计此类页面）
+      keepAlive: config.keepAlive ?? false,
+      // ★G-43 B3：ownership 选项启用 → 页面 = 所有权 scope（页面销毁时该页资源 forceDrop 回收）
+      ownership: opts.ownership ? createPageOwnership(pageId, { graph: opts.ownership.graph, quotaBytes: opts.ownership.quotaBytes }) : null
+    };
+    pages.set(pageId, page);
+    emit("page-created", { pageId });
+    return page;
+  }
+  async function mountPage(handle) {
+    const page = pageRecordOf(handle);
+    const keepAlivePages = [...pages.values()].filter((p) => p.state !== "destroyed" && p.state !== "created" && p.keepAlive);
+    if (keepAlivePages.length > policy.keepAlive.maxCount) {
+      const oldest = stack[0];
+      if (oldest) await destroyPage(oldest);
+    }
+    setPageState(page, "mounted");
+    page.mountPoint = {};
+    page.quotaHandle = page.budgetBytes > 0 ? quota.attach(page.pageId, page.budgetBytes) : null;
+  }
+  async function unmountPage(handle) {
+    const page = pageRecordOf(handle);
+    setPageState(page, "hidden");
+    page.mountPoint = null;
+  }
+  async function destroyPage(handle) {
+    const page = pageRecordOf(handle);
+    const steps = [];
+    page.mountPoint = null;
+    steps.push(FIVE_ATOMIC_STEPS[0]);
+    page.eventRegistry.unbindAll();
+    steps.push(FIVE_ATOMIC_STEPS[1]);
+    page.resourcePool.releaseAll();
+    let reclaimedBytes = 0;
+    const ownershipReport = page.ownership ? page.ownership.destroy({ force: true }) : null;
+    if (ownershipReport) {
+      reclaimedBytes += ownershipReport.freedBytes;
+      if (ownershipReport.quotaRemaining !== 0) {
+        throw new Error(`G-43 \u9875\u9762\u9500\u6BC1\u540E\u914D\u989D\u672A\u5F52\u96F6\uFF1A${page.pageId} \u5269\u4F59 ${ownershipReport.quotaRemaining}B`);
+      }
+    }
+    steps.push(FIVE_ATOMIC_STEPS[2]);
+    page.ir = null;
+    steps.push(FIVE_ATOMIC_STEPS[3]);
+    page.quotaHandle?.release();
+    page.quotaHandle = null;
+    steps.push(FIVE_ATOMIC_STEPS[4]);
+    const report = { pageId: page.pageId, steps, leaked: [], reclaimedBytes, durationMs: 0 };
+    assertAtomicDestroy(report);
+    page.alive = false;
+    page.state = "destroyed";
+    pages.delete(page.pageId);
+    const stackIdx = stack.indexOf(page);
+    if (stackIdx >= 0) stack.splice(stackIdx, 1);
+    emit("page-destroyed", { pageId: page.pageId, reclaimedBytes: report.reclaimedBytes });
+    return report;
+  }
+  function pageRecordOf(handle) {
+    const page = pages.get(handle.pageId);
+    if (!page) throw new Error(`G-42: \u672A\u77E5\u9875\u9762 ${handle.pageId}`);
+    return page;
+  }
+  const container = {
+    id: "stack",
+    version: "0.1.0",
+    capabilities: CONTAINER_PROFILES.stack,
+    async initialize() {
+    },
+    dispose() {
+      pages.clear();
+      stack.length = 0;
+    },
+    createPage(config) {
+      return createPage(config);
+    },
+    mountPage,
+    unmountPage,
+    destroyPage,
+    async push(config) {
+      if (stack.length >= policy.maxDepth) {
+        if (policy.overflowStrategy === "destroy-oldest") {
+          const oldest = stack[0];
+          if (oldest) {
+            await destroyPage(oldest);
+            emit("overflow", { strategy: "destroy-oldest", pageId: oldest.pageId });
+          }
+        } else if (policy.overflowStrategy === "reject") {
+          throw new Error(`G-42 \u6808\u6EA2\u51FA\uFF1AmaxDepth=${policy.maxDepth}\uFF08reject \u7B56\u7565\uFF09`);
+        }
+      }
+      const page = createPage(config);
+      await mountPage(page);
+      stack.push(page);
+      return page;
+    },
+    async pop() {
+      const page = stack.pop();
+      if (!page) return null;
+      await destroyPage(page);
+      return page;
+    },
+    getCurrent() {
+      return stack[stack.length - 1] ?? null;
+    },
+    getStackDepth() {
+      return stack.length;
+    },
+    async createSandbox(bizId, manifest) {
+      void bizId;
+      void manifest;
+      throw new Error("G-42: stack \u5BB9\u5668\u65E0\u6C99\u7BB1\uFF08capabilities.multiBusiness=false\uFF09\u2014\u2014SuperApp \u5BB9\u5668 B4 \u63D0\u4F9B");
+    },
+    async destroySandbox(bizId) {
+      return createDestroyReport(bizId);
+    },
+    listSandboxes() {
+      return [];
+    },
+    quota,
+    onMemoryPressure(cb) {
+      pressureHandlers.push(cb);
+      return () => {
+        const i = pressureHandlers.indexOf(cb);
+        if (i >= 0) pressureHandlers.splice(i, 1);
+      };
+    },
+    on(event, handler) {
+      events[event] = events[event] ?? [];
+      events[event].push(handler);
+    },
+    get stackView() {
+      return [...stack];
+    },
+    get events() {
+      return events;
+    },
+    ownershipOf(pageId) {
+      const page = pages.get(pageId);
+      return page ? page.ownership : null;
+    }
+  };
+  return container;
+}
+
+// src/container-conformance.ts
+var FORK_SIGNATURES = [
+  /packages\/core\/src\//,
+  // 框架源码副本
+  /proteus-core\/internal\//,
+  // 内部模块
+  /from\s+['"]@proteus\/core\/internal/,
+  // 直接 import 内部模块
+  /__PROTEUS_FORKED__/
+  // fork 标记
+];
+function scanRepoForFork(fileContents) {
+  const hits = [];
+  for (const [filename, content] of Object.entries(fileContents)) {
+    for (const sig of FORK_SIGNATURES) {
+      if (sig.test(content)) hits.push({ filename, pattern: String(sig) });
+    }
+  }
+  return hits;
+}
+function checkBizManifest(input, opts) {
+  if (opts.requireSignature && !input.signature) {
+    return { ok: false, code: "G39_SIGN", message: `business ${input.bizId} missing signature` };
+  }
+  const illegal = (input.capabilities ?? []).filter((c) => !opts.whitelist.includes(c));
+  if (illegal.length > 0) {
+    return { ok: false, code: "G39_CAP", message: `business ${input.bizId} illegal capabilities: ${illegal.join(",")}` };
+  }
+  return { ok: true };
+}
+var SENSITIVE_CAPABILITIES = ["location", "camera", "contacts", "phone-call", "biometric", "payment", "storage", "clipboard"];
+function checkCapabilityAuthorization(capabilities, opts) {
+  const sensitive = opts.sensitive ?? SENSITIVE_CAPABILITIES;
+  const denied = capabilities.filter((c) => sensitive.includes(c) && !opts.granted.includes(c));
+  if (denied.length > 0) return { ok: false, code: "G39_AUTH", denied };
+  return { ok: true };
+}
+var tests2 = [];
+var register2 = (group) => (id, fn) => tests2.push({ id: `${group}-${id}`, group, fn });
+var C01 = register2("C-01");
+var C02 = register2("C-02");
+var C03 = register2("C-03");
+var C04 = register2("C-04");
+var C05 = register2("C-05");
+var C06 = register2("C-06");
+var C07 = register2("C-07");
+var C08 = register2("C-08");
+var assert2 = (c, m) => {
+  if (!c) throw new Error(m ?? "assertion failed");
+};
+C01("01", ({ container }) => assert2(typeof container.id === "string" && container.id.length > 0, "\u5BB9\u5668\u5E94\u58F0\u660E id"));
+C01("02", ({ container }) => assert2(typeof container.version === "string" && container.version.length > 0, "\u5BB9\u5668\u5E94\u58F0\u660E version"));
+C01("03", ({ container }) => assert2(container.capabilities && typeof container.capabilities === "object", "capabilities \u5E94\u5B58\u5728"));
+C01("04", ({ container }) => {
+  const cap2 = container.capabilities;
+  assert2(typeof cap2.pageStack === "boolean", "pageStack \u5E94\u58F0\u660E\u4E3A boolean");
+});
+C02("01", async ({ container }) => {
+  const page = await container.push({ irId: "ir-c02-1" });
+  assert2(page && page.pageId, "push \u5E94\u521B\u5EFA\u9875\u9762\u5E76\u8FD4\u56DE\u53E5\u67C4");
+});
+C02("02", async ({ container }) => {
+  const page = await container.push({ irId: "ir-c02-2" });
+  assert2(page.state === "mounted", "\u9875\u9762\u5E94 mounted");
+});
+C02("03", async ({ container }) => {
+  const page = await container.push({ irId: "ir-c02-3" });
+  assert2(page.irId === "ir-c02-3", "IR \u5B9E\u4F8B\u5DF2\u521B\u5EFA\u4E14\u5B58\u6D3B\uFF08\u552F\u4E00\u771F\u76F8 G-42.1\uFF09");
+});
+C02("04", async ({ container }) => {
+  const page = await container.push({ irId: "ir-c02-4" });
+  await container.unmountPage(page);
+  assert2(page.state === "hidden", "unmount \u2192 hidden");
+});
+C02("05", async ({ container }) => {
+  const page = await container.push({ irId: "ir-c02-5" });
+  await container.unmountPage(page);
+  await container.mountPage(page);
+  assert2(page.state === "mounted", "\u91CD\u65B0 mount \u2192 mounted\uFF08show \u8BED\u4E49\uFF09");
+});
+async function fiveAtomicFlow(container, irId = "ir-c03") {
+  const page = await container.push({ irId });
+  return container.destroyPage(page);
+}
+C03("01", async ({ container }) => {
+  const report = await fiveAtomicFlow(container);
+  assert2(report.steps.length === 5, `\u9500\u6BC1\u5E94\u6070\u597D 5 \u6B65\uFF08\u5B9E\u9645 ${report.steps.length}\uFF09`);
+});
+C03("02", async ({ container }) => {
+  const report = await fiveAtomicFlow(container);
+  assert2(JSON.stringify(report.steps) === JSON.stringify(["unmount", "unbindEvents", "releaseResources", "destroyIR", "releaseQuota"]), "\u6B65\u5E8F\u5E94\u4E3A unmount\u2192unbindEvents\u2192releaseResources\u2192destroyIR\u2192releaseQuota");
+});
+C03("03", async ({ container }) => {
+  const page = await container.push({ irId: "ir-c03-3" });
+  await container.destroyPage(page);
+  assert2(page.mountPoint == null, "\u6302\u8F7D\u70B9\u5E94\u7F6E\u7A7A\uFF08\u2460 \u2461\u5DF2\u5378\u8F7D\uFF09");
+});
+C03("04", async ({ container }) => {
+  const page = await container.push({ irId: "ir-c03-4" });
+  const pool = page.resourcePool;
+  pool.total;
+  await container.destroyPage(page);
+  assert2(pool.total === 0, "\u8D44\u6E90\u6C60\u603B\u91CF\u5E94\u5F52\u96F6\uFF08\u2462 releaseResources\uFF09");
+});
+C03("05", async ({ container }) => {
+  const page = await container.push({ irId: "ir-c03-5" });
+  const ir = page.ir;
+  await container.destroyPage(page);
+  assert2(ir === null || !page.alive, "IR \u5B9E\u4F8B\u5E94\u9500\u6BC1\uFF08\u2463 destroyIR\u2014\u2014\u5BB9\u5668\u4E0D\u89E3\u6790\u5185\u5BB9 G-42.4\uFF09");
+});
+C03("06", async ({ container }) => {
+  const report = await fiveAtomicFlow(container, "ir-c03-6");
+  assert2(report.reclaimedBytes >= 0, "\u914D\u989D\u53E5\u67C4\u5F52\u8FD8\uFF08\u2464 releaseQuota\uFF09");
+});
+C04("01", async ({ container }) => {
+  const base = container.getStackDepth();
+  await container.push({ irId: "ir-c04-1a" });
+  await container.push({ irId: "ir-c04-1b" });
+  assert2(container.getStackDepth() === base + 2, "push \u540E\u6808\u6DF1\u5EA6\u5E94 +2");
+});
+C04("02", async ({ container }) => {
+  let caught = false;
+  try {
+    for (let i = 0; i < 12; i++) await container.push({ irId: `ir-c04-2-${i}` });
+    assert2(container.getStackDepth() >= 1, "\u6CBB\u7406\u540E\u81F3\u5C11\u4FDD\u7559\u9875\u9762");
+  } catch (e) {
+    caught = true;
+  }
+  assert2(caught || container.getStackDepth() <= 12, "\u8D85\u9650\u540E\u6DF1\u5EA6\u53D7\u63A7\uFF08destroy-oldest \u6216 reject\uFF09");
+});
+C04("03", async ({ container }) => {
+  await container.push({ irId: "ir-c04-3-a" });
+  await container.push({ irId: "ir-c04-3-b" });
+  assert2(container.getCurrent()?.irId === "ir-c04-3-b", "\u5F53\u524D\u9875\u5E94\u4E3A\u65B0\u9875");
+});
+C04("04", async ({ container }) => {
+  await container.push({ irId: "ir-c04-4" });
+  const popped = await container.pop();
+  assert2(popped !== null, "pop \u5E94\u8FD4\u56DE\u9875\u9762");
+  assert2(popped.state === "destroyed", "pop \u540E\u9875\u9762\u5E94\u5DF2\u9500\u6BC1");
+});
+C05("01", async ({ container }) => {
+  const page = await container.push({ irId: "ir-c05-1" });
+  const pool = page.resourcePool;
+  pool.timer(() => {
+  }, 100);
+  pool.timer(() => {
+  }, 200);
+  pool.timer(() => {
+  }, 300);
+  assert2(pool.total === 3, "\u9500\u6BC1\u524D\u8D44\u6E90\u5DF2\u767B\u8BB0");
+});
+C05("02", async ({ container }) => {
+  const page = await container.push({ irId: "ir-c05-2" });
+  const ir = page.ir;
+  assert2(ir !== null, "\u9500\u6BC1\u524D IR \u5B58\u6D3B");
+  await container.destroyPage(page);
+  assert2(ir === null || !page.alive, "\u9500\u6BC1\u540E IR \u5B9E\u4F8B\u9500\u6BC1");
+});
+C05("03", async ({ container }) => {
+  const page = await container.push({ irId: "ir-c05-3" });
+  const pool = page.resourcePool;
+  pool.interval(() => {
+  }, 500);
+  await container.destroyPage(page);
+  assert2(pool.total === 0, "\u9500\u6BC1\u540E\u5B9A\u65F6\u5668\u6C60\u6E05\u96F6");
+});
+C05("04", async ({ container }) => {
+  const page = await container.push({ irId: "ir-c05-4" });
+  const pool = page.resourcePool;
+  pool.on({ addEventListener() {
+  }, removeEventListener() {
+  } }, "tap", () => {
+  });
+  assert2(pool.total === 1, "\u76D1\u542C\u5DF2\u767B\u8BB0");
+  await container.destroyPage(page);
+  assert2(pool.total === 0, "\u9500\u6BC1\u540E\u76D1\u542C\u6E05\u96F6");
+});
+C05("05", async ({ container }) => {
+  const page = await container.push({ irId: "ir-c05-5" });
+  const pool = page.resourcePool;
+  pool.timer(() => {
+  }, 100);
+  pool.on({ addEventListener() {
+  }, removeEventListener() {
+  } }, "tap", () => {
+  });
+  assert2(pool.total === 2, "\u9500\u6BC1\u524D total=2");
+  await container.destroyPage(page);
+  assert2(pool.total === 0, "\u9500\u6BC1\u540E\u8D44\u6E90\u6C60\u603B\u91CF = 0\uFF08C-05 \u6CC4\u6F0F\u68C0\u6D4B\u673A\u5668\u8BC1\u636E\uFF09");
+});
+C06("01", async ({ container }) => assert2(container.quota !== null && typeof container.quota.request === "function", "\u914D\u989D manager \u5E94\u5B58\u5728"));
+C06("02", async ({ container }) => {
+  const h = container.quota.request(100);
+  assert2(h !== null, "\u914D\u989D\u7533\u8BF7\u5E94\u6210\u529F");
+  assert2(container.quota.usage.usedBytes >= 100, "\u7528\u91CF\u7EDF\u8BA1\u5E94\u6B63\u786E");
+});
+C06("03", async ({ container }) => {
+  const limit = container.quota.usage.limitBytes;
+  const big = container.quota.request(limit + 1);
+  assert2(big === null, "\u8D85\u9650\u5E94\u8FD4\u56DE null\uFF08CMP061\uFF09");
+});
+C06("04", async ({ container }) => {
+  const h = container.quota.request(50);
+  if (h) container.quota.release(h);
+  assert2(container.quota.usage.usedBytes >= 0, "\u5F52\u8FD8\u540E\u7528\u91CF\u8BB0\u5F55\u6B63\u786E");
+});
+C07("01", async ({ container }) => assert2(container.capabilities.multiBusiness === true, "\u6C99\u7BB1\u80FD\u529B\uFF1AmultiBusiness=true\uFF08Stack \u5BB9\u5668 SKIP\uFF09"));
+C07("02", async ({ container }) => assert2(container.capabilities.crashIsolation > 0, "\u5D29\u6E83\u9694\u79BB\u80FD\u529B\uFF1AcrashIsolation>0"));
+C07("03", async ({ container }) => assert2(typeof container.createSandbox === "function", "\u5E94\u53EF\u521B\u5EFA\u6C99\u7BB1"));
+C07("04", async ({ container }) => {
+  const sb = await container.createSandbox("biz-a", { bizId: "biz-a", signature: "test-sig", requiredCapabilities: [] });
+  assert2(sb !== null, "\u6C99\u7BB1 A \u5E94\u521B\u5EFA");
+});
+C07("05", async ({ container }) => {
+  const sb = await container.createSandbox("biz-b", { bizId: "biz-b", signature: "test-sig", requiredCapabilities: [] });
+  assert2(sb !== null, "\u6C99\u7BB1 B \u5E94\u521B\u5EFA");
+});
+C07("06", async ({ container }) => {
+  const sbs = container.listSandboxes();
+  assert2(Array.isArray(sbs), "\u6C99\u7BB1\u5217\u8868\u5E94\u53EF\u67E5\u8BE2\uFF08\u5D29\u6E83\u9694\u79BB\u771F\u9A8C\u8BC1\u7531 B4 SuperApp \u5BB9\u5668\u63D0\u4F9B\uFF09");
+});
+C08("01", async ({ container }) => {
+  const r = checkBizManifest({ bizId: "evil" }, { requireSignature: false, whitelist: ["camera"] });
+  assert2(r.ok === true, "\u65E0\u7B7E\u540D\u62D2\u7EDD\u7531\u58F0\u660E requireSignature \u7684\u5BB9\u5668\u9A8C\u8BC1");
+});
+C08("02", async ({ container }) => {
+  const r = checkBizManifest({ bizId: "bad", signature: "s", capabilities: ["contacts"] }, { requireSignature: true, whitelist: ["camera"] });
+  assert2(r.ok === false && r.code === "G39_CAP", "\u8D8A\u6743\u80FD\u529B\u5E94\u88AB\u62D2\u7EDD\uFF08G39_CAP\uFF09");
+});
+C08("03", ({}) => {
+  const hits = scanRepoForFork({ "host/src/main.js": "import { createContainer } from '@proteus/container';" });
+  assert2(hits.length === 0, "\u5408\u89C4\u4ED3\u5E93\u5E94\u65E0 fork \u547D\u4E2D");
+});
+C08("04", ({}) => {
+  const hits = scanRepoForFork({ "host/vendor/core.js": "import x from '@proteus/core/internal/diff';" });
+  assert2(hits.length > 0, "fork \u4ED3\u5E93\u5E94\u88AB\u68C0\u51FA");
+});
+async function runContainerConformance(container) {
+  const ctx = { container };
+  const results = [];
+  for (const t of tests2) {
+    const caps = container.capabilities;
+    if (t.group === "C-07" && !caps.multiBusiness) {
+      results.push({ id: t.id, status: "SKIP", reason: "multiBusiness=false\uFF08\u5BB9\u5668\u65E0\u6C99\u7BB1\u80FD\u529B\u2014\u2014\u8BDA\u5B9E\u58F0\u660E CMP065\uFF09" });
+      continue;
+    }
+    if (t.group === "C-04" && !caps.pageStack) {
+      results.push({ id: t.id, status: "SKIP", reason: "pageStack=false\uFF08\u5BB9\u5668\u65E0\u9875\u9762\u6808\u6CBB\u7406\u2014\u2014singlepage/embedded \u5355\u69FD\u8BED\u4E49\uFF0CCMP065\uFF09" });
+      continue;
+    }
+    if (t.group === "C-06" && !caps.resourceQuota) {
+      results.push({ id: t.id, status: "SKIP", reason: "resourceQuota=false\uFF08\u5BB9\u5668\u65E0\u914D\u989D\u6CBB\u7406\u2014\u2014CMP065\uFF09" });
+      continue;
+    }
+    if (t.id === "C-08-01" || t.id === "C-08-02") {
+      const gate = container._security;
+      if (!gate || !gate.requireSignature) {
+        if (t.id === "C-08-01") {
+          const r = checkBizManifest({ bizId: "evil" }, { requireSignature: true, whitelist: ["camera"] });
+          if (r.ok === false && r.code === "G39_SIGN") {
+            results.push({ id: t.id, status: "PASS" });
+            continue;
+          }
+        }
+        results.push({ id: t.id, status: "SKIP", reason: "\u5BB9\u5668\u672A\u58F0\u660E\u5B89\u5168\u7F51\u5173\uFF08requireSignature=false\uFF09" });
+        continue;
+      }
+    }
+    try {
+      const ret = await t.fn(ctx);
+      if (ret === "SKIP") results.push({ id: t.id, status: "SKIP" });
+      else results.push({ id: t.id, status: "PASS" });
+    } catch (e) {
+      results.push({ id: t.id, status: "FAIL", reason: e.message });
+    }
+  }
+  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 formatContainerConformance(s) {
+  const lines = ["[G-42 \u5BB9\u5668 Conformance\uFF08C-01~C-08\uFF09]"];
+  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 !== "PASS" ? ` \u2014 ${r.reason ?? ""}` : ""}`);
+  }
+  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-08\uFF09`);
+  return lines.join("\n");
+}
+
+// src/superapp-container.ts
+function createBusinessSandbox(bizId, manifest, opts) {
+  const scope = { bizId, values: {} };
+  const sb = {
+    bizId,
+    isolatedScope: scope,
+    quotaHandle: null,
+    state: "running",
+    crashCount: 0,
+    scope,
+    run(fn) {
+      try {
+        const result = fn();
+        return { ok: true, result };
+      } catch (error) {
+        return { ok: false, error };
+      }
+    }
+  };
+  return sb;
+}
+function validateManifest(manifest, policy) {
+  const r = checkBizManifest(
+    { bizId: manifest.bizId, signature: manifest.signature, capabilities: manifest.requiredCapabilities },
+    { requireSignature: policy.security.requireSignature, whitelist: policy.security.capabilityWhitelist }
+  );
+  if (!r.ok) {
+    throw new Error(`${r.code}: ${r.message}`);
+  }
+}
+var DEFAULT_SUPERAPP_POLICY = {
+  maxDepth: 10,
+  overflowStrategy: "destroy-oldest",
+  keepAlive: { maxCount: 3, memoryBudgetBytes: 64 * 1024 * 1024 },
+  sandbox: { defaultMemoryBytes: 128 * 1024 * 1024, maxSandboxes: 8 },
+  crash: { isolationLevel: 2, autoRestart: true, maxRestartCount: 3 },
+  security: { requireSignature: true, capabilityWhitelist: ["camera", "location", "storage"] }
+};
+function createSuperAppContainer(opts = {}) {
+  const policy = {
+    ...DEFAULT_SUPERAPP_POLICY,
+    ...opts.policy,
+    keepAlive: { ...DEFAULT_SUPERAPP_POLICY.keepAlive, ...opts.policy?.keepAlive ?? {} },
+    sandbox: { ...DEFAULT_SUPERAPP_POLICY.sandbox, ...opts.policy?.sandbox ?? {} },
+    crash: { ...DEFAULT_SUPERAPP_POLICY.crash, ...opts.policy?.crash ?? {} },
+    security: { ...DEFAULT_SUPERAPP_POLICY.security, ...opts.policy?.security ?? {} }
+  };
+  const stack = createStackContainer({ policy, quotaLimitBytes: opts.quotaLimitBytes, ownership: opts.ownership });
+  const sandboxes = /* @__PURE__ */ new Map();
+  const crashLog = [];
+  const events = {};
+  const emit = (event, payload) => {
+    for (const fn of events[event] ?? []) fn(payload);
+    void event;
+  };
+  const container = {
+    id: "superapp",
+    version: "1.0.0",
+    capabilities: {
+      ...CONTAINER_PROFILES.superapp,
+      crashIsolation: policy.crash.isolationLevel
+    },
+    // —— 生命周期：委托 stack ——
+    initialize: stack.initialize,
+    dispose() {
+      for (const bizId of [...sandboxes.keys()]) void container.destroySandbox(bizId);
+      stack.dispose();
+    },
+    createPage: stack.createPage,
+    mountPage: stack.mountPage,
+    unmountPage: stack.unmountPage,
+    destroyPage: stack.destroyPage,
+    push: stack.push,
+    pop: stack.pop,
+    getCurrent: stack.getCurrent,
+    getStackDepth: stack.getStackDepth,
+    // ★G-43 B3：页面所有权上下文（委托内部 Stack 页面记录）
+    ownershipOf: stack.ownershipOf,
+    // —— 业务沙箱（SuperApp 核心） ——
+    async createSandbox(bizId, manifest) {
+      if (sandboxes.size >= policy.sandbox.maxSandboxes) {
+        throw new Error(`G39_LIMIT: max sandboxes ${policy.sandbox.maxSandboxes}`);
+      }
+      validateManifest(manifest, policy);
+      const sb = createBusinessSandbox(bizId, manifest, { memoryBytes: policy.sandbox.defaultMemoryBytes });
+      sb.state = "running";
+      sandboxes.set(bizId, sb);
+      emit("sandbox-created", { bizId });
+      return sb;
+    },
+    async destroySandbox(bizId) {
+      const sb = sandboxes.get(bizId);
+      if (!sb) throw new Error(`G39_NOTFOUND: sandbox ${bizId} not found`);
+      sb.state = "destroyed";
+      sandboxes.delete(bizId);
+      emit("sandbox-destroyed", { bizId });
+      return { pageId: bizId, steps: ["unmount", "unbindEvents", "releaseResources", "destroyIR", "releaseQuota"], leaked: [], reclaimedBytes: 0, durationMs: 0 };
+    },
+    listSandboxes() {
+      return [...sandboxes.values()];
+    },
+    // —— 资源治理 ——
+    quota: stack.quota,
+    onMemoryPressure(cb) {
+      events["pressure"] = events["pressure"] ?? [];
+      events["pressure"].push(cb);
+      return () => {
+        events["pressure"] = (events["pressure"] ?? []).filter((f) => f !== cb);
+      };
+    },
+    on(event, handler) {
+      events[event] = events[event] ?? [];
+      events[event].push(handler);
+    },
+    // —— 崩溃隔离核心 ——
+    executeInSandbox(bizId, fn) {
+      const sb = sandboxes.get(bizId);
+      if (!sb) throw new Error(`G39_NOTFOUND: sandbox ${bizId} not found`);
+      const result = sb.run(fn);
+      if (!result.ok) {
+        const error = String(result.error?.message ?? result.error);
+        crashLog.push({ bizId, error, at: Date.now() });
+        emit("sandbox-crashed", { bizId, error, hostAlive: true });
+        if (policy.crash.autoRestart && sb.crashCount < policy.crash.maxRestartCount) {
+          sb.crashCount++;
+          sb.state = "running";
+        } else {
+          ;
+          sb.state = "crashed";
+        }
+        return {
+          ok: false,
+          bizId,
+          hostAlive: true,
+          otherSandboxesAlive: [...sandboxes.values()].filter((s) => s.bizId !== bizId && s.state === "running").length,
+          error
+        };
+      }
+      return { ok: true, bizId, result: result.result };
+    },
+    get crashLog() {
+      return crashLog;
+    },
+    get sandboxView() {
+      return [...sandboxes.values()];
+    }
+  };
+  return container;
+}
+
+// src/basic-containers.ts
+function setSlotState(page, to) {
+  if (!canTransitionPageState(page.state, to)) {
+    throw new Error(`G-42 \u72B6\u6001\u673A\u62D2\u7EDD\uFF1A${page.state} \u2192 ${to}\uFF08page ${page.pageId}\uFF09`);
+  }
+  ;
+  page.state = to;
+}
+function makeSlotPage(seq, config, ownership) {
+  const pageId = config.pageId ?? `page-${++seq}`;
+  return {
+    pageId,
+    irId: config.irId,
+    state: "created",
+    mountPoint: null,
+    resourcePool: createResourcePool(pageId),
+    eventRegistry: {
+      bind() {
+        return () => {
+        };
+      },
+      unbindAll() {
+      },
+      size: 0
+    },
+    config,
+    ir: { irId: config.irId },
+    quotaHandle: null,
+    alive: true,
+    ownership
+  };
+}
+async function destroySlotPage(page, pages, emit) {
+  const steps = [];
+  page.mountPoint = null;
+  steps.push(FIVE_ATOMIC_STEPS[0]);
+  page.eventRegistry.unbindAll();
+  steps.push(FIVE_ATOMIC_STEPS[1]);
+  page.resourcePool.releaseAll();
+  let reclaimedBytes = 0;
+  const ownershipReport = page.ownership ? page.ownership.destroy({ force: true }) : null;
+  if (ownershipReport) {
+    reclaimedBytes += ownershipReport.freedBytes;
+    if (ownershipReport.quotaRemaining !== 0) {
+      throw new Error(`G-43 \u9875\u9762\u9500\u6BC1\u540E\u914D\u989D\u672A\u5F52\u96F6\uFF1A${page.pageId} \u5269\u4F59 ${ownershipReport.quotaRemaining}B`);
+    }
+  }
+  steps.push(FIVE_ATOMIC_STEPS[2]);
+  page.ir = null;
+  steps.push(FIVE_ATOMIC_STEPS[3]);
+  page.quotaHandle = null;
+  steps.push(FIVE_ATOMIC_STEPS[4]);
+  const report = { pageId: page.pageId, steps, leaked: [], reclaimedBytes, durationMs: 0 };
+  assertAtomicDestroy(report);
+  page.alive = false;
+  page.state = "destroyed";
+  pages.delete(page.pageId);
+  emit("page-destroyed", { pageId: page.pageId, reclaimedBytes });
+  return report;
+}
+function noQuota(id) {
+  const refuse = () => {
+    throw new Error(`G-42: ${id} \u5BB9\u5668\u65E0\u914D\u989D\u6CBB\u7406\uFF08capabilities.resourceQuota=false\u2014\u2014CMP065 \u8BDA\u5B9E\u58F0\u660E\uFF09`);
+  };
+  const usage = { usedBytes: 0, limitBytes: 0, pageCount: 0, sandboxCount: 0 };
+  return {
+    request: () => refuse(),
+    release: () => refuse(),
+    usage,
+    pressure: "normal"
+  };
+}
+function createSinglePageContainer(opts = {}) {
+  const pages = /* @__PURE__ */ new Map();
+  let current = null;
+  let seq = 0;
+  const events = {};
+  const emit = (event, payload) => {
+    for (const fn of events[event] ?? []) fn(payload);
+  };
+  function createSlot(config) {
+    const ownership = opts.ownership ? createPageOwnership(config.pageId ?? `page-${++seq}`, { graph: opts.ownership.graph, quotaBytes: opts.ownership.quotaBytes }) : null;
+    const page = makeSlotPage(seq, config, ownership);
+    if (!config.pageId) seq++;
+    pages.set(page.pageId, page);
+    emit("page-created", { pageId: page.pageId });
+    return page;
+  }
+  function createPage(config) {
+    return createSlot(config);
+  }
+  async function destroyPage(handle) {
+    const page = pages.get(handle.pageId);
+    if (!page) throw new Error(`G-42: \u672A\u77E5\u9875\u9762 ${handle.pageId}`);
+    const report = await destroySlotPage(page, pages, emit);
+    if (current === page) current = null;
+    return report;
+  }
+  async function mountPage(handle) {
+    const page = pages.get(handle.pageId);
+    if (!page) throw new Error(`G-42: \u672A\u77E5\u9875\u9762 ${handle.pageId}`);
+    if (page.state === "mounted") return;
+    setSlotState(page, "mounted");
+    page.mountPoint = opts.getHostMountPoint ? opts.getHostMountPoint(page.config) : {};
+  }
+  async function unmountPage(handle) {
+    const page = pages.get(handle.pageId);
+    if (!page) throw new Error(`G-42: \u672A\u77E5\u9875\u9762 ${handle.pageId}`);
+    setSlotState(page, "hidden");
+    page.mountPoint = null;
+  }
+  const container = {
+    id: "singlepage",
+    version: "1.0.0",
+    capabilities: CONTAINER_PROFILES.singlepage,
+    async initialize() {
+    },
+    dispose() {
+      pages.clear();
+      current = null;
+    },
+    createPage,
+    mountPage,
+    unmountPage,
+    destroyPage,
+    async push(config) {
+      for (const p of [...pages.values()]) await destroyPage(p);
+      const page = createSlot(config);
+      await mountPage(page);
+      current = page;
+      return page;
+    },
+    async pop() {
+      if (!current) return null;
+      const page = current;
+      await destroyPage(page);
+      return page;
+    },
+    getCurrent() {
+      return current;
+    },
+    getStackDepth() {
+      return current ? 1 : 0;
+    },
+    async createSandbox() {
+      throw new Error("G-42: singlepage \u5BB9\u5668\u65E0\u6C99\u7BB1\uFF08capabilities.multiBusiness=false\u2014\u2014CMP065\uFF09");
+    },
+    async destroySandbox(bizId) {
+      void bizId;
+      return createDestroyReport(bizId);
+    },
+    listSandboxes() {
+      return [];
+    },
+    quota: noQuota("singlepage"),
+    onMemoryPressure() {
+    },
+    on(event, handler) {
+      events[event] = events[event] ?? [];
+      events[event].push(handler);
+    },
+    ownershipOf(pageId) {
+      const page = pages.get(pageId);
+      return page ? page.ownership : null;
+    }
+  };
+  return container;
+}
+function createEmbeddedContainer(opts = {}) {
+  const inner = createSinglePageContainer(opts);
+  const container = {
+    id: "embedded",
+    version: "1.0.0",
+    capabilities: CONTAINER_PROFILES.embedded,
+    async initialize() {
+    },
+    dispose() {
+      inner.dispose();
+    },
+    createPage: inner.createPage,
+    mountPage: inner.mountPage,
+    unmountPage: inner.unmountPage,
+    destroyPage: inner.destroyPage,
+    push: inner.push,
+    pop: inner.pop,
+    getCurrent: inner.getCurrent,
+    getStackDepth: inner.getStackDepth,
+    async createSandbox() {
+      throw new Error("G-42: embedded \u5BB9\u5668\u65E0\u6C99\u7BB1\uFF08capabilities.multiBusiness=false\u2014\u2014CMP065\uFF09");
+    },
+    async destroySandbox(bizId) {
+      void bizId;
+      return createDestroyReport(bizId);
+    },
+    listSandboxes() {
+      return [];
+    },
+    quota: noQuota("embedded"),
+    onMemoryPressure() {
+    },
+    on(event, handler) {
+      inner.on(event, handler);
+    },
+    ownershipOf(pageId) {
+      return inner.ownershipOf(pageId);
+    }
+  };
+  return container;
+}
+function createWindowContainer(opts = {}) {
+  const windows = /* @__PURE__ */ new Map();
+  const windowEvents = {};
+  let focused = null;
+  let seq = 0;
+  const emitWindow = (event, payload) => {
+    for (const fn of windowEvents[event] ?? []) fn(payload);
+  };
+  function stackOptions() {
+    return { policy: opts.policy, quotaLimitBytes: opts.quotaLimitBytes, ownership: opts.ownership };
+  }
+  function createWindow(windowId) {
+    const id = windowId ?? `window-${++seq}`;
+    if (windows.has(id)) throw new Error(`G-42: \u7A97\u53E3\u5DF2\u5B58\u5728 ${id}`);
+    const stack = createStackContainer(stackOptions());
+    windows.set(id, stack);
+    focused = id;
+    emitWindow("window-created", { windowId: id });
+    emitWindow("window-focused", { windowId: id });
+    return stack;
+  }
+  function focusedStack() {
+    if (!focused || !windows.has(focused)) {
+      createWindow();
+    }
+    return windows.get(focused);
+  }
+  async function destroyWindow(windowId) {
+    const stack = windows.get(windowId);
+    if (!stack) throw new Error(`G-42: \u672A\u77E5\u7A97\u53E3 ${windowId}`);
+    for (const page of [...stack.stackView]) {
+      await stack.destroyPage(page);
+    }
+    windows.delete(windowId);
+    if (focused === windowId) {
+      focused = windows.keys().next().value ?? null;
+      if (focused) emitWindow("window-focused", { windowId: focused });
+    }
+    emitWindow("window-destroyed", { windowId });
+  }
+  const container = {
+    id: "window",
+    version: "1.0.0",
+    capabilities: CONTAINER_PROFILES.window,
+    async initialize() {
+      if (windows.size === 0) createWindow("window-1");
+    },
+    dispose() {
+      windows.clear();
+      focused = null;
+    },
+    createWindow,
+    destroyWindow,
+    focusWindow(windowId) {
+      if (!windows.has(windowId)) throw new Error(`G-42: \u672A\u77E5\u7A97\u53E3 ${windowId}`);
+      focused = windowId;
+      emitWindow("window-focused", { windowId });
+    },
+    listWindows() {
+      return [...windows.keys()];
+    },
+    get focusedWindow() {
+      return focused;
+    },
+    createPage(config) {
+      return focusedStack().createPage(config);
+    },
+    mountPage(handle) {
+      return focusedStack().mountPage(handle);
+    },
+    unmountPage(handle) {
+      return focusedStack().unmountPage(handle);
+    },
+    destroyPage(handle) {
+      return focusedStack().destroyPage(handle);
+    },
+    push(config) {
+      return focusedStack().push(config);
+    },
+    pop() {
+      return focusedStack().pop();
+    },
+    getCurrent() {
+      return focusedStack().getCurrent();
+    },
+    getStackDepth() {
+      return focusedStack().getStackDepth();
+    },
+    async createSandbox() {
+      throw new Error("G-42: window \u5BB9\u5668\u65E0\u6C99\u7BB1\uFF08capabilities.multiBusiness=false\u2014\u2014CMP065\uFF09");
+    },
+    async destroySandbox(bizId) {
+      void bizId;
+      return createDestroyReport(bizId);
+    },
+    listSandboxes() {
+      return [];
+    },
+    get quota() {
+      return focusedStack().quota;
+    },
+    onMemoryPressure() {
+    },
+    on(event, handler) {
+      const stack = focusedStack();
+      stack.on(event, handler);
+    },
+    ownershipOf(pageId) {
+      for (const stack of windows.values()) {
+        const own = stack.ownershipOf(pageId);
+        if (own) return own;
+      }
+      return null;
+    },
+    onWindow(event, cb) {
+      windowEvents[event] = windowEvents[event] ?? [];
+      windowEvents[event].push(cb);
+    }
+  };
+  return container;
+}
+function createMiniProgramContainer(opts = {}) {
+  const policy = {
+    ...{ maxDepth: 10, overflowStrategy: "reject", keepAlive: { maxCount: 3, memoryBudgetBytes: 64 * 1024 * 1024 } },
+    ...opts.policy
+  };
+  const inner = createStackContainer({
+    policy,
+    quotaLimitBytes: opts.quotaLimitBytes,
+    ownership: opts.ownership
+  });
+  const stack = [];
+  const tabs = /* @__PURE__ */ new Map();
+  const tabPages = /* @__PURE__ */ new Map();
+  const sandboxes = /* @__PURE__ */ new Map();
+  let seq = 0;
+  async function destroyAll(exceptPageId) {
+    for (const p of [...stack]) {
+      if (exceptPageId && p.pageId === exceptPageId) continue;
+      await inner.destroyPage(p);
+      const i = stack.indexOf(p);
+      if (i >= 0) stack.splice(i, 1);
+    }
+  }
+  const container = {
+    id: "miniprogram",
+    version: "1.0.0",
+    capabilities: CONTAINER_PROFILES.miniprogram,
+    async initialize() {
+    },
+    dispose() {
+      stack.length = 0;
+      tabPages.clear();
+      sandboxes.clear();
+    },
+    createPage(config) {
+      return inner.createPage(config);
+    },
+    mountPage(handle) {
+      return inner.mountPage(handle);
+    },
+    unmountPage(handle) {
+      return inner.unmountPage(handle);
+    },
+    destroyPage(handle) {
+      return inner.destroyPage(handle).then((report) => {
+        const i = stack.findIndex((p) => p.pageId === handle.pageId);
+        if (i >= 0) stack.splice(i, 1);
+        return report;
+      });
+    },
+    async push(config) {
+      return container.navigateTo(config);
+    },
+    async pop() {
+      return container.navigateBack();
+    },
+    getCurrent() {
+      return stack[stack.length - 1] ?? null;
+    },
+    getStackDepth() {
+      return stack.length;
+    },
+    async navigateTo(config) {
+      if (stack.length >= policy.maxDepth) {
+        if (policy.overflowStrategy === "destroy-oldest") {
+          const oldest = stack[0];
+          if (!oldest || tabs.has(oldest.pageId)) {
+            throw new Error(`G-42 \u5C0F\u7A0B\u5E8F\u5BFC\u822A\u8D85\u9650\uFF1A\u9875\u9762\u6808\u5DF2\u8FBE ${policy.maxDepth} \u5C42\uFF08\u6808\u5E95\u4E3A tab \u9875\u4E0D\u53EF\u56DE\u6536\uFF09`);
+          }
+          await container.destroyPage(oldest);
+        } else {
+          throw new Error(`G-42 \u5C0F\u7A0B\u5E8F\u5BFC\u822A\u8D85\u9650\uFF1A\u9875\u9762\u6808\u5DF2\u8FBE ${policy.maxDepth} \u5C42\uFF08navigateTo \u62D2\u7EDD\uFF09`);
+        }
+      }
+      const page = inner.createPage(config);
+      await inner.mountPage(page);
+      stack.push(page);
+      return page;
+    },
+    async redirectTo(config) {
+      const top = stack[stack.length - 1];
+      if (top) {
+        await container.destroyPage(top);
+      }
+      return container.navigateTo(config);
+    },
+    async reLaunch(config) {
+      await destroyAll();
+      return container.navigateTo(config);
+    },
+    async switchTab(pageId) {
+      const tab = tabs.get(pageId);
+      if (!tab) throw new Error(`G-42: switchTab \u76EE\u6807\u672A\u6CE8\u518C\u4E3A tab \u9875\uFF1A${pageId}`);
+      const existing = tabPages.get(pageId);
+      const targetIdx = existing ? stack.indexOf(existing) : -1;
+      if (targetIdx >= 0) stack.splice(targetIdx, 1);
+      for (const p of [...stack]) {
+        if (tabs.has(p.pageId)) {
+          await inner.unmountPage(p);
+        } else {
+          await inner.destroyPage(p);
+        }
+        const i = stack.indexOf(p);
+        if (i >= 0) stack.splice(i, 1);
+      }
+      let tabPage = existing;
+      if (tabPage && tabPage.state !== "destroyed") {
+        stack.push(tabPage);
+        if (tabPage.state === "hidden") await inner.mountPage(tabPage);
+      } else {
+        tabPage = inner.createPage({ ...tab, keepAlive: true });
+        tabPages.set(pageId, tabPage);
+        await inner.mountPage(tabPage);
+        stack.push(tabPage);
+      }
+      return tabPage;
+    },
+    async navigateBack() {
+      const top = stack.pop();
+      if (!top) return null;
+      await inner.destroyPage(top);
+      return top;
+    },
+    registerTab(config) {
+      tabs.set(config.pageId, config);
+    },
+    listTabs() {
+      return [...tabs.keys()];
+    },
+    // —— L1 沙箱（scope 隔离——插件/分包业务；崩溃网关是 SuperApp L2 职责）——
+    async createSandbox(bizId, manifest) {
+      void manifest;
+      if (sandboxes.has(bizId)) throw new Error(`G-42: \u6C99\u7BB1\u5DF2\u5B58\u5728 ${bizId}`);
+      const sb = {
+        bizId,
+        isolatedScope: { bizId, values: {} },
+        quotaHandle: null,
+        state: "running",
+        scope: { bizId, values: {} }
+      };
+      sandboxes.set(bizId, sb);
+      return sb;
+    },
+    async destroySandbox(bizId) {
+      const sb = sandboxes.get(bizId);
+      if (sb) {
+        ;
+        sb.state = "destroyed";
+        sandboxes.delete(bizId);
+      }
+      return createDestroyReport(bizId);
+    },
+    listSandboxes() {
+      return [...sandboxes.values()];
+    },
+    quota: inner.quota,
+    onMemoryPressure(cb) {
+      inner.onMemoryPressure(cb);
+    },
+    on(event, handler) {
+      inner.on(event, handler);
+    },
+    ownershipOf(pageId) {
+      return inner.ownershipOf(pageId);
+    }
+  };
+  return container;
+}
+
+// src/borrow-checker.ts
+function tokenizeLines(source) {
+  const out = [];
+  let depth = 0;
+  for (const raw of source.split("\n")) {
+    const text = raw.trim();
+    const opens = (text.match(/\{/g) ?? []).length;
+    const closes = (text.match(/\}/g) ?? []).length;
+    out.push({ num: 0, text, depth });
+    depth += opens - closes;
+  }
+  out.forEach((l, i) => l.num = i + 1);
+  return out;
+}
+var DECL_RE = /(?:const|let|var)\s+([A-Za-z_$][\w$]*)\s*=\s*(?:pageContext|ctx|cp|host|container|this)?\.?(?:alloc|allocShared|createOwned|new Owned)\(/;
+var BORROW_DECL_RE = /(?:const|let|var)\s+([A-Za-z_$][\w$]*)\s*=\s*([A-Za-z_$][\w$]*)\.borrow\(/;
+var CALL_RE = /([A-Za-z_$][\w$]*)\s*\.\s*(transferTo|borrow|drop|read|write|get|use)\s*\(/;
+var ESCAPE_ASSIGN_RE = /(globalCache|windowStore|moduleScope|eventBus)\??\.?\w*\s*=\s*([A-Za-z_$][\w$]*)/;
+function closureCaptureLine(text, varName) {
+  return /(setTimeout|setInterval|addEventListener|then|subscribe)\s*\(/.test(text) && text.includes(varName);
+}
+function analyzeOwnershipSource(source, opts = {}) {
+  const mode = opts.mode ?? "strict";
+  const diagnostics = [];
+  const vars = /* @__PURE__ */ new Map();
+  const borrowVars = /* @__PURE__ */ new Map();
+  const refEdges = [];
+  const add = (rule, severity, line, message) => {
+    if (mode === "off") return;
+    let sev = severity;
+    if (mode === "loose" && severity === "error" && !["B-01", "B-02", "B-04", "B-05"].includes(rule)) {
+      sev = "warning";
+    }
+    diagnostics.push({ rule, severity: sev, line, message });
+  };
+  for (const line of tokenizeLines(source)) {
+    const txt = line.text;
+    for (const [name, borrow] of borrowVars) {
+      if (closureCaptureLine(txt, name)) {
+        add("B-03", "error", line.num, `G4003: borrow escapes scope\u2014\u2014${name} \u88AB\u95ED\u5305\u6355\u83B7\uFF08source ${borrow.source}\uFF09`);
+      }
+    }
+    const decl = txt.match(DECL_RE);
+    if (decl) {
+      const name = decl[1];
+      vars.set(name, { state: "alive", line: line.num, activeBorrows: 0 });
+      continue;
+    }
+    const bdecl = txt.match(BORROW_DECL_RE);
+    if (bdecl) {
+      borrowVars.set(bdecl[1], { source: bdecl[2], line: line.num });
+      const src = vars.get(bdecl[2]);
+      if (src) src.activeBorrows++;
+      continue;
+    }
+    const call = txt.match(CALL_RE);
+    if (call) {
+      const name = call[1];
+      const op = call[2];
+      const info = vars.get(name);
+      if (!info) continue;
+      if (op === "transferTo") {
+        if (info.state === "moved") {
+          add("B-01", "error", line.num, `G4001: use after move\u2014\u2014${name} \u5DF2\u8F6C\u79FB\uFF0C\u4E0D\u53EF\u518D\u64CD\u4F5C`);
+        } else if (info.state !== "alive") {
+          add("B-02", "error", line.num, `G4002: double move\u2014\u2014${name} \u72B6\u6001 ${info.state} \u4E0D\u53EF\u8F6C\u79FB`);
+        } else if (info.activeBorrows > 0) {
+          add("B-05", "error", line.num, `G4005: \u8F6C\u79FB\u65F6\u6709 ${info.activeBorrows} \u4E2A\u6D3B\u8DC3\u501F\u7528\u2014\u2014\u5148 release`);
+        } else {
+          info.state = "moved";
+        }
+      } else if (op === "borrow") {
+        if (info.state !== "alive") {
+          add("B-01", "error", line.num, `G4001: ${name} \u72B6\u6001 ${info.state} \u4E0D\u53EF\u501F\u7528`);
+        } else {
+          info.activeBorrows++;
+        }
+      } else if (op === "drop") {
+        if (info.state === "alive" && info.activeBorrows > 0 && !/force/.test(txt)) {
+          add("B-05", "error", line.num, `G4005: drop \u65F6 ${name} \u6709 ${info.activeBorrows} \u4E2A\u6D3B\u8DC3\u501F\u7528`);
+        } else if (info.state === "alive") {
+          info.state = "dropped";
+        }
+      } else if (op === "read" || op === "write" || op === "get" || op === "use") {
+        if (info.state === "moved") {
+          add("B-01", "error", line.num, `G4001: use after move\u2014\u2014${name} \u5DF2\u8F6C\u79FB\uFF08\u7B2C ${info.line} \u884C declared\uFF09\uFF0C\u6B64\u5904\u8BBF\u95EE\u975E\u6CD5`);
+        } else if (info.state === "dropped") {
+          add("B-01", "error", line.num, `G4001: use after drop\u2014\u2014${name} \u5DF2\u91CA\u653E\uFF0C\u4E0D\u53EF\u518D\u8BBF\u95EE`);
+        }
+      }
+      continue;
+    }
+    const esc = txt.match(ESCAPE_ASSIGN_RE);
+    if (esc) {
+      const varName = esc[2];
+      if (borrowVars.has(varName)) {
+        add("B-03", "error", line.num, `G4003: borrow escapes scope\u2014\u2014${varName} \u88AB\u5199\u5165\u66F4\u957F\u5BFF\u5BB9\u5668`);
+      } else if (vars.get(varName)?.state === "alive") {
+        add("B-07", "error", line.num, `G4007: \u8DE8\u9875\u9762\u5F3A\u5F15\u7528\u2014\u2014Owned ${varName} \u88AB\u5199\u5165\u8DE8\u9875\u5BB9\u5668\uFF08\u751F\u547D\u5468\u671F\u8D8A\u754C\uFF0C\u5E94 transferTo/weak\uFF09`);
+      }
+      continue;
+    }
+    const storeSet = txt.match(/\b(?:store|stores|globalCache|windowStore|moduleScope|eventBus)\s*\.\s*(?:set|add|push|write)\s*\(\s*[^,()]+,\s*([A-Za-z_$][\w$]*)/);
+    if (storeSet && vars.get(storeSet[1])?.state === "alive") {
+      add("B-07", "error", line.num, `G4007: \u8DE8\u9875\u9762\u5F3A\u5F15\u7528\u2014\u2014Owned ${storeSet[1]} \u88AB\u5B58\u5165\u8DE8\u9875\u5BB9\u5668\uFF08\u751F\u547D\u5468\u671F\u8D8A\u754C\uFF0C\u5E94 transferTo/weak\uFF09`);
+      continue;
+    }
+    for (const [name, borrow] of borrowVars) {
+      if (closureCaptureLine(txt, name)) {
+        add("B-03", "error", line.num, `G4003: borrow escapes scope\u2014\u2014${name} \u88AB\u95ED\u5305\u6355\u83B7\uFF08source ${borrow.source}\uFF09`);
+      }
+    }
+    const assign = txt.match(/^([A-Za-z_$][\w$]*)\s*\.\s*[\w$]+\s*=\s*([A-Za-z_$][\w$]*);?$/);
+    if (assign && assign[1] !== assign[2]) {
+      refEdges.push({ from: assign[1], to: assign[2], line: line.num });
+    }
+  }
+  const ownedVars = [...vars.keys()];
+  for (const [name, info] of vars) {
+    if (info.state === "alive") {
+      add("B-06", mode === "strict" ? "warning" : "warning", info.line, `G4006: owned resource not disposed\u2014\u2014${name} \u65E2\u672A drop \u4E5F\u672A transferTo`);
+    }
+  }
+  for (const e of refEdges) {
+    const back = refEdges.find((r) => r.from === e.to && r.to === e.from);
+    if (back || e.from === e.to) {
+      add("B-08", "warning", e.line, `G4008: \u5FAA\u73AF\u5F15\u7528\u2014\u2014${e.from} \u21C4 ${e.to}\uFF08\u6253\u7834\u5FAA\u73AF\u7528 Weak\uFF09`);
+    }
+  }
+  const blocksBuild = mode === "strict" && diagnostics.some((d) => d.severity === "error");
+  return { diagnostics, blocksBuild, ownedVars };
+}
+
+// src/ownership-observability.ts
+function createOwnershipHistory(graph, opts = {}) {
+  const limit = opts.limit ?? 2e3;
+  let records = [];
+  let enabled = opts.enabled ?? true;
+  let disposed = false;
+  function push(rec) {
+    records.push(rec);
+    if (records.length > limit) records = records.slice(-limit);
+  }
+  const unsub = graph.subscribe((m) => {
+    if (!enabled || disposed) return;
+    if (m.kind === "register") {
+      push({ ts: m.ts, kind: "alloc", id: m.id, owner: m.owner, type: m.type, byteSize: m.byteSize, sourceLocation: m.sourceLocation });
+    } else if (m.kind === "state") {
+      if (m.state === "dropped") {
+        const n = graph.nodes.get(m.id);
+        push({ ts: m.ts, kind: "drop", id: m.id, owner: n?.owner, type: n?.type, byteSize: n?.byteSize, sourceLocation: n?.sourceLocation ?? null });
+      } else if (m.state === "moved") {
+        const n = graph.nodes.get(m.id);
+        push({ ts: m.ts, kind: "moved", id: m.id, owner: n?.owner, type: n?.type, byteSize: n?.byteSize, sourceLocation: n?.sourceLocation ?? null });
+      }
+    } else if (m.kind === "edge") {
+      const k = m.edge.kind;
+      if (k === "owns" || k === "moved-from") return;
+      push({ ts: m.ts, kind: k === "borrows" ? "borrow" : k, from: m.edge.from, to: m.edge.to });
+    }
+  });
+  const history = {
+    get records() {
+      return records;
+    },
+    get enabled() {
+      return enabled;
+    },
+    set enabled(v) {
+      enabled = v;
+    },
+    setEnabled(v) {
+      enabled = v;
+    },
+    clear() {
+      records = [];
+    },
+    dispose() {
+      disposed = true;
+      unsub();
+      records = [];
+    }
+  };
+  return history;
+}
+function createOwnershipCounters(graph) {
+  let alive = 0;
+  let total = 0;
+  let bytesAlive = 0;
+  const byType = /* @__PURE__ */ new Map();
+  const bump = (type, delta) => {
+    const c = byType.get(type) ?? { allocated: 0, alive: 0 };
+    c.alive += delta;
+    if (c.alive < 0) c.alive = 0;
+    byType.set(type, c);
+  };
+  for (const n of graph.nodes.values()) {
+    total++;
+    const c = byType.get(n.type) ?? { allocated: 0, alive: 0 };
+    c.allocated++;
+    byType.set(n.type, c);
+    if (n.state === "alive") {
+      alive++;
+      bytesAlive += n.byteSize;
+      c.alive++;
+    }
+  }
+  graph.subscribe((m) => {
+    if (m.kind === "register") {
+      alive++;
+      total++;
+      bytesAlive += m.byteSize;
+      const c = byType.get(m.type) ?? { allocated: 0, alive: 0 };
+      c.allocated++;
+      c.alive++;
+      byType.set(m.type, c);
+    } else if (m.kind === "state") {
+      if (m.state === "dropped" || m.state === "moved") {
+        const n = graph.nodes.get(m.id);
+        alive = Math.max(0, alive - 1);
+        bytesAlive = Math.max(0, bytesAlive - (n?.byteSize ?? 0));
+        bump(n?.type ?? "?", -1);
+      }
+    }
+  });
+  return {
+    get alive() {
+      return alive;
+    },
+    get total() {
+      return total;
+    },
+    get bytesAlive() {
+      return bytesAlive;
+    },
+    get byType() {
+      return Object.fromEntries(byType);
+    },
+    consistent() {
+      const s = graph.stats();
+      return alive === s.alive && total === s.total && bytesAlive === s.totalBytes;
+    }
+  };
+}
+function diagnoseOwnershipIssues(graph, opts = {}) {
+  const now = opts.now ? opts.now() : Date.now();
+  const longBorrowMs = opts.longBorrowMs ?? 1e3;
+  const destroyedScopes = opts.destroyedScopes ?? [];
+  const stats = graph.stats();
+  const orphans = graph.findOrphans();
+  const leaks = [];
+  for (const scope of destroyedScopes) {
+    leaks.push(...graph.detectLeaks(scope));
+  }
+  const longBorrows = [];
+  for (const e of graph.edges) {
+    if (e.kind !== "borrows") continue;
+    const sinceMs = e.since ?? 0;
+    const duration = sinceMs > 0 ? now - sinceMs : 0;
+    if (duration > longBorrowMs) {
+      const n = graph.nodes.get(e.to);
+      longBorrows.push({ resourceId: e.to, type: n?.type ?? "?", owner: n?.owner ?? null, borrowedBy: e.from, sinceMs });
+    }
+  }
+  const crossPageRefs = [];
+  for (const e of graph.edges) {
+    if (e.kind !== "strong") continue;
+    const n = graph.nodes.get(e.to);
+    if (!n || n.state !== "alive") continue;
+    if (e.from === n.owner) continue;
+    crossPageRefs.push({ resourceId: e.to, type: n.type, owner: n.owner, heldBy: e.from });
+  }
+  return { aliveNodes: stats.alive, totalNodes: stats.total, orphans, leaks, longBorrows, crossPageRefs };
+}
+function buildOwnershipTimeline(history, graph) {
+  const events = [];
+  const allocById = /* @__PURE__ */ new Map();
+  for (const rec of history.records) {
+    if (rec.kind === "alloc" && rec.id) {
+      allocById.set(rec.id, rec);
+      events.push(rec);
+    } else if ((rec.kind === "drop" || rec.kind === "moved") && rec.id) {
+      const matched = allocById.get(rec.id);
+      if (matched) allocById.delete(rec.id);
+      events.push({ ...rec, matchedAlloc: matched });
+    } else {
+      events.push(rec);
+    }
+  }
+  const unpairedAllocs = [...allocById.values()].filter((a) => a.id !== void 0 && graph.nodes.get(a.id)?.state === "alive");
+  return { events, unpairedAllocs };
+}
+function formatOwnershipDiagnosis(d, opts = {}) {
+  const src = opts.sourceLabel ?? "\u{1F4CD}";
+  const lines = [];
+  lines.push(`\u6240\u6709\u6743\u56FE\uFF1A${d.aliveNodes} alive / ${d.totalNodes} total`);
+  if (d.orphans.length > 0) {
+    lines.push(`\u{1F534} \u65E0\u4E3B\u8D44\u6E90 ${d.orphans.length} \u5904\uFF08\u5FC5\u7136\u6CC4\u6F0F\u2014\u2014\u6846\u67B6 bug \u6216\u672A\u6B63\u786E\u767B\u8BB0\uFF09\uFF1A`);
+    for (const o of d.orphans) lines.push(`  \xB7 ${o.id}\uFF08${o.type}\uFF0C${o.byteSize}B\uFF09${o.sourceLocation ? `${src} ${o.sourceLocation}` : ""}`);
+  }
+  if (d.leaks.length > 0) {
+    lines.push(`\u26A0\uFE0F \u6CC4\u6F0F\u8DEF\u5F84 ${d.leaks.length} \u5904\uFF08\u9875\u9762\u5DF2\u9500\u6BC1\u8D44\u6E90\u4ECD\u5B58\u6D3B\uFF09\uFF1A`);
+    for (const l of d.leaks) {
+      lines.push(`  \xB7 ${l.resourceId}\uFF08${l.type}\uFF0C${l.byteSize}B\uFF09${l.sourceLocation ? `${src} ${l.sourceLocation}` : ""}`);
+      for (const hop of l.referenceChain) lines.push(`      ${hop}`);
+    }
+  }
+  if (d.longBorrows.length > 0) {
+    lines.push(`\u{1F7E1} \u957F\u671F\u501F\u7528 ${d.longBorrows.length} \u5904\uFF08>\u9608\u503C\u2014\u2014\u501F\u7528\u7684\u8FD0\u884C\u65F6\u9003\u9038\u8868\u73B0\uFF09\uFF1A`);
+    for (const b of d.longBorrows) lines.push(`  \xB7 ${b.resourceId} \u2190 borrowed by ${b.borrowedBy}\uFF08owner ${b.owner ?? "\u65E0\u4E3B"}\uFF09`);
+  }
+  if (d.crossPageRefs.length > 0) {
+    lines.push(`\u26A0\uFE0F \u8DE8\u9875\u9762\u5F3A\u5F15\u7528 ${d.crossPageRefs.length} \u5904\uFF08\u9500\u6BC1\u65F6\u65E0\u6CD5\u91CA\u653E\u2014\u2014\u5E94 transferTo/weak\uFF09\uFF1A`);
+    for (const c of d.crossPageRefs) lines.push(`  \xB7 ${c.resourceId}\uFF08owner ${c.owner ?? "\u65E0\u4E3B"}\uFF09\u2190 \u5F3A\u6301\u6709 by ${c.heldBy}`);
+  }
+  if (d.orphans.length === 0 && d.leaks.length === 0 && d.longBorrows.length === 0 && d.crossPageRefs.length === 0) {
+    lines.push("\u2705 \u65E0\u5F02\u5E38\uFF08\u65E0\u65E0\u4E3B\u8D44\u6E90/\u6CC4\u6F0F\u8DEF\u5F84/\u957F\u671F\u501F\u7528/\u8DE8\u9875\u5F3A\u5F15\u7528\uFF09");
+  }
+  return lines.join("\n");
+}
+
+// src/pss.ts
+var PSS_PRAGMA_RE = /@proteus-pss\s*[:=]?\s*(strict|loose|off)/i;
+function resolvePssMode(source, fallback = "off") {
+  const head = source.split("\n", 20).join("\n");
+  const m = head.match(PSS_PRAGMA_RE);
+  return m?.[1]?.toLowerCase() ?? fallback;
+}
+var STATIC_PSS_RULES = [
+  // P1 禁 any/unknown（类型不可推导——borrow-checker.md §2.1）
+  { rule: "P1", re: /:\s*(?:any|unknown)\b|\bas\s+(?:any|unknown)\b|<(?:any|unknown)>/, loose: true, message: "G4011: PSS \u7981\u7528 any/unknown\u2014\u2014\u7C7B\u578B\u4E0D\u53EF\u63A8\u5BFC\uFF0C\u6240\u6709\u6743\u5206\u6790\u5931\u6548" },
+  // P2 动态属性写入（`obj[keyVar] =`——字符串字面量键放行；布局不稳定）
+  { rule: "P2", re: /\[[A-Za-z_$][\w$]*\]\s*=\s/, loose: true, message: "G4012: PSS \u7981\u7528\u52A8\u6001\u5C5E\u6027\u5199\u5165\u2014\u2014\u5BF9\u8C61\u5F62\u72B6\u4E0D\u53EF\u9759\u6001\u63A8\u5BFC" },
+  // P3 delete（破坏所有权登记）
+  { rule: "P3", re: /\bdelete\s+[A-Za-z_$][\w$]*/, loose: false, message: "G4013: PSS \u7981\u7528 delete \u64CD\u4F5C\u7B26\u2014\u2014\u7834\u574F\u6240\u6709\u6743\u767B\u8BB0" },
+  // P4 eval / new Function（完全不可分析）
+  { rule: "P4", re: /\beval\s*\(|\bnew\s+Function\s*\(/, loose: false, message: "G4014: PSS \u7981\u7528 eval/new Function\u2014\u2014\u4EE3\u7801\u5B8C\u5168\u4E0D\u53EF\u5206\u6790" },
+  // P8 with（作用域动态）
+  { rule: "P8", re: /\bwith\s*\(/, loose: false, message: "G4018: PSS \u7981\u7528 with \u8BED\u53E5\u2014\u2014\u4F5C\u7528\u57DF\u52A8\u6001\u4E0D\u53EF\u5206\u6790" },
+  // P9 原型链动态修改（破坏类型契约）
+  { rule: "P9", re: /\.\s*prototype\s*\.\s*[\w$]+\s*=\s/, loose: false, message: "G4019: PSS \u7981\u7528\u539F\u578B\u94FE\u52A8\u6001\u4FEE\u6539\u2014\u2014\u7834\u574F\u7C7B\u578B\u5951\u7EA6" }
+];
+function closureCaptureLine2(text, varName) {
+  return /(setTimeout|setInterval|addEventListener|then|subscribe|queueMicrotask)\s*\(/.test(text) && text.includes(varName);
+}
+function analyzePss(source, opts = {}) {
+  const mode = opts.mode ?? resolvePssMode(source);
+  const diagnostics = [];
+  if (mode === "off") return { diagnostics, mode };
+  const ownedVars = opts.ownedVars ?? analyzeOwnershipSource(source, { mode }).ownedVars;
+  const ownedSet = new Set(ownedVars);
+  const add = (rule, severity, line, message) => {
+    diagnostics.push({ rule, severity, line, message });
+  };
+  const lines = source.split("\n");
+  lines.forEach((raw, i) => {
+    const txt = raw.trim();
+    const line = i + 1;
+    if (txt.startsWith("//") || txt.startsWith("*") || txt.startsWith("/*")) return;
+    for (const r of STATIC_PSS_RULES) {
+      if (r.re.test(txt) && (mode === "strict" || r.loose)) {
+        add(r.rule, "error", line, r.message);
+      }
+    }
+    const globalAssign = txt.match(/(?:globalThis|window|global|self)\s*\.\s*[\w$]+\s*=\s*([A-Za-z_$][\w$]*)/);
+    if (globalAssign && ownedSet.has(globalAssign[1])) {
+      add("P5", "error", line, `G4015: Owned ${globalAssign[1]} \u9003\u9038\u5230\u5168\u5C40\u2014\u2014\u6240\u6709\u6743\u8131\u79BB\u4F5C\u7528\u57DF\uFF08strict \u7981\u6B62\uFF09`);
+    }
+    for (const name of ownedSet) {
+      if (closureCaptureLine2(txt, name)) {
+        add("P7", "error", line, `G4017: \u95ED\u5305\u6355\u83B7 Owned ${name}\u2014\u2014\u4F5C\u7528\u57DF\u4E0D\u53EF\u63A7\uFF0C\u5E94\u663E\u5F0F transferTo \u6216 drop`);
+      }
+    }
+    const refWrap = txt.match(/\b(?:ref|reactive|shallowRef|readonly)\s*\(\s*([A-Za-z_$][\w$]*)/);
+    if (refWrap && ownedSet.has(refWrap[1])) {
+      add("CMP071", mode === "strict" ? "error" : "warning", line, `CMP071: ${refWrap[1]}\uFF08Owned\uFF09\u88AB ref/reactive \u5305\u88C5\u2014\u2014Proxy \u7834\u574F\u6240\u6709\u6743\u8BED\u4E49\uFF0C\u6539\u7528 useOwned()\uFF08\u54CD\u5E94\u5F0F\u5143\u4FE1\u606F\uFF09`);
+    }
+  });
+  return { diagnostics, mode };
+}
+function insertScopeDrops(source) {
+  const rawLines = source.split("\n");
+  const depths = [];
+  let depth = 0;
+  for (const raw of rawLines) {
+    depths.push(depth);
+    const t = raw.trim();
+    depth += (t.match(/\{/g) ?? []).length - (t.match(/\}/g) ?? []).length;
+  }
+  const pending = /* @__PURE__ */ new Set();
+  const insertionsByLine = /* @__PURE__ */ new Map();
+  for (let i = 0; i < rawLines.length; i++) {
+    const t = rawLines[i].trim();
+    const d = depths[i];
+    const line = i + 1;
+    const decl = t.match(/(?:const|let|var)\s+([A-Za-z_$][\w$]*)\s*=\s*(?:pageContext|ctx|cp|host|container|this)?\.?(?:alloc|allocShared|createOwned|new Owned)\(/);
+    if (decl) {
+      if (d > 0) {
+        const indent = rawLines[i].match(/^\s*/)?.[0] ?? "";
+        pending.add({ varName: decl[1], declDepth: d, declLine: line, indent, disposed: false });
+      }
+      continue;
+    }
+    const call = t.match(/([A-Za-z_$][\w$]*)\s*\.\s*(?:drop|transferTo)\s*\(/);
+    if (call) {
+      for (const p of pending) {
+        if (p.varName === call[1] && !p.disposed) {
+          p.disposed = true;
+          break;
+        }
+      }
+    }
+    if (t.includes("}")) {
+      for (const p of [...pending]) {
+        if (p.declDepth === d) {
+          if (!p.disposed) {
+            const list = insertionsByLine.get(line) ?? [];
+            list.push(p);
+            insertionsByLine.set(line, list);
+          }
+          pending.delete(p);
+        }
+      }
+    }
+  }
+  const insertions = [];
+  const outLines = [...rawLines];
+  const closeLines = [...insertionsByLine.keys()].sort((a, b) => b - a);
+  for (const closeLine of closeLines) {
+    const items = insertionsByLine.get(closeLine);
+    const stmts = items.map((p) => {
+      insertions.push({ varName: p.varName, line: closeLine });
+      return `${p.indent}  ${p.varName}.drop()`;
+    });
+    outLines.splice(closeLine - 1, 0, ...stmts);
+  }
+  return { code: outLines.join("\n"), insertions };
+}
+function runPss(source, opts = {}) {
+  const mode = resolvePssMode(source, opts.mode ?? "off");
+  const autoDrop = opts.autoDrop ?? true;
+  if (mode === "off") {
+    return { mode, diagnostics: [], blocksBuild: false, ownedVars: [], code: source, insertions: [] };
+  }
+  const borrow = analyzeOwnershipSource(source, { mode });
+  const pss = analyzePss(source, { mode, ownedVars: borrow.ownedVars });
+  const diagnostics = [...borrow.diagnostics, ...pss.diagnostics];
+  let code = source;
+  let insertions = [];
+  if (autoDrop) {
+    const r = insertScopeDrops(source);
+    code = r.code;
+    insertions = r.insertions;
+  }
+  const blocksBuild = mode === "strict" && diagnostics.some((d) => d.severity === "error");
+  return { mode, diagnostics, blocksBuild, ownedVars: borrow.ownedVars, code, insertions };
+}
+
+// src/host-matrix.ts
+var HOSTS = ["web", "ios", "android", "harmony", "flutter", "miniprogram"];
+var ENGINES = ["vue-dom", "headless", "native-ios", "native-android", "native-harmony", "flutter"];
+var HOST_ENGINE_MATRIX = {
+  web: { "vue-dom": 1, "headless": 1, "flutter": 3, "native-ios": 0, "native-android": 0, "native-harmony": 0 },
+  ios: { "vue-dom": 3, "headless": 1, "flutter": 1, "native-ios": 1, "native-android": 0, "native-harmony": 0 },
+  android: { "vue-dom": 3, "headless": 1, "flutter": 1, "native-ios": 0, "native-android": 1, "native-harmony": 0 },
+  harmony: { "vue-dom": 3, "headless": 1, "flutter": 0, "native-ios": 0, "native-android": 0, "native-harmony": 1 },
+  flutter: { "vue-dom": 0, "headless": 1, "flutter": 1, "native-ios": 3, "native-android": 3, "native-harmony": 0 },
+  miniprogram: { "vue-dom": 0, "headless": 1, "flutter": 0, "native-ios": 0, "native-android": 0, "native-harmony": 0 }
+};
+function matrixCombos(filter = {}) {
+  const out = [];
+  for (const host of HOSTS) {
+    for (const engine of ENGINES) {
+      const tier = HOST_ENGINE_MATRIX[host][engine];
+      if (filter.tier === void 0 || tier === filter.tier) out.push({ host, engine, tier });
+    }
+  }
+  return out;
+}
+function createEngine(engine, documentLike) {
+  switch (engine) {
+    case "vue-dom":
+      return createVueDomBackend(documentLike);
+    case "headless":
+      return createHeadlessBackend();
+    case "native-ios":
+      return createNativeBackend(void 0, "ios");
+    case "native-android":
+      return createNativeBackend(void 0, "android");
+    case "native-harmony":
+      return createNativeBackend(void 0, "harmony");
+    case "flutter":
+      return createFlutterBackend();
+  }
+}
+var GRID_CONTROL = {
+  "vue-dom": { attr: "class", value: "proteus-grid" },
+  "headless": { attr: "type", value: "grid" },
+  "native-ios": { attr: "type", value: "UICollectionView" },
+  "native-android": { attr: "type", value: "GridLayoutManager" },
+  "native-harmony": { attr: "type", value: "Grid" },
+  "flutter": { attr: "widget", value: "GridView" }
+};
+function secondEngineOf(engine) {
+  return engine === "flutter" ? "headless" : "flutter";
+}
+function countIR(ir) {
+  return 1 + ir.children.reduce((s, c) => s + countIR(c), 0);
+}
+function walkNodes(node, visit) {
+  const n = node;
+  visit(n);
+  let count = 1;
+  const children = n.children;
+  if (Array.isArray(children)) {
+    for (const c of children) count += walkNodes(c, visit);
+  } else if (children && typeof children.length === "number") {
+    const list = children;
+    for (let i = 0; i < list.length; i++) count += walkNodes(list[i], visit);
+  }
+  return count;
+}
+function buildProductIR2(dispatch) {
+  const grid = dispatch.toIRNode("p-grid", { minColWidth: 160 });
+  const box1 = dispatch.toIRNode("p-box", {});
+  const box2 = dispatch.toIRNode("p-box", {});
+  const text = dispatch.toIRNode("p-text", { content: "\u5546\u54C1 A" });
+  const button = dispatch.toIRNode("p-button", { variant: "primary" });
+  return {
+    ...dispatch.toIRNode("p-page", { title: "Product" }),
+    children: [{ ...grid, children: [{ ...box1, children: [text] }, { ...box2, children: [button] }] }]
+  };
+}
+async function runComboConformance(opts) {
+  const { host, engine } = opts;
+  const checks = [];
+  const add = (id, ok, message) => {
+    checks.push({ id, ok, message: ok ? void 0 : message });
+  };
+  const backend = createEngine(engine, opts.documentLike);
+  const backendConf = runBackendConformance(backend);
+  add("backend-conformance", backendConf.ok, `\u5F15\u64CE\u81EA\u8EAB conformance \u672A\u8FC7\uFF08${backendConf.checks.filter((c) => !c.pass).length} \u9879\uFF09`);
+  const dispatch = createNodeOpsDispatcher(backend);
+  const carrier = createCarrierStub("jsi");
+  const hostRuntime = host === "web" ? createWebHostRuntime() : createHostRuntimeStub();
+  add("registration-before-bootstrap", dispatch.currentBackend === backend && hostRuntime.state === "created", "Backend \u5E94\u5728 bootstrap \u524D\u6CE8\u518C\uFF08G-41.6\uFF09");
+  hostRuntime.bootstrap();
+  add("host-bootstrap", hostRuntime.state === "running", "\u5BBF\u4E3B bootstrap \u540E\u5E94 running");
+  const ir = buildProductIR2(dispatch);
+  const fingerprint = semanticSequence(ir);
+  add("semantic-fingerprint", JSON.stringify(fingerprint) === JSON.stringify(["shell.page", "layout.grid", "layout.box", "ui.text", "layout.box", "ui.button"]), `\u8BED\u4E49\u6307\u7EB9\u4E0D\u7B26\uFF1A${fingerprint.join(",")}`);
+  const root = renderIRTree(backend, ir);
+  const irCount = countIR(ir);
+  const engineCount = walkNodes(root, () => {
+  });
+  add("render-complete", engineCount === irCount, `\u5F15\u64CE\u8282\u70B9\u6570 ${engineCount} \u2260 IR \u8282\u70B9\u6570 ${irCount}`);
+  const ctrl = GRID_CONTROL[engine];
+  let gridFound = false;
+  walkNodes(root, (n) => {
+    if (ctrl.attr === "class") {
+      const cls = String(n.className ?? "");
+      if (cls.includes(ctrl.value)) gridFound = true;
+    } else if (n[ctrl.attr] === ctrl.value) {
+      gridFound = true;
+    }
+  });
+  add("semantic-control-mapping", gridFound, `layout.grid \u672A\u6620\u5C04\u5230 ${ctrl.value}\uFF08${engine}\uFF09`);
+  const second = secondEngineOf(engine);
+  const backend2 = createEngine(second, opts.documentLike);
+  dispatch.switchBackend(backend2);
+  const root2 = renderIRTree(backend2, ir);
+  const count2 = walkNodes(root2, () => {
+  });
+  const ctrl2 = GRID_CONTROL[second];
+  let grid2 = false;
+  walkNodes(root2, (n) => {
+    if (ctrl2.attr === "class") {
+      if (String(n.className ?? "").includes(ctrl2.value)) grid2 = true;
+    } else if (n[ctrl2.attr] === ctrl2.value) {
+      grid2 = true;
+    }
+  });
+  add(
+    "hot-switch-equivalence",
+    dispatch.currentBackend === backend2 && count2 === irCount && grid2 && semanticSequence(ir).length === fingerprint.length,
+    `\u5207\u6362\u5230 ${second} \u540E\u6E32\u67D3\u4E0D\u7B49\u4EF7\uFF08count ${count2}/${irCount}\uFF0Cgrid ${grid2}\uFF09`
+  );
+  const failed = checks.filter((c) => !c.ok).length;
+  return { host, engine, ok: failed === 0, total: checks.length, failed, checks };
+}
+async function runHostEngineMatrix(opts = {}) {
+  const rows = [];
+  for (const combo of matrixCombos()) {
+    if (opts.only && (opts.only.host && opts.only.host !== combo.host || opts.only.engine && opts.only.engine !== combo.engine)) {
+      continue;
+    }
+    if (combo.tier === 1) {
+      const result = await runComboConformance({ host: combo.host, engine: combo.engine, documentLike: opts.documentLike });
+      rows.push({ host: combo.host, engine: combo.engine, tier: combo.tier, result });
+    } else {
+      rows.push({ host: combo.host, engine: combo.engine, tier: combo.tier, result: null });
+    }
+  }
+  const tier1Rows = rows.filter((r) => r.tier === 1);
+  return {
+    totalCombos: rows.length,
+    tier1Combos: tier1Rows.length,
+    verified: tier1Rows.filter((r) => r.result?.ok).length,
+    failed: tier1Rows.reduce((s, r) => s + (r.result?.failed ?? 0), 0),
+    rows
+  };
+}
+function formatMatrixReport(report) {
+  const lines = [];
+  lines.push(`\u5BBF\u4E3B\xD7\u5F15\u64CE\u77E9\u9635\uFF1A${report.totalCombos} \u7EC4\u5408 / Tier 1 ${report.tier1Combos} / \u5DF2\u9A8C\u8BC1 ${report.verified} / \u5931\u8D25 ${report.failed}`);
+  for (const row of report.rows) {
+    if (row.tier === 1 && row.result) {
+      lines.push(`  ${row.result.ok ? "\u2705" : "\u274C"} T1  ${row.host} \xD7 ${row.engine}\uFF08${row.result.total - row.result.failed}/${row.result.total}\uFF09`);
+    } else if (row.tier === 3) {
+      lines.push(`  \u26AA T3  ${row.host} \xD7 ${row.engine}\uFF08\u6DF7\u5165\u53EF\u884C\uFF0C\u4E0D\u627F\u8BFA\uFF09`);
+    } else {
+      lines.push(`  \u2B1B T0  ${row.host} \xD7 ${row.engine}\uFF08\u8DE8\u751F\u6001\u4E0D\u5408\u6CD5\uFF09`);
+    }
+  }
+  return lines.join("\n");
+}
+export {
+  Borrow,
+  CONTAINER_PROFILES,
+  DEFAULT_STACK_POLICY,
+  DispatcherError,
+  ENGINES,
+  FIVE_ATOMIC_STEPS,
+  FORK_SIGNATURES,
+  HOSTS,
+  HOST_ENGINE_MATRIX,
+  Managed,
+  ManagedRegistry,
+  OWNERSHIP_ERRORS,
+  Owned,
+  OwnershipError,
+  OwnershipGraph,
+  PAGE_STATE_TRANSITIONS,
+  SENSITIVE_CAPABILITIES,
+  Weak,
+  analyzeOwnershipSource,
+  analyzePss,
+  assertAtomicDestroy,
+  buildOwnershipTimeline,
+  canTransitionPageState,
+  checkBizManifest,
+  checkCapabilityAuthorization,
+  createBackendSwitcher,
+  createCarrierStub,
+  createControlReader,
+  createDestroyReport,
+  createEmbeddedContainer,
+  createEngine,
+  createFlutterBackend,
+  createHeadlessBackend,
+  createHostRuntimeStub,
+  createHybridRenderer,
+  createMiniProgramContainer,
+  createMockNativeAdapter,
+  createNativeBackend,
+  createNodeOpsDispatcher,
+  createOwnershipCounters,
+  createOwnershipHistory,
+  createPageOwnership,
+  createProteusRenderer,
+  createProteusRendererForBackend,
+  createQuotaManager,
+  createQuotaTracker,
+  createResourcePool,
+  createSinglePageContainer,
+  createStackContainer,
+  createSuperAppContainer,
+  createVueDomBackend,
+  createVueRendererOptions,
+  createWebHostRuntime,
+  createWindowContainer,
+  diagnoseOwnershipIssues,
+  formatContainerConformance,
+  formatHostConformance,
+  formatMatrixReport,
+  formatOwnershipDiagnosis,
+  getProteusOwnershipGraph,
+  insertScopeDrops,
+  mapWidgetType,
+  matrixCombos,
+  profileOfContainer,
+  renderComponentSnapshot,
+  renderIRTree,
+  resolvePssMode,
+  runBackendConformance,
+  runComboConformance,
+  runContainerConformance,
+  runHostConformance,
+  runHostEngineMatrix,
+  runHybridConformance,
+  runPss,
+  scanRepoForFork,
+  semanticSequence,
+  textureRef,
+  toPlainTree,
+  toWidgetTree
+};