@proteus-vue/render-backend 0.3.0-beta.11 → 0.3.0-beta.23

package/dist/index.js

@@ -80,6 +80,7 @@ var SEMANTIC_HEADLESS_MAP = {
   "layout.split": "split",
   "layout.safe": "safe",
   "layout.sidebar": "sidebar",
+  "layout.formfactor": "formfactor",
   "ui.text": "text",
   "ui.button": "button",
   "ui.image": "image",
@@ -110,6 +111,8 @@ var SEMANTIC_HEADLESS_MAP = {
   "shell.segment": "segment",
   "shell.popover": "popover",
   "shell.action-sheet": "action-sheet",
+  "shell.toast": "toast",
+  "ui.loading": "loading",
   "ui.rich-text": "rich-text",
   "ui.avatar": "avatar",
   "ui.media": "media",
@@ -175,6 +178,18 @@ function createHeadlessBackend() {
       nodes.set(n.id, n);
       return n;
     },
+    // ★2026-09-26 文本保留：'#text' → 文本节点（内存树）
+    createText(text) {
+      const n = {
+        id: nextId++,
+        type: "#text",
+        props: {},
+        children: [],
+        parent: null,
+        text
+      };
+      return n;
+    },
     insert(child, parent, anchor) {
       const c = ensureNode(child);
       const p = ensureNode(parent);
@@ -247,6 +262,8 @@ var SEMANTIC_WEB_MAP = {
   "layout.split": { tag: "div", className: "proteus-split" },
   "layout.safe": { tag: "div", className: "proteus-safe" },
   "layout.sidebar": { tag: "div", className: "proteus-sidebar" },
+  // ★★Fluid System v2：柔性形态容器
+  "layout.formfactor": { tag: "div", className: "proteus-formfactor" },
   "ui.text": { tag: "span" },
   "ui.button": { tag: "button" },
   "ui.image": { tag: "img" },
@@ -278,6 +295,9 @@ var SEMANTIC_WEB_MAP = {
   "shell.segment": { tag: "div", className: "proteus-segment" },
   "shell.popover": { tag: "div", className: "proteus-popover" },
   "shell.action-sheet": { tag: "div", className: "proteus-action-sheet" },
+  // ★2026-09-30 补缺（U19/S8 上批加了 SEMANTIC_BACKEND_MAP 但后端控件表漏补——M3 readback 门禁抓出）
+  "shell.toast": { tag: "div", className: "proteus-toast" },
+  "ui.loading": { tag: "div", className: "proteus-loading" },
   "ui.rich-text": { tag: "div", className: "proteus-rich-text" },
   "ui.avatar": { tag: "div", className: "proteus-avatar" },
   "ui.media": { tag: "div", className: "proteus-media" },
@@ -313,7 +333,9 @@ 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");
+    if (!el || typeof el.tagName !== "string" && el.nodeType !== 3) {
+      throw new Error("VueDomBackend: \u975E\u6CD5\u53E5\u67C4");
+    }
     return el;
   }
   return {
@@ -331,6 +353,10 @@ function createVueDomBackend(doc) {
       }
       return documentLike.createElement(node.type);
     },
+    // ★2026-09-26 文本保留：IR '#text' 节点 → 真实文本节点（此前 createText 无实现——IR 无文本节点）
+    createText(text) {
+      return documentLike.createTextNode(text);
+    },
     insert(child, parent, anchor) {
       const c = ensureEl(child);
       const p = ensureEl(parent);
@@ -385,6 +411,9 @@ function createVueDomBackend(doc) {
 }
 
 // src/native.ts
+function isBatchAdapter(a) {
+  return typeof a.commit === "function";
+}
 function createMockNativeAdapter() {
   const ops = [];
   return {
@@ -432,6 +461,7 @@ var SEMANTIC_NATIVE_MAPS = {
     "layout.split": "UISplitViewController",
     "layout.safe": "safeAreaLayoutGuide",
     "layout.sidebar": "UISplitViewController.side",
+    "layout.formfactor": "UIViewController.formFactor",
     "ui.text": "UILabel",
     "ui.button": "UIButton",
     "ui.image": "UIImageView",
@@ -462,6 +492,9 @@ var SEMANTIC_NATIVE_MAPS = {
     "shell.segment": "UISegmentedControl",
     "shell.popover": "UIPopoverController",
     "shell.action-sheet": "UIAlertController.actionSheet",
+    // ★2026-09-30 补缺（同 vue-dom 注释）
+    "shell.toast": "UIView.toast",
+    "ui.loading": "UIActivityIndicatorView",
     "ui.rich-text": "UITextView.attributed",
     "ui.avatar": "UIImageView.avatar",
     "ui.media": "AVPlayerView",
@@ -501,6 +534,7 @@ var SEMANTIC_NATIVE_MAPS = {
     "layout.split": "SlidingPaneLayout",
     "layout.safe": "WindowInsets",
     "layout.sidebar": "NavigationRail",
+    "layout.formfactor": "FormFactorLayout",
     "ui.text": "TextView",
     "ui.button": "Button",
     "ui.image": "ImageView",
@@ -531,6 +565,9 @@ var SEMANTIC_NATIVE_MAPS = {
     "shell.segment": "TabLayout",
     "shell.popover": "PopupWindow",
     "shell.action-sheet": "BottomSheet",
+    // ★2026-09-30 补缺（同 vue-dom 注释）
+    "shell.toast": "Toast",
+    "ui.loading": "ProgressBar",
     "ui.rich-text": "TextView.html",
     "ui.avatar": "ImageView.avatar",
     "ui.media": "VideoView",
@@ -570,6 +607,7 @@ var SEMANTIC_NATIVE_MAPS = {
     "layout.split": "SideBarContainer",
     "layout.safe": "getAvoidArea",
     "layout.sidebar": "SideBarContainer",
+    "layout.formfactor": "GridRow.formFactor",
     "ui.text": "Text",
     "ui.button": "Button",
     "ui.image": "Image",
@@ -600,6 +638,8 @@ var SEMANTIC_NATIVE_MAPS = {
     "shell.segment": "Segmented",
     "shell.popover": "Popup",
     "shell.action-sheet": "ActionSheet",
+    "shell.toast": "promptAction.showToast",
+    "ui.loading": "LoadingProgress",
     "ui.rich-text": "RichText",
     "ui.avatar": "Image.avatar",
     "ui.media": "Video",
@@ -631,11 +671,23 @@ var SEMANTIC_NATIVE_MAPS = {
   }
 };
 function createNativeBackend(adapter, platform = "ios") {
-  const viewAdapter = adapter ?? createMockNativeAdapter();
+  const rawAdapter = adapter ?? createMockNativeAdapter();
+  const viewAdapter = rawAdapter;
+  const batchAdapter = isBatchAdapter(rawAdapter) ? rawAdapter : null;
   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();
+  const pending = [];
+  let hostCalls = 0;
+  const queueOrCall = (op, imperative) => {
+    if (batchAdapter) {
+      pending.push(op);
+      return;
+    }
+    hostCalls++;
+    imperative();
+  };
   function ensureNode(handle) {
     const n = handle;
     if (!n || typeof n.id !== "number") throw new Error("NativeBackend: \u975E\u6CD5\u53E5\u67C4");
@@ -656,10 +708,31 @@ function createNativeBackend(adapter, platform = "ios") {
         text: "",
         handle: null
       };
-      descriptor.handle = viewAdapter.createView(descriptor);
+      queueOrCall({ op: "create", id: descriptor.id, type: viewType, props: descriptor.props }, () => {
+        descriptor.handle = viewAdapter.createView(descriptor);
+      });
+      if (!batchAdapter) descriptor.handle = descriptor.handle ?? descriptor;
       nodes.set(descriptor.id, descriptor);
       return descriptor;
     },
+    // ★2026-09-26 文本保留：'#text' → 文本描述符（type 'text'，text 字段承载内容——
+    //   readback/控件树即见真实文案；真机渲染通道接线时映射 Text/Label 内容）
+    createText(text) {
+      const descriptor = {
+        id: nextId++,
+        type: "text",
+        props: {},
+        children: [],
+        parent: null,
+        text,
+        handle: null
+      };
+      descriptor.handle = descriptor;
+      queueOrCall({ op: "create", id: descriptor.id, type: "text", props: {} }, () => {
+      });
+      if (batchAdapter) pending.push({ op: "text", id: descriptor.id, text });
+      return descriptor;
+    },
     insert(child, parent, anchor) {
       const c = ensureNode(child);
       const p = ensureNode(parent);
@@ -675,7 +748,9 @@ function createNativeBackend(adapter, platform = "ios") {
         p.children.push(c);
       }
       c.parent = p;
-      viewAdapter.insertView(c.handle, p.handle, anchor ? ensureNode(anchor).handle : void 0);
+      queueOrCall({ op: "insert", id: c.id, parentId: p.id, anchorId: anchor ? ensureNode(anchor).id : void 0 }, () => {
+        viewAdapter.insertView(c.handle, p.handle, anchor ? ensureNode(anchor).handle : void 0);
+      });
     },
     remove(child) {
       const c = ensureNode(child);
@@ -685,7 +760,7 @@ function createNativeBackend(adapter, platform = "ios") {
         c.parent = null;
       }
       nodes.delete(c.id);
-      viewAdapter.removeView(c.handle);
+      queueOrCall({ op: "remove", id: c.id }, () => viewAdapter.removeView(c.handle));
     },
     patchProp(el, key, prev, next) {
       const n = ensureNode(el);
@@ -694,15 +769,159 @@ function createNativeBackend(adapter, platform = "ios") {
       } else {
         n.props[key] = next;
       }
-      viewAdapter.updateView(n.handle, key, prev, next);
+      queueOrCall({ op: "patch", id: n.id, key, prev, next }, () => viewAdapter.updateView(n.handle, key, prev, next));
     },
     setText(el, text) {
       const n = ensureNode(el);
       n.text = text;
-      viewAdapter.setViewText(n.handle, text);
+      queueOrCall({ op: "text", id: n.id, text }, () => viewAdapter.setViewText(n.handle, text));
     },
     measure() {
       return { width: 0, height: 0 };
+    },
+    // ★★C1 批量模式的两个接口（逐节点模式下：flush 为空操作、hostCalls 反映真实调用数）
+    /** 提交本帧累积的操作（**一次跨边界调用**——批处理红线的落点） */
+    flush() {
+      if (!batchAdapter) return;
+      if (pending.length === 0) return;
+      hostCalls++;
+      const batch = pending.splice(0, pending.length);
+      batchAdapter.commit(batch);
+    },
+    /** 已发生的宿主调用数（判据：批量模式下应 == flush 次数，不随节点数增长） */
+    hostCalls() {
+      return hostCalls;
+    }
+  };
+}
+
+// src/selfdraw-batch.ts
+function createSelfDrawBatchAdapter(host, opts) {
+  const mirror = /* @__PURE__ */ new Map();
+  const rootOrder = [];
+  let calls = 0;
+  let lastKind = null;
+  let mounted = false;
+  const normalize = opts.normalizeProps ?? ((p) => p);
+  function removeSubtree(id) {
+    const n = mirror.get(id);
+    if (!n) return;
+    for (const c of n.children) removeSubtree(c);
+    mirror.delete(id);
+    const at = rootOrder.indexOf(id);
+    if (at >= 0) rootOrder.splice(at, 1);
+  }
+  function specs() {
+    const out = [];
+    const visit = (id) => {
+      const n = mirror.get(id);
+      if (!n) return;
+      const spec = { id: n.id, parentId: n.parentId, ...normalize(n.props) };
+      if (n.text !== void 0) spec.text = n.text;
+      out.push(spec);
+      for (const c of n.children) visit(c);
+    };
+    for (const r of rootOrder) visit(r);
+    return out;
+  }
+  return {
+    commit(ops) {
+      let structural = false;
+      const patched = /* @__PURE__ */ new Map();
+      const patch = (id, key, value) => {
+        const s = patched.get(id) ?? {};
+        if (value === null || value === void 0) delete s[key];
+        else s[key] = value;
+        patched.set(id, s);
+      };
+      for (const op of ops) {
+        switch (op.op) {
+          case "create": {
+            mirror.set(op.id, {
+              id: op.id,
+              type: op.type,
+              props: { ...op.props },
+              parentId: null,
+              children: []
+            });
+            rootOrder.push(op.id);
+            structural = true;
+            break;
+          }
+          case "insert": {
+            const n = mirror.get(op.id);
+            if (!n) break;
+            if (n.parentId !== null) {
+              const old = mirror.get(n.parentId);
+              if (old) {
+                const i = old.children.indexOf(n.id);
+                if (i >= 0) old.children.splice(i, 1);
+              }
+            } else {
+              const i = rootOrder.indexOf(n.id);
+              if (i >= 0) rootOrder.splice(i, 1);
+            }
+            n.parentId = op.parentId;
+            if (op.parentId === null) {
+              rootOrder.push(n.id);
+            } else {
+              const p = mirror.get(op.parentId);
+              if (p) {
+                const at = op.anchorId === void 0 ? -1 : p.children.indexOf(op.anchorId);
+                if (at >= 0) p.children.splice(at, 0, n.id);
+                else p.children.push(n.id);
+              }
+            }
+            structural = true;
+            break;
+          }
+          case "remove": {
+            removeSubtree(op.id);
+            structural = true;
+            break;
+          }
+          case "patch": {
+            const n = mirror.get(op.id);
+            if (!n) break;
+            if (op.next === null || op.next === void 0) delete n.props[op.key];
+            else n.props[op.key] = op.next;
+            patch(op.id, op.key, op.next);
+            break;
+          }
+          case "text": {
+            const n = mirror.get(op.id);
+            if (!n) break;
+            n.text = op.text;
+            patch(op.id, "text", op.text);
+            break;
+          }
+        }
+      }
+      if (!mounted) {
+        host.mount(JSON.stringify({ viewport: opts.viewport, nodes: specs() }));
+        mounted = true;
+        lastKind = "mount";
+      } else if (structural) {
+        host.update(JSON.stringify({ viewport: opts.viewport, nodes: specs() }));
+        lastKind = "update";
+      } else {
+        const arr = [...patched.entries()].map(([id, style]) => ({ id, style }));
+        host.updatePatches(JSON.stringify(arr));
+        lastKind = "updatePatches";
+      }
+      calls++;
+    },
+    hostCalls() {
+      return calls;
+    },
+    lastCallKind() {
+      return lastKind;
+    },
+    nodeSpecs() {
+      return specs();
+    },
+    commitCount() {
+      return calls;
     }
   };
 }
@@ -735,6 +954,7 @@ var SEMANTIC_FLUTTER_MAP = {
   "layout.split": "Row",
   "layout.safe": "SafeArea",
   "layout.sidebar": "NavigationRail",
+  "layout.formfactor": "LayoutBuilder.formFactor",
   "ui.text": "Text",
   "ui.button": "FilledButton",
   "ui.image": "Image",
@@ -765,6 +985,8 @@ var SEMANTIC_FLUTTER_MAP = {
   "shell.segment": "SegmentedButton",
   "shell.popover": "showMenu",
   "shell.action-sheet": "showModalBottomSheet",
+  "shell.toast": "ScaffoldMessenger.showSnackBar",
+  "ui.loading": "CircularProgressIndicator",
   "ui.rich-text": "RichText",
   "ui.avatar": "CircleAvatar",
   "ui.media": "VideoPlayer",
@@ -846,6 +1068,18 @@ function createFlutterBackend() {
       nodes.set(descriptor.id, descriptor);
       return descriptor;
     },
+    // ★2026-09-26 文本保留：'#text' → Text widget 描述符
+    createText(text) {
+      const descriptor = {
+        id: nextId++,
+        widget: "Text",
+        props: {},
+        children: [],
+        parent: null,
+        text
+      };
+      return descriptor;
+    },
     insert(child, parent, anchor) {
       const c = ensureNode(child);
       const p = ensureNode(parent);
@@ -990,6 +1224,10 @@ function createHybridRenderer(options) {
       }
       return handle;
     },
+    // ★2026-09-26 文本保留：'#text' → 委托默认后端（文本无 semantic 不可路由——区域语义由父元素决定）
+    createText(text) {
+      return defaultBackend.createText(text);
+    },
     insert(child, parent, anchor) {
       const b = backendOf(child);
       if (!b) return;
@@ -1129,8 +1367,17 @@ var TAG_SEMANTIC_MAP = {
   "p-segment": "shell.segment",
   "p-drawer": "shell.drawer",
   "p-modal": "shell.modal",
+  // ★★★GP4-c（2026-10-03）：登录失效拦截弹窗——与 p-modal **同语义**（模态弹窗）、
+  //   **不同可取消性**（本组件不可取消：无关闭按钮/点遮罩不关；唯一出口是登录态恢复）。
+  //   ★不登记 ⇒ 编译期按"未注册自定义组件"输出 ⇒ MP 端不渲染（M3 门禁会当场红）
+  "p-auth-gate": "shell.modal",
   "p-popover": "shell.popover",
   "p-toast": "shell.toast",
+  // ★★★GP4-a/b（2026-10-03）：两个**浮层宿主**同属其能力的语义（multi-tag 别名——同 ui.loading 的先例）。
+  //   · p-toast-host：Toast 队列的渲染端（构建期按需注入）
+  //   · p-loading-host：Loading 多实例的渲染端（同上）
+  //   ★不登记 ⇒ 编译期按"未注册自定义组件"输出 ⇒ **MP 端不渲染**（M3 门禁当场抓出）
+  "p-toast-host": "shell.toast",
   "p-action-sheet": "shell.action-sheet",
   "p-split": "layout.split",
   // ★已落地绑定（G-32 S10 分栏语义——layout.split 承载）
@@ -1168,7 +1415,16 @@ var TAG_SEMANTIC_MAP = {
   //    ——同一语义由两个标签提供；本条与 p-view 是并列的别名情形，非「先例」关系）
   "p-aspect": "layout.aspect",
   "p-zone": "layout.zone",
+  "p-formfactor": "layout.formfactor",
+  // ★★Fluid System v2：柔性形态容器
   "p-loading": "ui.loading",
+  // ★★★GP4-b（2026-10-03）：Loading **多实例宿主**与**区域遮罩**同属 ui.loading 语义（multi-tag 别名，
+  //   与上一行 `router-link`/`p-view` 的"同一语义多标签"同款）。
+  //   · p-loading-host：命令式多实例的渲染端（由构建期按需注入——用户一般不手写）
+  //   · p-loading-region：区域遮罩（就地包裹，用户手写）
+  //   ★不登记 ⇒ 编译期按"未注册自定义组件"输出 ⇒ MP 端不渲染（M3 门禁当场抓出——它是对的）
+  "p-loading-host": "ui.loading",
+  "p-loading-region": "ui.loading",
   "p-scale": "ui.scale",
   "p-skeleton": "ui.skeleton",
   "p-mask": "shell.mask",
@@ -1219,6 +1475,8 @@ var LAYOUT = [
   // ★#405 语义登记批：Fluid 体系剩余组件（语义层待多端映射 → planned L2——G-31.4 不足 3 端降级）
   { id: "L13", kind: "layout", semantic: "layout.aspect", tag: "p-aspect", props: ["ratio", "maxWidth"], mpEquiv: "\u65E0\uFF08\u7EB5\u6A2A\u6BD4\u5BB9\u5668\uFF09", tier: "L2", status: "planned" },
   { id: "L14", kind: "layout", semantic: "layout.zone", tag: "p-zone", props: ["designWidth"], mpEquiv: "\u65E0\uFF08\u5BB9\u5668\u65AD\u70B9\u5206\u533A\uFF09", tier: "L2", status: "planned" },
+  // ★★Fluid System v2（2026-09-26）：柔性形态容器——按设备形态自动编排布局拓扑/能力/密度/缩放
+  { id: "L26", kind: "layout", semantic: "layout.formfactor", tag: "p-formfactor", props: ["declared", "width", "height"], mpEquiv: "\u65E0\uFF08\u5F62\u6001\u7F16\u6392\u5BB9\u5668\uFF1Aglance/stack/duo/rail-split/rail-grid/dashboard/hero-focus-row\uFF09", tier: "L2", status: "implemented" },
   // ★批次 7（2026-09-18）未登记组件补登记：安全区（刘海/折叠屏/降级）+ 侧边导航容器
   { id: "L15", kind: "layout", semantic: "layout.safe", tag: "p-safe", props: ["area", "fold", "fallback"], mpEquiv: "\u65E0\uFF08\u5B89\u5168\u533A\u8BED\u4E49\u5BB9\u5668\uFF09", tier: "L1", status: "implemented" },
   { id: "L16", kind: "layout", semantic: "layout.sidebar", tag: "p-sidebar", props: ["minSidebarWidth", "navWidth", "designWidth", "toggleLabel"], mpEquiv: "\u65E0\uFF08\u5BB9\u5668\u65AD\u70B9\u4FA7\u680F\uFF09", tier: "L1", status: "implemented" }
@@ -1243,7 +1501,9 @@ var UI = [
   { id: "U17", kind: "ui", semantic: "ui.picker", tag: "p-picker", props: ["mode", "start", "end", "indicatorStyle", "indicatorClass", "maskClass", "maskStyle", "immediateChange"], 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" },
   // ★#405 语义登记批：反馈/状态类组件
-  { id: "U19", kind: "ui", semantic: "ui.loading", tag: "p-loading", props: ["size", "text"], mpEquiv: "wx.showLoading \u90E8\u5206", tier: "L2", status: "planned" },
+  // ★2026-09-30 反馈组件补齐：组件本体（p-loading）与 MP 产物测试早已存在，
+  //   缺的只是 SEMANTIC_BACKEND_MAP 的后端映射登记 ⇒ 补齐后据实转 implemented（**修记账非修能力**）
+  { id: "U19", kind: "ui", semantic: "ui.loading", tag: "p-loading", props: ["size", "text"], mpEquiv: "wx.showLoading \u90E8\u5206", tier: "L1", status: "implemented" },
   { id: "U20", kind: "ui", semantic: "ui.scale", tag: "p-scale", props: ["level", "density", "baseSize"], mpEquiv: "\u65E0\uFF08\u65E0\u969C\u788D\u6863\u4F4D\uFF09", tier: "L2", status: "planned" },
   { id: "U21", kind: "ui", semantic: "ui.skeleton", tag: "p-skeleton", props: ["rows", "avatar", "animated"], mpEquiv: "\u65E0", tier: "L2", status: "planned" },
   // ★能力颗粒度对齐 C2：进度条 / 表单标签
@@ -1271,7 +1531,8 @@ var SHELL = [
   { 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" },
+  // ★2026-09-30 同上（p-toast 已有 MP 产物测试 + 7 端映射 ⇒ 据实转 implemented）
+  { id: "S8", kind: "shell", semantic: "shell.toast", tag: "p-toast", props: ["message", "duration", "type"], mpEquiv: "wx.showToast", tier: "L1", status: "implemented" },
   { 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——机器事实以实现为准）
@@ -1332,9 +1593,13 @@ var CAPABILITY = [
   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"),
+  // ★★2026-09-30：C23/C24/C25 App 宿主腿落地（此前仅 wx/web 两桥 ⇒ App 端形同虚设）——
+  //   App 桥 `packages/api/src/capability-app.ts`（总线 + 三能力 + 虚拟栈页面事件翻译器）；
+  //   真机判据 `check:host-runtime` ①~⑤（冷启动补 launch / 真实栈驱动页面生命周期 /
+  //   壳真实事件逐条驱动总线 / 启动参数经 job 泵 / 阶段快照）。
+  { id: "C23", kind: "capability", semantic: "capability.app-lifecycle", api: "useAppLifecycle()", props: ["LifecycleHooks"], mpEquiv: "App.onLaunch/onShow", tier: "L1", status: "implemented" },
+  { id: "C24", kind: "capability", semantic: "capability.page-lifecycle", api: "usePageLifecycle()", props: ["LifecycleHooks"], mpEquiv: "Page.onLoad/onShow", tier: "L1", status: "implemented" },
+  { id: "C25", kind: "capability", semantic: "capability.background", api: "useBackground()", props: ["BackgroundAPI"], mpEquiv: "wx.onBackground", tier: "L1", status: "implemented" },
   // 7.3 通信/数据（10）
   cap("C26", "fetch", "useFetch()", "wx.request", "Promise<T>"),
   cap("C27", "websocket", "useWebSocket()", "wx.connectSocket", "WSConnection"),
@@ -1360,15 +1625,15 @@ var CAPABILITY = [
   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: "C47", kind: "capability", semantic: "capability.mini-program", api: "useMiniProgram()", props: ["MPContext"], mpEquiv: "wx.navigateToMiniProgram", tier: "L1", status: "implemented" },
+  { id: "C48", kind: "capability", semantic: "capability.embedded", api: "useEmbedded()", props: ["HostContext"], mpEquiv: "\u65E0\uFF08\u88AB\u5BBF\u4E3B\u5D4C\u5165\uFF09", tier: "L1", status: "implemented" },
   { 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" },
+  { 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: "implemented" },
   // ★颗粒度对齐 C（2026-09-11）：C51 小程序热更新（wx.getUpdateManager）
-  { id: "C51", kind: "capability", semantic: "capability.update", api: "useUpdate()", props: ["UpdateManagerAPI"], mpEquiv: "wx.getUpdateManager", tier: "L1", status: "planned" },
+  { id: "C51", kind: "capability", semantic: "capability.update", api: "useUpdate()", props: ["UpdateManagerAPI"], mpEquiv: "wx.getUpdateManager", tier: "L1", status: "implemented" },
   // ★颗粒度对齐 C3（2026-09-11）：相册 / Worker（对齐小程序媒体与多线程 API——纯 Hook，无 C-IR 节点 → planned）
   { id: "C52", kind: "capability", semantic: "capability.album", api: "useAlbum()", props: ["AlbumAPI"], mpEquiv: "wx.chooseMedia/saveImageToPhotosAlbum/previewMedia", tier: "L1", status: "planned" },
-  { id: "C53", kind: "capability", semantic: "capability.worker", api: "useWorker()", props: ["WorkerHandle"], mpEquiv: "wx.createWorker", tier: "L1", status: "planned" },
+  { id: "C53", kind: "capability", semantic: "capability.worker", api: "useWorker()", props: ["WorkerHandle"], mpEquiv: "wx.createWorker", tier: "L1", status: "implemented" },
   // ★颗粒度对齐 C3 批 2：收货地址 / WiFi / 微信运动（对齐小程序系统 API——纯 Hook → planned）
   { id: "C54", kind: "capability", semantic: "capability.address", api: "useAddress()", props: ["ShippingAddress"], mpEquiv: "wx.chooseAddress", tier: "L1", status: "planned" },
   { id: "C55", kind: "capability", semantic: "capability.wifi", api: "useWifi()", props: ["WifiAPI"], mpEquiv: "wx.getConnectedWifi/getWifiList/connectWifi", tier: "L1", status: "planned" },
@@ -1388,7 +1653,7 @@ var CAPABILITY = [
   { id: "C65", kind: "capability", semantic: "capability.privacy", api: "usePrivacy()", props: ["PrivacyAPI"], mpEquiv: "wx.getPrivacySetting/openPrivacyContract/requirePrivacyAuthorize", tier: "L1", status: "planned" },
   // ★权威标尺缺口补齐批 D（2026-09-12）：性能 / 预加载 / 图像编辑（通用能力，无资质门槛）
   { id: "C66", kind: "capability", semantic: "capability.performance", api: "usePerformance()", props: ["PerformanceAPI"], mpEquiv: "wx.getPerformance/reportPerformance", tier: "L1", status: "planned" },
-  { id: "C67", kind: "capability", semantic: "capability.preload", api: "usePreload()", props: ["PreloadAPI"], mpEquiv: "wx.preloadAssets/preloadSkylineView/preloadWebview/preDownloadSubpackage", tier: "L1", status: "planned" },
+  { id: "C67", kind: "capability", semantic: "capability.preload", api: "usePreload()", props: ["PreloadAPI"], mpEquiv: "wx.preloadAssets/preloadSkylineView/preloadWebview/preDownloadSubpackage", tier: "L1", status: "implemented" },
   { id: "C68", kind: "capability", semantic: "capability.image-edit", api: "useImageEdit()", props: ["ImageEditAPI"], mpEquiv: "wx.cropImage/editImage", tier: "L1", status: "planned" },
   // ★权威标尺缺口补齐批 E（2026-09-12）：网络底层 / 媒体高级
   { id: "C69", kind: "capability", semantic: "capability.socket", api: "useSocket()", props: ["UDPSocketHandle / TCPSocketHandle"], mpEquiv: "wx.createUDPSocket/createTCPSocket", tier: "L1", status: "planned" },
@@ -1396,16 +1661,37 @@ var CAPABILITY = [
   // ★权威标尺缺口补齐批 F（2026-09-12）：录屏/缓存/空闲/窗口/导航拦截
   { id: "C71", kind: "capability", semantic: "capability.screen-capture", api: "useScreenCapture()", props: ["ScreenCaptureAPI"], mpEquiv: "wx.getScreenRecordingState/onScreenRecordingStateChanged/onUserCaptureScreen/checkIsPictureInPictureActive", tier: "L1", status: "planned" },
   { id: "C72", kind: "capability", semantic: "capability.cache-manager", api: "useCacheManager()", props: ["CacheManagerHandle"], mpEquiv: "wx.createCacheManager", tier: "L1", status: "planned" },
-  { id: "C73", kind: "capability", semantic: "capability.idle", api: "useIdle()", props: ["IdleAPI"], mpEquiv: "wx.requestIdleCallback/cancelIdleCallback", tier: "L1", status: "planned" },
-  { id: "C74", kind: "capability", semantic: "capability.window", api: "useWindow()", props: ["WindowAPI"], mpEquiv: "wx.setWindowSize", tier: "L1", status: "planned" },
-  { id: "C75", kind: "capability", semantic: "capability.navigation-guard", api: "useNavigationGuard()", props: ["NavigationGuardAPI"], mpEquiv: "wx.enableAlertBeforeUnload/disableAlertBeforeUnload", tier: "L1", status: "planned" },
+  { id: "C73", kind: "capability", semantic: "capability.idle", api: "useIdle()", props: ["IdleAPI"], mpEquiv: "wx.requestIdleCallback/cancelIdleCallback", tier: "L1", status: "implemented" },
+  { id: "C74", kind: "capability", semantic: "capability.window", api: "useWindow()", props: ["WindowAPI"], mpEquiv: "wx.setWindowSize", tier: "L1", status: "implemented" },
+  { id: "C75", kind: "capability", semantic: "capability.navigation-guard", api: "useNavigationGuard()", props: ["NavigationGuardAPI"], mpEquiv: "wx.enableAlertBeforeUnload/disableAlertBeforeUnload", tier: "L1", status: "implemented" },
   // ★权威标尺缺口补齐批 G（2026-09-12）：AR/XR / iBeacon / 局域网 / 翻译 / 海报 / 设备探测
   { id: "C76", kind: "capability", semantic: "capability.ar", api: "useAR()", props: ["ARAPI"], mpEquiv: "wx.createVKSession/isVKSupport", tier: "L1", status: "planned" },
   { id: "C77", kind: "capability", semantic: "capability.beacon", api: "useBeacon()", props: ["BeaconAPI"], mpEquiv: "wx.onBeaconServiceChange/onBeaconUpdate", tier: "L1", status: "planned" },
   { id: "C78", kind: "capability", semantic: "capability.local-service", api: "useLocalService()", props: ["LocalServiceAPI"], mpEquiv: "wx.onLocalServiceFound/Lost/ResolveFail/DiscoveryStop", tier: "L1", status: "planned" },
   { id: "C79", kind: "capability", semantic: "capability.translation", api: "useTranslation()", props: ["TranslationAPI"], mpEquiv: "wx.onUserTriggerTranslation/onUserOffTranslation", tier: "L1", status: "planned" },
   { id: "C80", kind: "capability", semantic: "capability.poster", api: "usePoster()", props: ["PosterAPI"], mpEquiv: "wx.onGeneratePoster", tier: "L1", status: "planned" },
-  { id: "C81", kind: "capability", semantic: "capability.device-capability", api: "useDeviceCapability()", props: ["DeviceCapabilityAPI"], mpEquiv: "wx.checkDeviceSupportHevc", tier: "L1", status: "planned" }
+  { id: "C81", kind: "capability", semantic: "capability.device-capability", api: "useDeviceCapability()", props: ["DeviceCapabilityAPI"], mpEquiv: "wx.checkDeviceSupportHevc", tier: "L1", status: "planned" },
+  // ★C82（2026-09-29）：WebAssembly 跨平台实现——**超官方清单**能力（官方 301 API 里无 wasm）。
+  //   三端形态有实质差异（双源取证：微信官方文档 /framework/performance/wasm.html +
+  //   miniprogram-api-typings/lib.wx.wasm.d.ts）：
+  //   MP `WXWebAssembly.instantiate(path)` 只收**代码包路径**（.wasm/.wasm.br）· 无 compile/validate ·
+  //   v2.13.0+ 全局 / v2.15.0+ Worker；Web 与 App-iOS(JSC) 走标准 `WebAssembly`（收字节 · 有 compile/validate）；
+  //   App-Android 由**宿主 wasm3** 执行（QuickJS 内建无 WASM——双端真机验证 add(2,40)=42）。
+  //   ⇒ 归一入口 `instantiate({bytes}|{path})` + 能力位 `supportsStreaming`/`supportsPathLoad`。
+  { id: "C82", kind: "capability", semantic: "capability.webassembly", api: "useWebAssembly()", props: ["WebAssemblyAPI"], mpEquiv: "WXWebAssembly.instantiate\uFF08\u5B98\u65B9\u6587\u6863 performance/wasm\uFF09", tier: "L1", status: "implemented" },
+  // ★★NC1 首个声明式能力（2026-09-30）：来源 = 权威标尺修复后浮现的真实缺口之一
+  //   （快照抽取器修复前 `wx.setKeepScreenOn` 结构性不可见，见 mp-spec-coverage 的 SPEC_PLANNED）。
+  //   落地方式 = **声明式**（`packages/api/src/bridge-decls/keep-screen-on.ts` → 生成 → 合并进 bridge）：
+  //   MP `wx.setKeepScreenOn` / Web **Screen Wake Lock**（`navigator.wakeLock.request('screen')`）——
+  //   双端都有真实对等（非降级对等）。status 标 implemented：桥与 Hook 已落地且测试覆盖
+  //   （含双端真跑 + 幂等 + 缺 API 降级）。
+  { id: "C83", kind: "capability", semantic: "capability.keep-screen-on", api: "useKeepScreenOn()", props: ["KeepScreenOnState"], mpEquiv: "wx.setKeepScreenOn\uFF08Web \u5BF9\u7B49\uFF1AScreen Wake Lock API\uFF09", tier: "L1", status: "implemented" },
+  // ★★NC1 第二个声明式能力（2026-09-30）：**用户裁定**「openDocument 属原生能力落地范畴，
+  //   目标就是 99% 的业务代码不需要写原生代码」⇒ 落地而非搁置。
+  //   形态 = 声明式（bridge-decls/open-document.ts → 生成 → 合并）；MP `wx.openDocument` /
+  //   Web `window.open`（浏览器查看器）；★Web 诚实边界：office 格式通常转下载而非预览。
+  //   status = implemented：桥与 Hook 已落地 + 测试覆盖（含"弹窗被拦截 ⇒ Err"的防静默判据）。
+  { id: "C84", kind: "capability", semantic: "capability.document-preview", api: "useOpenDocument()", props: ["DocumentPath"], mpEquiv: "wx.openDocument\uFF08Web \u5BF9\u7B49\uFF1Awindow.open \u2192 \u6D4F\u89C8\u5668\u67E5\u770B\u5668\uFF09", tier: "L1", status: "implemented" }
 ];
 var ENGINEERING = [
   { id: "E1", kind: "engineering", semantic: "engineering.state", api: "useState()", mpEquiv: "data", tier: "L1", status: "planned" },
@@ -1551,6 +1837,10 @@ var MP_API_GROUPS = [
   { mp: "wx.onUserTriggerTranslation/onUserOffTranslation\uFF08\u7FFB\u8BD1\uFF09", proteus: "useTranslation", status: "ok", group: "api" },
   { mp: "wx.onGeneratePoster\uFF08\u5206\u4EAB\u6D77\u62A5\uFF09", proteus: "usePoster", status: "ok", group: "api" },
   { mp: "wx.checkDeviceSupportHevc\uFF08\u8BBE\u5907\u80FD\u529B\u63A2\u6D4B\uFF09", proteus: "useDeviceCapability", status: "ok", group: "api" },
+  // ★C82：**超官方清单**能力（官方 301 API 列表里无 wasm）——`WXWebAssembly` 属官方「小程序运行时」
+  //   文档（performance/wasm）确认的运行时能力 ⇒ 矩阵按 mpEquiv 如实登记；
+  //   不进 spec 覆盖度分母（否则分母不变而 covered 虚增，覆盖率失真——见 mp-spec-coverage 注释）
+  { mp: "WXWebAssembly.instantiate\uFF08WebAssembly \u8DE8\u5E73\u53F0\uFF0C\u5B98\u65B9\u6587\u6863 performance/wasm\uFF09", proteus: "useWebAssembly", status: "ok", group: "api" },
   { mp: "wx.getFileSystemManager/*\uFF08\u6587\u4EF6 30+\uFF09", proteus: "useFileSystem", status: "ok", group: "api" },
   { mp: "wx.compressFile/unzip", proteus: "useArchive", status: "ok", group: "api" },
   { mp: "wx.set/get/remove/clearStorage(+Sync)", proteus: "useStorage", status: "ok", group: "api" },
@@ -1647,38 +1937,2020 @@ function degradeProp(tag, prop) {
   if (tag && HOST_TAGS[tag]) {
     return { mp: "supported", web: "fallback", behavior: HOST_TAGS[tag] };
   }
-  const tagProp = tag ? TAG_PROP_MP_FALLBACK[tag] : void 0;
-  const tagPropBehavior = tagProp ? tagProp[prop] : void 0;
-  if (tagPropBehavior) return { mp: "fallback", web: "supported", behavior: tagPropBehavior };
-  const webExt = WEB_EXTENSION_MP_FALLBACK[prop];
-  if (webExt) return { mp: "fallback", web: "supported", behavior: webExt };
-  return { mp: "supported", web: "supported" };
+  const tagProp = tag ? TAG_PROP_MP_FALLBACK[tag] : void 0;
+  const tagPropBehavior = tagProp ? tagProp[prop] : void 0;
+  if (tagPropBehavior) return { mp: "fallback", web: "supported", behavior: tagPropBehavior };
+  const webExt = WEB_EXTENSION_MP_FALLBACK[prop];
+  if (webExt) return { mp: "fallback", web: "supported", behavior: webExt };
+  return { mp: "supported", web: "supported" };
+}
+function degradationOf(prim) {
+  const out = {};
+  for (const p of prim.props ?? []) out[p] = degradeProp(prim.tag, p);
+  return out;
+}
+var DEGRADATION_TABLE = (() => {
+  const out = {};
+  for (const prim of PRIMITIVE_CATALOG) {
+    if (!prim.tag) continue;
+    out[prim.tag] = degradationOf(prim);
+  }
+  return out;
+})();
+var MP_UNSUPPORTED_PROPS = (() => {
+  const kebab = (s) => s.replace(/([a-z0-9])([A-Z])/g, "$1-$2").toLowerCase();
+  const out = {};
+  for (const [tag, table] of Object.entries(DEGRADATION_TABLE)) {
+    const set = /* @__PURE__ */ new Set();
+    for (const [prop, entry] of Object.entries(table)) {
+      if (entry.mp === "unsupported") set.add(kebab(prop));
+    }
+    if (set.size) out[tag] = set;
+  }
+  return out;
+})();
+
+// ../slot-runtime/src/opcode.ts
+var PropKeyTable = class _PropKeyTable {
+  constructor() {
+    this.keys = [];
+    this.index = /* @__PURE__ */ new Map();
+  }
+  /** 分配（已存在则返回原下标——**幂等**） */
+  intern(key) {
+    const hit = this.index.get(key);
+    if (hit !== void 0) return hit;
+    const id = this.keys.length;
+    this.keys.push(key);
+    this.index.set(key, id);
+    return id;
+  }
+  /** 反查（诊断 / explain 用；运行时不走这条路径） */
+  keyOf(id) {
+    return this.keys[id];
+  }
+  get size() {
+    return this.keys.length;
+  }
+  /** 导出（进 PatchTable 产物） */
+  toArray() {
+    return [...this.keys];
+  }
+  /** 导入（消费方重建） */
+  static fromArray(keys) {
+    const t = new _PropKeyTable();
+    for (const k of keys) t.intern(k);
+    return t;
+  }
+};
+var StringPool = class _StringPool {
+  constructor() {
+    this.values = [];
+    this.index = /* @__PURE__ */ new Map();
+  }
+  intern(s) {
+    const hit = this.index.get(s);
+    if (hit !== void 0) return hit;
+    const id = this.values.length;
+    this.values.push(s);
+    this.index.set(s, id);
+    return id;
+  }
+  valueOf(id) {
+    return this.values[id];
+  }
+  get size() {
+    return this.values.length;
+  }
+  toArray() {
+    return [...this.values];
+  }
+  static fromArray(values) {
+    const p = new _StringPool();
+    for (const v of values) p.intern(v);
+    return p;
+  }
+};
+
+// ../slot-runtime/src/anim-curve.ts
+var AnimCurve = {
+  LINEAR: 0,
+  EASE_OUT_CUBIC: 1,
+  EASE_IN_CUBIC: 2,
+  EASE_IN_OUT_CUBIC: 3,
+  SPRING_APPROX: 4
+};
+var TABLE_N = 65;
+function springApprox(u) {
+  return 1 - Math.exp(-6 * u) * Math.cos(10 * u);
+}
+function buildTable(curve) {
+  const t = new Float64Array(TABLE_N);
+  for (let i = 0; i < TABLE_N; i++) {
+    const u = i / (TABLE_N - 1);
+    t[i] = curve === AnimCurve.EASE_OUT_CUBIC ? 1 - (1 - u) ** 3 : curve === AnimCurve.EASE_IN_CUBIC ? u ** 3 : curve === AnimCurve.EASE_IN_OUT_CUBIC ? u < 0.5 ? 4 * u ** 3 : 1 - (-2 * u + 2) ** 3 / 2 : curve === AnimCurve.SPRING_APPROX ? springApprox(u) : u;
+  }
+  t[0] = 0;
+  t[TABLE_N - 1] = 1;
+  return t;
+}
+var TABLES = [
+  buildTable(AnimCurve.LINEAR),
+  buildTable(AnimCurve.EASE_OUT_CUBIC),
+  buildTable(AnimCurve.EASE_IN_CUBIC),
+  buildTable(AnimCurve.EASE_IN_OUT_CUBIC),
+  buildTable(AnimCurve.SPRING_APPROX)
+];
+
+// ../slot-runtime/src/buffer.ts
+var OPS_MAGIC = 1347376720;
+var OPS_VERSION = 2;
+var OPS_HEADER_BYTES = 20;
+function opSize(op) {
+  switch (op.op) {
+    case 1 /* SET_PROP */:
+    case 2 /* SET_STYLE */:
+      return 11;
+    case 3 /* SET_TEXT */:
+      return 9;
+    case 4 /* SET_ATTRS */:
+      return 7 + 6 * op.attrs.length;
+    case 5 /* TOGGLE_VIS */:
+      return 6;
+    case 16 /* INSERT_BLOCK */:
+      return 10;
+    case 17 /* REMOVE_NODE */:
+      return 5;
+    case 18 /* MOVE_NODE */:
+      return 10;
+    case 32 /* LIST_SET */:
+      return 9;
+    case 33 /* LIST_SPLICE */:
+      return 15 + 4 * op.itemKeyRefs.length;
+    case 34 /* LIST_UPDATE */:
+      return 17;
+    case 48 /* CALL_COMPONENT_UPDATE */:
+      return 13;
+    default: {
+      const never = op;
+      throw new Error(`\u672A\u77E5\u6307\u4EE4\uFF1A${JSON.stringify(never)}`);
+    }
+  }
+}
+var ByteWriter = class {
+  constructor(size) {
+    this.pos = 0;
+    this.buf = new Uint8Array(size);
+  }
+  u8(v) {
+    this.buf[this.pos++] = v & 255;
+  }
+  u16(v) {
+    this.buf[this.pos++] = v & 255;
+    this.buf[this.pos++] = v >>> 8 & 255;
+  }
+  u32(v) {
+    this.buf[this.pos++] = v & 255;
+    this.buf[this.pos++] = v >>> 8 & 255;
+    this.buf[this.pos++] = v >>> 16 & 255;
+    this.buf[this.pos++] = v >>> 24 & 255;
+  }
+  f32(v) {
+    const f = new Float32Array(1);
+    f[0] = v;
+    const b = new Uint8Array(f.buffer);
+    this.buf[this.pos++] = b[0];
+    this.buf[this.pos++] = b[1];
+    this.buf[this.pos++] = b[2];
+    this.buf[this.pos++] = b[3];
+  }
+  str(s) {
+    const bytes = utf8Encode(s);
+    if (bytes.length > 65535) throw new Error(`\u5B57\u7B26\u4E32\u8FC7\u957F\uFF08>65535B\uFF09\uFF1A${bytes.length}`);
+    this.u16(bytes.length);
+    this.buf.set(bytes, this.pos);
+    this.pos += bytes.length;
+  }
+  done() {
+    if (this.pos !== this.buf.length) throw new Error(`\u5199\u5165\u957F\u5EA6\u4E0D\u7B26\uFF1A${this.pos} != ${this.buf.length}`);
+    return this.buf;
+  }
+};
+function utf8Encode(s) {
+  const out = [];
+  for (let i = 0; i < s.length; i++) {
+    let cp = s.charCodeAt(i);
+    if (cp >= 55296 && cp <= 56319 && i + 1 < s.length) {
+      const lo = s.charCodeAt(i + 1);
+      if (lo >= 56320 && lo <= 57343) {
+        cp = (cp - 55296 << 10) + (lo - 56320) + 65536;
+        i++;
+      }
+    }
+    if (cp < 128) out.push(cp);
+    else if (cp < 2048) out.push(192 | cp >> 6, 128 | cp & 63);
+    else if (cp < 65536) out.push(224 | cp >> 12, 128 | cp >> 6 & 63, 128 | cp & 63);
+    else out.push(240 | cp >> 18, 128 | cp >> 12 & 63, 128 | cp >> 6 & 63, 128 | cp & 63);
+  }
+  return Uint8Array.from(out);
+}
+var OpBuffer = class {
+  constructor() {
+    this.ops = [];
+  }
+  push(op) {
+    this.ops.push(op);
+  }
+  get count() {
+    return this.ops.length;
+  }
+  /** 只读快照（调试 / explain / 测试用） */
+  snapshot() {
+    return this.ops.slice();
+  }
+  clear() {
+    this.ops.length = 0;
+  }
+  /**
+   * 编码并提交，随后**清空**。
+   *
+   * @param keys    属性键表（进入 Header，供消费方还原 keyId → 字符串）
+   * @param strings 字符串池（同上）
+   * @param sink    提交出口（App 端 = 一次 JSI 调用）
+   * @returns 本次提交的字节数
+   */
+  flush(keys, strings, sink) {
+    const bytes = encodeOps(this.ops, keys, strings);
+    const n = this.ops.length;
+    sink(bytes, n);
+    this.ops.length = 0;
+    return bytes.length;
+  }
+};
+function collectRefs(ops) {
+  const k = /* @__PURE__ */ new Set();
+  const s = /* @__PURE__ */ new Set();
+  for (const op of ops) {
+    switch (op.op) {
+      case 1 /* SET_PROP */:
+      case 2 /* SET_STYLE */:
+        k.add(op.keyId);
+        break;
+      case 4 /* SET_ATTRS */:
+        for (const a of op.attrs) k.add(a.keyId);
+        break;
+      case 3 /* SET_TEXT */:
+        s.add(op.textRef);
+        break;
+      case 33 /* LIST_SPLICE */:
+        for (const r of op.itemKeyRefs) s.add(r);
+        break;
+      case 34 /* LIST_UPDATE */:
+        s.add(op.itemKeyRef);
+        break;
+      // TOGGLE_VIS / INSERT_BLOCK / REMOVE_NODE / MOVE_NODE / LIST_SET /
+      // CALL_COMPONENT_UPDATE：无池引用（若将来新增，**在此处补一支**）
+      default:
+        break;
+    }
+  }
+  return { keyIds: [...k].sort((a, b) => a - b), strRefs: [...s].sort((a, b) => a - b) };
+}
+function remapOf(used) {
+  const m = /* @__PURE__ */ new Map();
+  used.forEach((old, i) => m.set(old, i));
+  return m;
+}
+function remapOp(op, kMap, sMap) {
+  switch (op.op) {
+    case 1 /* SET_PROP */:
+    case 2 /* SET_STYLE */:
+      return { ...op, keyId: kMap.get(op.keyId) ?? 0 };
+    case 4 /* SET_ATTRS */:
+      return { ...op, attrs: op.attrs.map((a) => ({ keyId: kMap.get(a.keyId) ?? 0, value: a.value })) };
+    case 3 /* SET_TEXT */:
+      return { ...op, textRef: sMap.get(op.textRef) ?? 0 };
+    case 33 /* LIST_SPLICE */:
+      return { ...op, itemKeyRefs: op.itemKeyRefs.map((r) => sMap.get(r) ?? 0) };
+    case 34 /* LIST_UPDATE */:
+      return { ...op, itemKeyRef: sMap.get(op.itemKeyRef) ?? 0 };
+    default:
+      return op;
+  }
+}
+function encodeOps(ops, keys, strings) {
+  const allKeys = keys.toArray();
+  const allStrs = strings.toArray();
+  const used = collectRefs(ops);
+  const keyArr = used.keyIds.map((i) => allKeys[i]).filter((x) => x !== void 0);
+  const strArr = used.strRefs.map((i) => allStrs[i]).filter((x) => x !== void 0);
+  const kMap = remapOf(used.keyIds.filter((i) => allKeys[i] !== void 0));
+  const sMap = remapOf(used.strRefs.filter((i) => allStrs[i] !== void 0));
+  let size = OPS_HEADER_BYTES;
+  for (const k of keyArr) size += 2 + utf8Encode(k).length;
+  for (const s of strArr) size += 2 + utf8Encode(s).length;
+  for (const op of ops) size += opSize(op);
+  const w = new ByteWriter(size);
+  w.u32(OPS_MAGIC);
+  w.u32(OPS_VERSION);
+  w.u32(ops.length);
+  w.u32(keyArr.length);
+  w.u32(strArr.length);
+  for (const k of keyArr) w.str(k);
+  for (const s of strArr) w.str(s);
+  for (const op of ops) encodeOp(w, remapOp(op, kMap, sMap));
+  return w.done();
+}
+function encodeOp(w, op) {
+  w.u8(op.op);
+  switch (op.op) {
+    case 1 /* SET_PROP */:
+    case 2 /* SET_STYLE */:
+      w.u32(op.nodeId);
+      w.u16(op.keyId);
+      w.f32(op.value);
+      return;
+    case 3 /* SET_TEXT */:
+      w.u32(op.nodeId);
+      w.u32(op.textRef);
+      return;
+    case 4 /* SET_ATTRS */:
+      w.u32(op.nodeId);
+      w.u16(op.attrs.length);
+      for (const a of op.attrs) {
+        w.u16(a.keyId);
+        w.f32(a.value);
+      }
+      return;
+    case 5 /* TOGGLE_VIS */:
+      w.u32(op.nodeId);
+      w.u8(op.visible ? 1 : 0);
+      return;
+    case 16 /* INSERT_BLOCK */:
+      w.u32(op.blockId);
+      w.u32(op.refNodeId);
+      w.u8(op.pos);
+      return;
+    case 17 /* REMOVE_NODE */:
+      w.u32(op.nodeId);
+      return;
+    case 18 /* MOVE_NODE */:
+      w.u32(op.nodeId);
+      w.u32(op.refNodeId);
+      w.u8(op.pos);
+      return;
+    case 32 /* LIST_SET */:
+      w.u32(op.listId);
+      w.u32(op.dataRef);
+      return;
+    case 33 /* LIST_SPLICE */:
+      w.u32(op.listId);
+      w.u32(op.start);
+      w.u32(op.delCount);
+      w.u16(op.itemKeyRefs.length);
+      for (const r of op.itemKeyRefs) w.u32(r);
+      return;
+    case 34 /* LIST_UPDATE */:
+      w.u32(op.listId);
+      w.u32(op.itemKeyRef);
+      w.u32(op.slotId);
+      w.f32(op.value);
+      return;
+    case 48 /* CALL_COMPONENT_UPDATE */:
+      w.u32(op.componentId);
+      w.u32(op.slotId);
+      w.f32(op.value);
+      return;
+    default: {
+      const never = op;
+      throw new Error(`\u672A\u77E5\u6307\u4EE4\uFF1A${JSON.stringify(never)}`);
+    }
+  }
+}
+
+// ../slot-runtime/src/slot.ts
+function createSlot(spec, keys, strings, initial, registry) {
+  const nodeId = spec.nodeId;
+  const keyId = spec.keyId ?? 0;
+  const listId = spec.listId ?? 0;
+  const listSlotId = spec.listSlotId ?? spec.id;
+  const slot = {
+    id: spec.id,
+    nodeId,
+    kind: spec.kind,
+    value: initial,
+    dirty: false,
+    emit(next, buf) {
+      switch (spec.kind) {
+        case "text":
+          buf.push({ op: 3 /* SET_TEXT */, nodeId, textRef: strings.intern(String(next)) });
+          return;
+        case "prop":
+          buf.push({ op: 1 /* SET_PROP */, nodeId, keyId, value: toF32(next) });
+          return;
+        case "style":
+          buf.push({ op: 2 /* SET_STYLE */, nodeId, keyId, value: toF32(next) });
+          return;
+        case "visibility":
+          buf.push({ op: 5 /* TOGGLE_VIS */, nodeId, visible: Boolean(next) });
+          return;
+        case "list-item": {
+          const item = next;
+          const nodeId2 = registry?.resolveNode(listId, item.key, listSlotId);
+          if (nodeId2 !== void 0) {
+            if ((spec.itemKind ?? "style") === "text") {
+              buf.push({ op: 3 /* SET_TEXT */, nodeId: nodeId2, textRef: strings.intern(String(item.value)) });
+            } else {
+              buf.push({ op: 2 /* SET_STYLE */, nodeId: nodeId2, keyId, value: toF32(item.value) });
+            }
+            return;
+          }
+          buf.push({
+            op: 34 /* LIST_UPDATE */,
+            listId,
+            itemKeyRef: strings.intern(item.key),
+            slotId: listSlotId,
+            value: toF32(item.value)
+          });
+          return;
+        }
+        case "list-data":
+          buf.push({ op: 32 /* LIST_SET */, listId, dataRef: toF32(next) });
+          return;
+        case "attrs": {
+          const attrs = next;
+          buf.push({ op: 4 /* SET_ATTRS */, nodeId, attrs });
+          return;
+        }
+        case "component-prop":
+          buf.push({ op: 48 /* CALL_COMPONENT_UPDATE */, componentId: nodeId, slotId: listSlotId, value: toF32(next) });
+          return;
+        default: {
+          const never = spec.kind;
+          throw new Error(`\u672A\u77E5\u69FD\u4F4D\u79CD\u7C7B\uFF1A${String(never)}`);
+        }
+      }
+    }
+  };
+  return slot;
+}
+function toF32(v) {
+  if (typeof v === "number") return v;
+  if (typeof v === "boolean") return v ? 1 : 0;
+  throw new Error(`\u69FD\u4F4D\u503C\u5FC5\u987B\u662F number/boolean\uFF0C\u6536\u5230 ${typeof v}\uFF08\u6587\u672C\u8BF7\u7528 kind='text'\uFF09`);
+}
+var microtaskScheduler = {
+  schedule(cb) {
+    void Promise.resolve().then(cb);
+  }
+};
+var SlotRuntime = class {
+  constructor(keys, strings, sink, scheduler = microtaskScheduler) {
+    this.keys = keys;
+    this.strings = strings;
+    this.sink = sink;
+    this.scheduler = scheduler;
+    this.buffer = new OpBuffer();
+    this.dirty = [];
+    this.pending = false;
+    this.stats = { flushes: 0, opsEmitted: 0, bytesSent: 0, shortCircuits: 0 };
+    /**
+     * ★★**帧号**（P2-5 新增）：每次 `flush()` 调用（**包括无脏槽位的空调用**）自增。
+     *
+     * 【为什么需要（v-memo 的组语义要求帧边界）】memo 组在"同一帧内"只判定一次脏：
+     *   若一帧里有多个源变化（多次 `writeSlotsOfSource`）触到同一组的多个槽位，
+     *   第一次判定"依赖变了"之后，同帧其余槽位必须**照常写**（组语义 = 子树整体更新）。
+     *   而判定一次的判据只有帧边界——`flush()` 是这套系统的天然帧边界。
+     *   ★与 `stats.flushes` 的区别：后者只在**真的提交了字节**时自增（空 flush 不计）；
+     *     本计数每次 flush 调用都自增（帧边界语义）。
+     */
+    this.frame = 0;
+  }
+  /** 帧号（v-memo 门用；只读） */
+  get frameId() {
+    return this.frame;
+  }
+  /** 槽位写入（方案 §3.3）：相等即短路；否则标脏 + 排帧 */
+  setSlot(slot, next) {
+    if (Object.is(slot.value, next)) {
+      this.stats.shortCircuits++;
+      return;
+    }
+    slot.value = next;
+    if (!slot.dirty) {
+      slot.dirty = true;
+      this.dirty.push(slot);
+    }
+    this.scheduleFlush();
+  }
+  /** 排帧（幂等——同帧多次调用只排一次） */
+  scheduleFlush() {
+    if (this.pending) return;
+    this.pending = true;
+    this.scheduler.schedule(() => this.flush());
+  }
+  /**
+   * 立即 flush（测试 / 确定性驱动用）
+   *
+   * 【为什么单独暴露】真机上「Vsync 何时来」不可控；测量装置纪律要求用例能**确定性地**
+   *   驱动一次提交（本仓四次踩过"测量装置污染读数"）。
+   */
+  flush() {
+    this.frame++;
+    this.pending = false;
+    for (const slot of this.dirty) {
+      slot.emit(slot.value, this.buffer);
+      slot.dirty = false;
+    }
+    this.dirty.length = 0;
+    if (this.buffer.count === 0) return;
+    this.stats.opsEmitted += this.buffer.count;
+    this.stats.bytesSent += this.buffer.flush(this.keys, this.strings, this.sink);
+    this.stats.flushes++;
+  }
+  getStats() {
+    return { ...this.stats };
+  }
+  /** 待发射的脏槽位数（诊断） */
+  get dirtyCount() {
+    return this.dirty.length;
+  }
+};
+
+// ../slot-runtime/src/table.ts
+function resolveDynamicClasses(classValue, rules) {
+  const active = collectActiveClasses(classValue);
+  if (active.size === 0 || rules.length === 0) return {};
+  const normal = {};
+  const important = {};
+  for (const r of rules) {
+    if (r.classes.length === 0) continue;
+    if (!r.classes.every((c) => active.has(c))) continue;
+    for (const [k, v] of Object.entries(r.decls)) {
+      if (r.important.includes(k)) important[k] = v;
+      else normal[k] = v;
+    }
+  }
+  return { ...normal, ...important };
+}
+function collectActiveClasses(v) {
+  const out = /* @__PURE__ */ new Set();
+  const walk = (x) => {
+    if (!x) return;
+    if (typeof x === "string") {
+      for (const c of x.split(/\s+/)) if (c) out.add(c);
+      return;
+    }
+    if (Array.isArray(x)) {
+      for (const e of x) walk(e);
+      return;
+    }
+    if (typeof x === "object") {
+      for (const [k, vv] of Object.entries(x)) if (vv) out.add(k);
+      return;
+    }
+  };
+  walk(v);
+  return out;
+}
+
+// ../slot-runtime/src/dynamic-class.ts
+function bitmapOfDynamicClasses(active, classes) {
+  let b = 0;
+  for (let i = 0; i < classes.length; i++) if (active.has(classes[i])) b |= 1 << i;
+  return b >>> 0;
+}
+function groupStateOf(bitmap, groupBits) {
+  for (let i = 0; i < groupBits.length; i++) if ((bitmap & 1 << groupBits[i]) !== 0) return i + 1;
+  return 0;
+}
+function applyDynamicClassPlan(classValue, plan, out) {
+  const tables = plan.tables;
+  const fields = Object.keys(tables);
+  if (fields.length === 0) return 0;
+  const active = collectActiveClasses(classValue);
+  const bitmap = bitmapOfDynamicClasses(active, plan.classes);
+  const groups = plan.mutexGroups;
+  let groupStates = null;
+  if (groups && groups.length > 0) {
+    groupStates = groups.map((bits) => groupStateOf(bitmap, bits));
+  }
+  let written = 0;
+  for (const field of fields) {
+    const t = tables[field];
+    let v;
+    if (t.kind === "bits") {
+      const masked = (bitmap & (t.mask ?? 0)) >>> 0;
+      v = t.values[t.map[masked]];
+    } else {
+      v = t.values[groupStates ? groupStates[t.group ?? 0] : 0];
+    }
+    out[field] = v;
+    written++;
+  }
+  return written;
+}
+
+// ../slot-runtime/src/expr.ts
+var PURE_CALLS = {
+  // —— Math（纯计算）——
+  "Math.abs": Math.abs,
+  "Math.ceil": Math.ceil,
+  "Math.floor": Math.floor,
+  "Math.round": Math.round,
+  "Math.trunc": Math.trunc,
+  "Math.sign": Math.sign,
+  "Math.sqrt": Math.sqrt,
+  "Math.cbrt": Math.cbrt,
+  "Math.pow": Math.pow,
+  "Math.exp": Math.exp,
+  "Math.log": Math.log,
+  "Math.log2": Math.log2,
+  "Math.log10": Math.log10,
+  "Math.min": Math.min,
+  "Math.max": Math.max,
+  // —— 类型转换（call 形态，非 new）——
+  "String": String,
+  "Number": Number,
+  "Boolean": Boolean,
+  // —— 解析 / 判定（全局）——
+  "parseInt": parseInt,
+  "parseFloat": parseFloat,
+  "isNaN": isNaN,
+  "isFinite": isFinite,
+  "Number.isFinite": Number.isFinite,
+  "Number.isInteger": Number.isInteger,
+  "Number.isNaN": Number.isNaN,
+  // —— 数组判定 ——
+  "Array.isArray": Array.isArray
+};
+var PURE_METHODS = {
+  // —— Array（非变异）——
+  join: (recv, sep) => Array.isArray(recv) ? recv.join(sep === void 0 ? "," : String(sep)) : void 0,
+  slice: (recv, a, b) => typeof recv === "string" || Array.isArray(recv) ? recv.slice(a, b) : void 0,
+  concat: (recv, ...rest) => Array.isArray(recv) ? recv.concat(...rest) : void 0,
+  indexOf: (recv, x) => typeof recv === "string" || Array.isArray(recv) ? recv.indexOf(x) : void 0,
+  includes: (recv, x) => typeof recv === "string" || Array.isArray(recv) ? recv.includes(x) : void 0,
+  // —— String（非变异）——
+  toUpperCase: (recv) => typeof recv === "string" ? recv.toUpperCase() : void 0,
+  toLowerCase: (recv) => typeof recv === "string" ? recv.toLowerCase() : void 0,
+  trim: (recv) => typeof recv === "string" ? recv.trim() : void 0,
+  trimStart: (recv) => typeof recv === "string" ? recv.trimStart() : void 0,
+  trimEnd: (recv) => typeof recv === "string" ? recv.trimEnd() : void 0,
+  charAt: (recv, i) => typeof recv === "string" ? recv.charAt(i) : void 0,
+  padStart: (recv, n, pad) => typeof recv === "string" ? recv.padStart(n, pad) : void 0,
+  padEnd: (recv, n, pad) => typeof recv === "string" ? recv.padEnd(n, pad) : void 0,
+  repeat: (recv, n) => typeof recv === "string" ? recv.repeat(n) : void 0,
+  substring: (recv, a, b) => typeof recv === "string" ? recv.substring(a, b) : void 0,
+  startsWith: (recv, x) => typeof recv === "string" ? recv.startsWith(x) : void 0,
+  endsWith: (recv, x) => typeof recv === "string" ? recv.endsWith(x) : void 0,
+  // —— Number（非变异）——
+  toFixed: (recv, n) => typeof recv === "number" ? recv.toFixed(n) : void 0,
+  toString: (recv) => recv === void 0 || recv === null ? void 0 : String(recv)
+};
+var GLOBAL_CONST_MEMBERS = {
+  "Math.PI": Math.PI,
+  "Math.E": Math.E,
+  "Math.LN2": Math.LN2,
+  "Math.LN10": Math.LN10,
+  "Math.LOG2E": Math.LOG2E,
+  "Math.LOG10E": Math.LOG10E,
+  "Math.SQRT2": Math.SQRT2,
+  "Math.SQRT1_2": Math.SQRT1_2,
+  "Number.MAX_SAFE_INTEGER": Number.MAX_SAFE_INTEGER,
+  "Number.MIN_SAFE_INTEGER": Number.MIN_SAFE_INTEGER,
+  "Number.EPSILON": Number.EPSILON,
+  "Number.MAX_VALUE": Number.MAX_VALUE,
+  "Number.MIN_VALUE": Number.MIN_VALUE
+};
+function toNum(v) {
+  if (typeof v === "number") return v;
+  if (typeof v === "boolean") return v ? 1 : 0;
+  if (typeof v === "string") return v.trim() === "" ? 0 : Number(v);
+  if (v === null) return 0;
+  if (v === void 0) return NaN;
+  return NaN;
+}
+function evalExpr(p, ctx) {
+  switch (p.k) {
+    case "root":
+      return ctx.read(p.name);
+    case "lit":
+      return p.v;
+    case "undef":
+      return void 0;
+    case "mem": {
+      const o = evalExpr(p.obj, ctx);
+      if (o == null) return void 0;
+      return o[p.key];
+    }
+    case "memdyn": {
+      const o = evalExpr(p.obj, ctx);
+      if (o == null) return void 0;
+      const k = evalExpr(p.key, ctx);
+      return o[String(k)];
+    }
+    case "un": {
+      const v = evalExpr(p.arg, ctx);
+      const uop = p.op;
+      switch (uop) {
+        case "!":
+          return !v;
+        case "-":
+          return -toNum(v);
+        case "+":
+          return +toNum(v);
+        default:
+          throw new Error(`\u672A\u77E5\u4E00\u5143\u8FD0\u7B97\u7B26\uFF1A${String(uop)}`);
+      }
+    }
+    case "bin": {
+      const l = evalExpr(p.l, ctx);
+      const r = evalExpr(p.r, ctx);
+      const bop = p.op;
+      switch (bop) {
+        case "+":
+          if (typeof l === "string" || typeof r === "string") return String(l) + String(r);
+          return toNum(l) + toNum(r);
+        case "-":
+          return toNum(l) - toNum(r);
+        case "*":
+          return toNum(l) * toNum(r);
+        case "/":
+          return toNum(l) / toNum(r);
+        case "%":
+          return toNum(l) % toNum(r);
+        case "===":
+          return l === r;
+        case "!==":
+          return l !== r;
+        case "<":
+          return l < r;
+        case ">":
+          return l > r;
+        case "<=":
+          return l <= r;
+        case ">=":
+          return l >= r;
+        default:
+          throw new Error(`\u672A\u77E5\u4E8C\u5143\u8FD0\u7B97\u7B26\uFF1A${String(bop)}`);
+      }
+    }
+    case "logi": {
+      const l = evalExpr(p.l, ctx);
+      if (p.op === "&&") return l ? evalExpr(p.r, ctx) : l;
+      if (p.op === "||") return l ? l : evalExpr(p.r, ctx);
+      return l === null || l === void 0 ? evalExpr(p.r, ctx) : l;
+    }
+    case "cond":
+      return evalExpr(p.t, ctx) ? evalExpr(p.c, ctx) : evalExpr(p.a, ctx);
+    case "obj": {
+      const o = {};
+      for (const pr of p.props) o[pr.key] = evalExpr(pr.value, ctx);
+      return o;
+    }
+    case "arr":
+      return p.items.map((x) => evalExpr(x, ctx));
+    case "mcall": {
+      const recv = evalExpr(p.recv, ctx);
+      if (recv === void 0 || recv === null) return void 0;
+      const impl = PURE_METHODS[p.method];
+      if (!impl) {
+        throw new Error(`\u8868\u8FBE\u5F0F\u7A0B\u5E8F\u5F15\u7528\u4E86\u975E\u767D\u540D\u5355\u65B9\u6CD5\uFF1A${p.method}\uFF08\u89C1 slot-runtime/expr.ts \u7684 PURE_METHODS\uFF09`);
+      }
+      const args = p.args.map((a) => evalExpr(a, ctx));
+      return impl(recv, ...args);
+    }
+    case "call": {
+      const fn = PURE_CALLS[p.fn];
+      if (typeof fn !== "function") {
+        throw new Error(`\u8868\u8FBE\u5F0F\u7A0B\u5E8F\u5F15\u7528\u4E86\u975E\u767D\u540D\u5355\u51FD\u6570\uFF1A${p.fn}\uFF08\u89C1 slot-runtime/expr.ts \u7684 PURE_CALLS\uFF09`);
+      }
+      const args = p.args.map((a) => evalExpr(a, ctx));
+      return fn(...args);
+    }
+    default: {
+      const never = p;
+      throw new Error(`\u672A\u77E5\u8868\u8FBE\u5F0F\u8282\u70B9\uFF1A${JSON.stringify(never)}`);
+    }
+  }
+}
+
+// ../slot-runtime/src/list-registry.ts
+var ListRegistry = class {
+  constructor() {
+    /** listId → itemKey → (itemSlotId → nodeId) */
+    this.items = /* @__PURE__ */ new Map();
+    /** 统计（诊断：解释"这次 item 更新为什么没走快路径"） */
+    this.hits = 0;
+    this.misses = 0;
+  }
+  /**
+   * 登记一个列表项
+   *
+   * @param listId    编译期分配的列表 id
+   * @param itemKey   该行的稳定 key（**绝不用下标**——下标在 splice 后会命中错项，方案坑位 #5）
+   * @param slotNodes item 内槽位 id → 该槽位对应的**节点 id**
+   */
+  registerItem(listId, itemKey, slotNodes) {
+    let byKey = this.items.get(listId);
+    if (!byKey) {
+      byKey = /* @__PURE__ */ new Map();
+      this.items.set(listId, byKey);
+    }
+    const m = slotNodes instanceof Map ? slotNodes : new Map(Object.entries(slotNodes).map(([k, v]) => [Number(k), v]));
+    byKey.set(itemKey, m);
+  }
+  /** 批量登记（列表首帧渲染后一次性登记全部项——避免逐项调用） */
+  registerItems(listId, entries) {
+    for (const e of entries) this.registerItem(listId, e.itemKey, e.slotNodes);
+  }
+  /** 解析：该列表项内某槽位对应的节点 id（未登记 ⇒ undefined，调用方回退 LIST_UPDATE） */
+  resolveNode(listId, itemKey, slotId) {
+    const hit = this.items.get(listId)?.get(itemKey)?.get(slotId);
+    if (hit === void 0) this.misses++;
+    else this.hits++;
+    return hit;
+  }
+  /** 移除项（splice 删除时调用，防止 key 被复用时命中已删项） */
+  removeItem(listId, itemKey) {
+    return this.items.get(listId)?.delete(itemKey) ?? false;
+  }
+  /** 整体清空某个列表（LIST_SET 整体换数据源时） */
+  clearList(listId) {
+    this.items.delete(listId);
+  }
+  /** 清空全部（卸载页面时） */
+  clear() {
+    this.items.clear();
+  }
+  get size() {
+    let n = 0;
+    for (const byKey of this.items.values()) n += byKey.size;
+    return n;
+  }
+  get stats() {
+    return { hits: this.hits, misses: this.misses, items: this.size };
+  }
+};
+
+// ../slot-runtime/src/runtime.ts
+var VaporRuntime = class {
+  constructor(table, rt, evaluators, registry, onComponentProp, nodeIdOffset = 0, skipNodeIds, onPaintProp) {
+    this.table = table;
+    this.rt = rt;
+    this.evaluators = evaluators;
+    this.registry = registry;
+    this.onComponentProp = onComponentProp;
+    this.nodeIdOffset = nodeIdOffset;
+    this.skipNodeIds = skipNodeIds;
+    this.onPaintProp = onPaintProp;
+    this.slots = /* @__PURE__ */ new Map();
+    this.slotById = /* @__PURE__ */ new Map();
+    this.evalImpls = /* @__PURE__ */ new Map();
+    this.sourcesOfSlot = /* @__PURE__ */ new Map();
+    /**
+     * ★★未能实例化求值器的槽位（**诊断，不许静默**）
+     *
+     * 【为什么必须有（本仓实测）】表达式引用外层别名或含运算时编译器给 `expr` 形态，
+     *   而 `expr` 只支持纯路径 ⇒ `impl` 为 undefined。首版**直接 continue** ⇒
+     *   该槽位永不写、且无任何提示（静默不更新的典型）。
+     */
+    this.uninstantiatedSlots = [];
+    /** ★行内槽位的按键值缓存（`slotId:key` → 上次值）——只发变化行 */
+    /**
+     * ★★行内值缓存（**免字符串拼接**，2026-09-29 优化）
+     *
+     * 【为什么改（本仓实测的瓶颈）】原实现每 (槽位 × 行) 都做一次
+     *   `` `${spec.slotId}:${key}` `` 字符串拼接 + Map 查存；1000 行 × 3 槽位 = 3000 次
+     *   ⇒ 在 `V11` 测得单行更新 **JS 侧 6.76ms**（扫描成本主导，而增量只有 1 条指令）。
+     *   ⇒ 改**嵌套 Map**（listId → slotId → key → value）：键是数字/字符串原值，无拼接、无临时字符串。
+     *   ★正确性不变（同一 (listId, slotId, key) 三元组仍是唯一键）。
+     */
+    this.itemValueCache = /* @__PURE__ */ new Map();
+    this.loaded = false;
+    /* ── ★★P2-5（2026-10-03）：v-once / v-memo 的运行时状态 ── */
+    /**
+     * v-once：已写过的槽位 id（**只写一次**——首次写入后永久冻结）。
+     * ★为什么记在运行时（而不是把槽位从表里删掉）：表是编译产物（只读、可序列化）；
+     *   而"写过没有"是**实例态**（页面重挂载 ⇒ 重新写一次，与官方"重挂载重新渲染"一致）。
+     */
+    this.onceWritten = /* @__PURE__ */ new Set();
+    /** ★批次 30：每节点上次由动态 `:class` 施加的引擎字段（关掉类 ⇒ 需清除这些字段） */
+    this.lastClassFields = /* @__PURE__ */ new Map();
+    /** v-memo：各组的**依赖基线**（上一次比较时的值；缺省 = 还没建过基线 ⇒ 首帧必脏） */
+    this.memoBaseline = /* @__PURE__ */ new Map();
+    /**
+     * v-memo：组在本**帧**已被判定为"依赖变了"的标记（值 = 帧号）。
+     *
+     * 【为什么按帧记（组语义的关键）】一帧里多个源变化可能触到同组多个槽位——
+     *   第一次判定"变了"之后，**同帧其余槽位必须照常写**（组 = 子树整体更新）；
+     *   而"一次判定管一帧"的边界只有 `flush()`（见 `SlotRuntime.frameId`）。
+     */
+    this.memoDirtyFrame = /* @__PURE__ */ new Map();
+    /* ── ★★★P3-3（2026-10-03）：可见性变化日志（`<Transition>` 的**驱动源**）──
+     *
+     * 【为什么运行时记、桥来消费】`v-show` / `v-if` 的切换在运行时表现为 `visible` 槽位写入
+     *   ⇒ 编成 `TOGGLE_VIS` 指令（内核只管**应用**可见性，不知道"要不要过渡"）。
+     *   而"这个节点有没有过渡声明"是**编译产物**（`LayoutNode.transition`）、
+     *   "把动画交给谁播"是**宿主**（`proteusHost.animStart`）——桥正好两头都有。
+     *   ⇒ 运行时只负责**记事实**（谁、变成什么），桥负责**查声明 + 转发**（分层正确、可单测）。
+     *
+     * 【为什么要去重】`relink` 会重写全部槽位（含未变的可见性）⇒ 不去重会把"每次 relink"
+     *   当成一次切换（过渡被反复触发）。⇒ 与上一状态比较，**只在真的翻转时记**。
+     */
+    this.visibilityLog = [];
+    this.lastVisible = /* @__PURE__ */ new Map();
+  }
+  /**
+   * 从订阅表重建求值函数（把**可序列化的声明**变成可执行函数）
+   *
+   * 【为什么单独一步（而不是直接吃函数）】方案 §4.4 要求产物可序列化
+   *   （跨端禁 eval）⇒ 声明与实现分离：声明随产物下发，实现在各端本地重建。
+   *   本方法就是「本地重建」的参考实现：
+   *     · `member` —— 纯路径访问，**免解析**（热路径主力）
+   *     · `const`  —— 常量
+   *     · `expr`   —— 表达式文本（各端按自己的能力求值；本实现给出最简单的成员回退）
+   */
+  static buildEvaluators(specs) {
+    const out = /* @__PURE__ */ new Map();
+    for (const s of specs) {
+      switch (s.form) {
+        case "member": {
+          const segs = (s.path ?? "").split(".").filter(Boolean);
+          const [root, ...rest] = segs;
+          out.set(s.evaluatorId, (ctx) => {
+            let v = ctx.read(root);
+            for (const seg of rest) {
+              if (v == null || typeof v !== "object") return void 0;
+              v = v[seg];
+            }
+            return v;
+          });
+          break;
+        }
+        case "program": {
+          const prog = s.program;
+          if (!prog) break;
+          out.set(s.evaluatorId, (ctx) => evalExpr(prog, ctx));
+          break;
+        }
+        case "const": {
+          const text = (s.expr ?? "").trim();
+          const parsed = /^-?\d+(\.\d+)?$/.test(text) ? Number(text) : text === "true" ? true : text === "false" ? false : text.replace(/^['"]|['"]$/g, "");
+          out.set(s.evaluatorId, () => parsed);
+          break;
+        }
+        case "expr": {
+          const expr = (s.expr ?? "").trim();
+          if (/^[A-Za-z_$][\w$]*(\.[A-Za-z_$][\w$]*)*$/.test(expr)) {
+            const segs = expr.split(".");
+            const [root, ...rest] = segs;
+            out.set(s.evaluatorId, (ctx) => {
+              let v = ctx.read(root);
+              for (const seg of rest) {
+                if (v == null || typeof v !== "object") return void 0;
+                v = v[seg];
+              }
+              return v;
+            });
+          }
+          break;
+        }
+        default:
+          break;
+      }
+    }
+    return out;
+  }
+  /** 注册订阅（方案 §4.3 Step 5：源变化 → 求值 → 直写槽位） */
+  load(ctx, subscribe) {
+    const unknownSources = [];
+    const unsupportedEvaluators = [];
+    let l1Slots = 0;
+    for (const src of this.table.sources) {
+      for (const spec of src.slots) {
+        const impl = this.evaluators.get(spec.evaluatorId);
+        if (!impl) {
+          unsupportedEvaluators.push({ evaluatorId: spec.evaluatorId, reason: "\u6C42\u503C\u51FD\u6570\u672A\u5B9E\u4F8B\u5316\uFF08\u5F62\u6001\u4E0D\u652F\u6301\uFF09" });
+          continue;
+        }
+        let slot = this.slots.get(spec.slotId);
+        if (!slot) {
+          slot = createSlot(
+            {
+              id: spec.slotId,
+              // ★P1-3：子组件的 nodeId 统一加偏移（内核/宿主在**父树空间**里认节点）
+              nodeId: spec.nodeId + this.nodeIdOffset,
+              kind: spec.kind,
+              keyId: this.rt.keys.intern(spec.propKey),
+              listId: spec.listId ?? spec.slotId,
+              listSlotId: spec.itemSlotId ?? spec.slotId,
+              itemKind: spec.itemKind,
+              itemValueField: spec.itemValueField,
+              itemKeyField: spec.itemKeyField,
+              scope: spec.scope
+            },
+            this.rt.keys,
+            this.rt.strings,
+            void 0,
+            this.registry
+            // ★传入注册表（缺省 ⇒ list-item 回退 LIST_UPDATE，保持 V3 行为）
+          );
+          this.slots.set(spec.slotId, slot);
+        }
+        this.slotById.set(spec.slotId, { slot, spec, evalId: spec.evaluatorId });
+        const deps = this.sourcesOfSlot.get(spec.slotId) ?? [];
+        deps.push(src.sourceName);
+        this.sourcesOfSlot.set(spec.slotId, deps);
+        l1Slots++;
+      }
+    }
+    for (const src of this.table.sources) {
+      subscribe(src.sourceName, () => {
+        this.writeSlotsOfSource(src.sourceName, ctx);
+      });
+    }
+    for (const src of this.table.sources) {
+      for (const spec of src.slots) {
+        if (spec.kind !== "list-item") continue;
+        if (!this.evaluators.get(spec.evaluatorId)) {
+          this.uninstantiatedSlots.push({ slotId: spec.slotId, evaluatorId: spec.evaluatorId, propKey: spec.propKey });
+        }
+      }
+    }
+    this.loaded = true;
+    return {
+      l1Slots,
+      l0Slots: this.table.l0Slots.length,
+      unknownSources,
+      unsupportedEvaluators,
+      // ★行内槽位的未实例化清单（与 unsupportedEvaluators 同性质：**上报而非静默**）
+      uninstantiatedSlots: this.uninstantiatedSlots.slice()
+    };
+  }
+  /** 写入某源驱动的全部槽位（源变化时由订阅回调触发） */
+  writeSlotsOfSource(sourceName, ctx) {
+    for (const src of this.table.sources) {
+      if (src.sourceName !== sourceName) continue;
+      this.writeListItems(src, ctx);
+      for (const spec of src.slots) {
+        if (spec.kind === "list-item") continue;
+        if (spec.kind === "list-data") continue;
+        if (spec.once && this.onceWritten.has(spec.slotId)) continue;
+        if (this.skipNodeIds?.has(spec.nodeId + this.nodeIdOffset)) continue;
+        if (spec.propKey === "paint.class" && this.onPaintProp) {
+          const implC = this.evaluators.get(spec.evaluatorId);
+          if (implC) {
+            const cv = implC(ctx);
+            const plan = this.table.classPlans?.[String(spec.nodeId)];
+            let fields;
+            if (plan) {
+              fields = {};
+              applyDynamicClassPlan(cv, plan, fields);
+            } else {
+              fields = resolveDynamicClasses(cv, this.table.classRules ?? []);
+            }
+            const nid = spec.nodeId + this.nodeIdOffset;
+            const nextKeys = new Set(Object.keys(fields));
+            const prev = this.lastClassFields.get(nid);
+            if (prev) {
+              for (const k of prev) if (!nextKeys.has(k)) this.onPaintProp(nid, `paint.${k}`, void 0);
+            }
+            for (const [fk, fv] of Object.entries(fields)) this.onPaintProp(nid, `paint.${fk}`, fv);
+            this.lastClassFields.set(nid, nextKeys);
+            const eC = this.slotById.get(spec.slotId);
+            if (eC) eC.slot.value = cv;
+          }
+          continue;
+        }
+        if (spec.propKey.startsWith("paint.") && this.onPaintProp) {
+          const impl2 = this.evaluators.get(spec.evaluatorId);
+          if (impl2) {
+            const v = impl2(ctx);
+            this.onPaintProp(spec.nodeId + this.nodeIdOffset, spec.propKey, v);
+            const e2 = this.slotById.get(spec.slotId);
+            if (e2) e2.slot.value = v;
+          }
+          continue;
+        }
+        if (spec.memoId !== void 0 && !this.memoGroupDirty(spec.memoId, ctx)) continue;
+        const entry = this.slotById.get(spec.slotId);
+        const impl = this.evaluators.get(spec.evaluatorId);
+        if (!entry || !impl) continue;
+        const value = impl(ctx);
+        if (spec.kind === "component-prop" && this.onComponentProp) {
+          const propName = spec.propKey.startsWith("component.") ? spec.propKey.slice("component.".length) : spec.propKey;
+          this.onComponentProp(spec.nodeId, propName, value);
+          entry.slot.value = value;
+          continue;
+        }
+        this.rt.setSlot(entry.slot, value);
+        if (spec.once) this.onceWritten.add(spec.slotId);
+        if (spec.kind === "visibility") {
+          const now = Boolean(value);
+          const prev = this.lastVisible.get(spec.nodeId);
+          if (prev !== void 0 && prev !== now) {
+            this.visibilityLog.push({ nodeId: spec.nodeId, visible: now });
+          }
+          this.lastVisible.set(spec.nodeId, now);
+        }
+      }
+    }
+  }
+  /**
+   * ★★**v-memo 组脏判定**（P2-5）：依赖逐项比较（`Object.is`），任一变化即"脏"。
+   *
+   * 【语义（对齐 Vue `withMemo`）】依赖未变 ⇒ **跳过**该子树更新；变了 ⇒ 照常更新，
+   *   并把本次依赖值记为基线供下轮比较。
+   * 【诚实边界】组定义缺失（产物异常）⇒ 返回 true（照常更新）——**不静默冻结**：
+   *   "少一层优化"可接受，"该更新的不更新"不可接受。
+   */
+  memoGroupDirty(memoId, ctx) {
+    const fid = this.rt.frameId;
+    if (this.memoDirtyFrame.get(memoId) === fid) return true;
+    const group = this.table.memoGroups?.find((g) => g.memoId === memoId);
+    if (!group) return true;
+    const now = [];
+    for (const prog of group.deps) {
+      try {
+        now.push(evalExpr(prog, ctx));
+      } catch {
+        now.push(void 0);
+      }
+    }
+    const prev = this.memoBaseline.get(memoId);
+    const changed = !prev || now.some((v, i) => !Object.is(v, prev[i]));
+    if (changed) {
+      this.memoBaseline.set(memoId, now);
+      this.memoDirtyFrame.set(memoId, fid);
+    }
+    return changed;
+  }
+  /**
+   * ★列表行内槽位通道：按行求值 → 与上一轮**按 key 缓存**的值 diff → 只发变化行
+   *
+   * 【关键：行作用域求值】`item.w` 的求值需要**当前行**绑定到 v-for 作用域。
+   *   故每行构造一个 `rowCtx`：`read(scope)` 返回该行，其余名透传原 ctx。
+   *   （编译器在槽位上给了 `scope` 才能这么做——见 SlotSubscription.scope）
+   */
+  writeListItems(src, ctx) {
+    const itemSlots = src.slots.filter((x) => x.kind === "list-item");
+    if (itemSlots.length === 0) return;
+    const rowsCache = /* @__PURE__ */ new Map();
+    const rowsOfList2 = (listId, spec) => {
+      const cached = rowsCache.get(listId);
+      if (cached) return cached;
+      const out = [];
+      const keyOf2 = (r, i) => spec.itemKeyField && r && r[spec.itemKeyField] !== void 0 ? String(r[spec.itemKeyField]) : String(i);
+      const segs = (spec.sourceExpr ?? "").split(".").filter(Boolean);
+      const topRows = ctx.read(src.sourceName);
+      if (!Array.isArray(topRows)) return out;
+      const walkSegs = segs[0] === src.sourceName ? segs.slice(1) : segs;
+      let current = topRows.map((row) => ({ row, ancestors: [] }));
+      for (let seg = 0; seg < walkSegs.length; seg++) {
+        const field = walkSegs[seg];
+        const next = [];
+        for (const c of current) {
+          const arr = c.row?.[field];
+          if (!Array.isArray(arr)) continue;
+          for (const x of arr) {
+            next.push({ row: x, ancestors: [...c.ancestors, c.row] });
+          }
+        }
+        current = next;
+      }
+      for (let i = 0; i < current.length; i++) {
+        out.push({ key: keyOf2(current[i].row, i), row: current[i].row, ancestors: current[i].ancestors });
+      }
+      rowsCache.set(listId, out);
+      return out;
+    };
+    const rowCtxCache = /* @__PURE__ */ new Map();
+    for (const spec of itemSlots) {
+      const impl = this.evaluators.get(spec.evaluatorId);
+      if (!impl) {
+        this.uninstantiatedSlots.push({ slotId: spec.slotId, evaluatorId: spec.evaluatorId, propKey: spec.propKey });
+        continue;
+      }
+      const scope = spec.scope ?? "";
+      const rows = rowsOfList2(spec.listId ?? -1, spec);
+      for (const rowRef of rows) {
+        const key = rowRef.key;
+        const row = rowRef.row;
+        const ancestors = rowRef.ancestors;
+        const cached = rowCtxCache.get(rowRef);
+        const rowCtx = cached && cached.scope === scope ? cached.ctx : this.makeRowCtx(scope, row, ancestors, ctx);
+        if (!(cached && cached.scope === scope)) rowCtxCache.set(rowRef, { scope, ctx: rowCtx });
+        const value = impl(rowCtx);
+        this.diffAndEmit(spec, key, value);
+      }
+    }
+  }
+  /**
+   * ★★行级失效：**只重算指定行**的 list-item 槽位（2026-09-29 新增）
+   *
+   * 【为什么需要（本仓真机实测的瓶颈）】粗粒度触发（`triggers.get('list')` ⇒ `relink`）只知道
+   *   "源变了"、不知道"哪一行变了" ⇒ 只能**全表重扫**：1000 行 × 3 槽位 = 3000 次求值 + diff。
+   *   真机 `V11` 实测该段 **7.03ms**（列表更新总 11ms）——而 Vapor 的设计本意是
+   *   **O(1) 槽位直写**（改哪行算哪行）。本方法就是那个 O(1) 入口。
+   *
+   * 【调用方责任】提供**变更行的身份**（`key` + 行对象 + 祖先链）——它天然知道（编译器产出的
+   *   行作用域效应 / 应用层的不可变更新都携带这些）。**不知道时不要调用**，走 `relink` 全扫（正确但慢）。
+   *
+   * 【正确性】与全扫路径**共用** `makeRowCtx` / `diffAndEmit` / `itemValueCache`（唯一实现
+   *   ⇒ 两条路径不会漂移）；缓存是实例级的 ⇒ 全扫与行级失效交替调用也保持一致。
+   *
+   * @param listId 目标列表 id（订阅表里的 `listId`）
+   * @param key    行标识（= `itemKeyField` 对应的值，与 `emitListItem` 的键一致）
+   * @param row    该行的**数据对象**
+   * @param ancestors 该行的祖先行链（顶层列表传空数组；嵌套列表按「自外向内」）
+   */
+  relinkRow(listId, key, row, ancestors = [], ctx) {
+    const evalCtx = ctx ?? this.lastCtx ?? { read: () => void 0 };
+    for (const spec of this.listSpecsOf(listId)) {
+      const impl = this.evaluators.get(spec.evaluatorId);
+      if (!impl) continue;
+      const rowCtx = this.makeRowCtx(spec.scope ?? "", row, ancestors, evalCtx);
+      this.diffAndEmit(spec, key, impl(rowCtx));
+    }
+  }
+  /** scope（v-for 别名）→ listId 反查（`relinkRow` 用；作用域由订阅表声明，不猜） */
+  listIdOfScope(scope) {
+    for (const src of this.table.sources) {
+      for (const sl of src.slots) if (sl.kind === "list-item" && (sl.scope ?? "") === scope) return sl.listId ?? -1;
+    }
+    return void 0;
+  }
+  /** 该列表的全部 list-item 槽位（`relinkRow` 用；与 `writeListItems` 同一数据源） */
+  listSpecsOf(listId) {
+    const out = [];
+    for (const src of this.table.sources) {
+      for (const sl of src.slots) if (sl.kind === "list-item" && (sl.listId ?? -1) === listId) out.push(sl);
+    }
+    return out;
+  }
+  /** ★行作用域上下文（**唯一实现**）：当前行别名 + 各层祖先别名 —— `writeListItems` 与 `relinkRow` 共用 */
+  makeRowCtx(scope, row, ancestors, ctx) {
+    if (!scope) return ctx;
+    const lid = this.listIdOfScope(scope);
+    const ancestorScopes = lid === void 0 ? [] : this.ancestorScopesOf(lid);
+    return makeScopedRead(scope, row, ancestors, ancestorScopes, ctx);
+  }
+  /** ★值 diff + 发射（**唯一实现**）：嵌套 Map 免拼接：listId/slotId 均为数字键 */
+  diffAndEmit(spec, key, value) {
+    const listId = spec.listId ?? -1;
+    let bySlot = this.itemValueCache.get(listId);
+    if (!bySlot) {
+      bySlot = /* @__PURE__ */ new Map();
+      this.itemValueCache.set(listId, bySlot);
+    }
+    let byKey = bySlot.get(spec.slotId);
+    if (!byKey) {
+      byKey = /* @__PURE__ */ new Map();
+      bySlot.set(spec.slotId, byKey);
+    }
+    if (byKey.get(key) === value) return;
+    byKey.set(key, value);
+    this.emitListItem(spec, key, value);
+  }
+  /** 发一条行内更新指令：解析得到 nodeId 就发普通指令，否则回退 LIST_UPDATE */
+  emitListItem(spec, key, value) {
+    const nodeId = this.registry?.resolveNode(spec.listId ?? -1, key, spec.itemSlotId ?? -1);
+    if (nodeId !== void 0 && this.skipNodeIds?.has(nodeId)) return;
+    if (nodeId !== void 0) {
+      if ((spec.itemKind ?? "style") === "text") {
+        this.rt.buffer.push({ op: 3 /* SET_TEXT */, nodeId, textRef: this.rt.strings.intern(String(value)) });
+      } else {
+        this.rt.buffer.push({
+          op: 2 /* SET_STYLE */,
+          nodeId,
+          keyId: this.rt.keys.intern(spec.propKey),
+          value: typeof value === "number" ? value : Number(value) || 0
+        });
+      }
+    } else {
+      this.rt.buffer.push({
+        op: 34 /* LIST_UPDATE */,
+        listId: spec.listId ?? -1,
+        itemKeyRef: this.rt.strings.intern(key),
+        slotId: spec.itemSlotId ?? -1,
+        value: typeof value === "number" ? value : Number(value) || 0
+      });
+    }
+  }
+  /** ★首帧同步：把所有 L1 槽位按当前源值写一遍（否则首屏不会出现这些值） */
+  relink(ctx) {
+    this.lastCtx = ctx;
+    for (const src of this.table.sources) {
+      this.writeSlotsOfSource(src.sourceName, ctx);
+    }
+  }
+  /**
+   * 某列表的**别名链**（自外向内；末位是它自身的 scope）
+   *
+   * 【为什么需要】`rowCtx` 要按位置把「祖先行」绑给对应的外层别名——
+   *   而位置对应关系依赖"自外向内"的稳定顺序（由 `parentListId` 逐级上溯构造）。
+   */
+  ancestorScopesOf(listId) {
+    const chain = [];
+    let cur = listId;
+    const allSlots = this.table.sources.flatMap((x) => x.slots);
+    let guard = 0;
+    while (cur !== void 0 && guard < 32) {
+      const spec = allSlots.find((x) => x.kind === "list-item" && x.listId === cur);
+      if (!spec) break;
+      chain.unshift(spec.scope ?? "");
+      cur = spec.parentListId;
+      guard++;
+    }
+    return chain;
+  }
+  /** 取某源的行数组（列表源 ⇒ 数组；非数组返回空）——仅供「无 :key 时用下标兜底」 */
+  rowsOfSource(sourceName, ctx) {
+    const v = ctx.read(sourceName);
+    return Array.isArray(v) ? v : [];
+  }
+  /**
+   * ★★★**取走可见性变化**（P3-3；取走即复位——与 `takePatches` 同款"自上次取走以来"语义）。
+   *
+   * 桥侧用法：`relink`/手势回调后 drain ⇒ 对每个变化查模板的 `transition` 声明 ⇒
+   * 有声明则调 `proteusHost.animStart(...)`（宿主把动画交给内核）。
+   */
+  takeVisibilityChanges() {
+    if (this.visibilityLog.length === 0) return [];
+    const out = this.visibilityLog.slice();
+    this.visibilityLog.length = 0;
+    return out;
+  }
+  /** 某槽位是否已建立订阅（诊断：确认"这个槽位真的被接管了"） */
+  hasSlot(slotId) {
+    return this.slots.has(slotId);
+  }
+  get loaded_() {
+    return this.loaded;
+  }
+  /** 该槽位由哪些源驱动（诊断 / explain） */
+  depsOf(slotId) {
+    return this.sourcesOfSlot.get(slotId) ?? [];
+  }
+  /** L1 槽位表（供宿主对账：哪些槽位由 L1 接管） */
+  slotIds() {
+    return [...this.slots.keys()].sort((a, b) => a - b);
+  }
+};
+function makeScopedRead(scope, row, ancestors, ancestorScopes, ctx) {
+  if (!scope) return ctx;
+  return {
+    read: (n) => {
+      if (n === scope) return row;
+      const idx = ancestorScopes.indexOf(n);
+      if (idx >= 0 && idx < ancestors.length) return ancestors[idx];
+      return ctx.read(n);
+    }
+  };
+}
+
+// ../slot-runtime/src/instantiate.ts
+function applyStyleField(target, propKey, key, v, classRules, classPlan) {
+  if (propKey === "paint.class") {
+    let fields;
+    if (classPlan) {
+      fields = {};
+      applyDynamicClassPlan(v, classPlan, fields);
+    } else {
+      fields = resolveDynamicClasses(v, classRules ?? []);
+    }
+    for (const [k, val] of Object.entries(fields)) target[k] = val;
+    return;
+  }
+  ;
+  target[key] = v;
+}
+function setNormText(obj, value) {
+  const t = value === void 0 || value === null ? "" : String(value);
+  obj["text"] = normalizeWhiteSpace(t, obj["whiteSpace"]);
+}
+function normalizeWhiteSpace(text, ws) {
+  switch (ws) {
+    case "pre":
+    case "pre-wrap":
+      return text;
+    // 原样保留
+    case "pre-line":
+      return text.replace(/[ \t\r\f\v]+/g, " ").split("\n").map((l) => l.trim()).join("\n");
+    default:
+      return text.replace(/\s+/g, " ").trim();
+  }
+}
+function engineFieldOf(propKey) {
+  if (propKey === "text.content") return { kind: "text" };
+  const m = propKey.match(/^(?:layout|paint|text)\.(.+)$/);
+  if (!m) return null;
+  return { kind: "style", key: m[1] };
+}
+function evalTextSegments(segs, read) {
+  let out = "";
+  for (const s of segs) {
+    if ("text" in s) {
+      out += s.text;
+      continue;
+    }
+    try {
+      const v = evalExpr(s.expr, { read });
+      out += v === void 0 || v === null ? "" : String(v);
+    } catch {
+    }
+  }
+  return out;
+}
+function rowsOfList(listId, meta, table, read) {
+  if (!table) return [];
+  const allSlots = table.sources.flatMap((s) => s.slots);
+  const itemSlots = allSlots.filter((x) => x.kind === "list-item" && x.listId === listId);
+  const spec = itemSlots[0] ?? allSlots.find((x) => x.kind === "list-data" && x.listId === listId);
+  if (!spec) return [];
+  const srcName = table.sources.find((s) => s.slots.some((x) => x.listId === listId))?.sourceName ?? "";
+  const segs = (meta?.sourceField || spec.sourceExpr || "").split(".").filter(Boolean);
+  const topRows = read(srcName);
+  if (!Array.isArray(topRows)) return [];
+  const walkSegs = segs[0] === srcName ? segs.slice(1) : segs;
+  let cur = topRows;
+  for (const field of walkSegs) {
+    const next = [];
+    for (const r of cur) {
+      const arr = r?.[field];
+      if (!Array.isArray(arr)) continue;
+      for (const x of arr) next.push(x);
+    }
+    cur = next;
+  }
+  return cur;
+}
+function instantiateTemplate(tpl, opts) {
+  const nodes = [];
+  const idOffset = opts.idOffset ?? 0;
+  const instNotes = [];
+  const maxTemplateId = tpl.nodes.reduce((m, n) => Math.max(m, n.id), 0);
+  let nextId = opts.firstRowInstanceId ?? maxTemplateId + 1;
+  let allocated = 0;
+  let reused = 0;
+  const rowLists = new Map(tpl.lists.map((l) => [l.listId, l]));
+  const byId = /* @__PURE__ */ new Map();
+  let valuesFilled = 0;
+  const evaluators = opts.table ? VaporRuntime.buildEvaluators(opts.table.evaluators) : /* @__PURE__ */ new Map();
+  const ancestorScopesOf = (listId) => {
+    const chain = [];
+    let cur = listId;
+    let guard = 0;
+    while (cur !== void 0 && guard < 32) {
+      const meta = rowLists.get(cur);
+      if (!meta) break;
+      chain.unshift(meta.scope ?? "");
+      cur = meta.parentListId;
+      guard++;
+    }
+    return chain;
+  };
+  const evalInitial = (evaluatorId, ctx) => {
+    const impl = evaluators.get(evaluatorId);
+    if (!impl) return { ok: false };
+    try {
+      return { ok: true, value: impl(ctx) };
+    } catch {
+      return { ok: false };
+    }
+  };
+  const virtualRows = [];
+  const emit = (n, id, parentId, ctx = { read: opts.read }) => {
+    const out = { id, parentId };
+    if (n.style) for (const [k, v] of Object.entries(n.style)) {
+      ;
+      out[k] = v;
+    }
+    if (n.text !== void 0) setNormText(out, n.text);
+    if (n.textSegments && n.textSegments.length > 0) {
+      setNormText(out, evalTextSegments(n.textSegments, ctx.read));
+    }
+    if (n.tag) out.tag = n.tag;
+    if (n.component) out.component = n.component;
+    if (n.slotOutlet) out.slotOutlet = n.slotOutlet;
+    if (n.slotFor) out.slotFor = n.slotFor;
+    out.id = id + idOffset;
+    out.parentId = parentId === null ? null : parentId + idOffset;
+    nodes.push(out);
+    byId.set(id, out);
+  };
+  const cloneRow = (listId, row, itemKey, first, rowIndex, parentOverrideId, collect, ancestors = []) => {
+    const meta = rowLists.get(listId);
+    const idMap = /* @__PURE__ */ new Map();
+    let rowRootId = 0;
+    const myIds = [];
+    for (const tplId of meta.subtreeIds) {
+      const engineId = first ? tplId : nextId++;
+      if (!first) allocated++;
+      else reused++;
+      idMap.set(tplId, engineId);
+      if (tplId === meta.rowRootId) rowRootId = engineId;
+    }
+    const rowRead = makeScopedRead(meta.scope ?? "", row, ancestors, ancestorScopesOf(listId), { read: opts.read });
+    for (const tplId of meta.subtreeIds) {
+      const tn = tpl.nodes.find((x) => x.id === tplId);
+      const engineId = idMap.get(tplId);
+      const tplParent = tn.parentId;
+      let parentId = tplParent === null ? null : idMap.get(tplParent) ?? tplParent;
+      if (parentOverrideId !== void 0 && tplId === meta.rowRootId) parentId = parentOverrideId;
+      emit(tn, engineId, parentId, rowRead);
+      myIds.push(engineId);
+    }
+    for (const inner of tpl.lists) {
+      if (inner.parentListId !== listId) continue;
+      let arr = row;
+      for (const seg of (inner.sourceField ?? "").split(".").filter(Boolean)) {
+        arr = arr?.[seg];
+      }
+      if (!Array.isArray(arr)) continue;
+      const innerKeyField = opts.table?.sources.flatMap((s) => s.slots).find((x) => x.kind === "list-item" && x.listId === inner.listId)?.itemKeyField;
+      for (let j = 0; j < arr.length; j++) {
+        const innerRow = arr[j];
+        const innerKey = innerKeyField && innerRow?.[innerKeyField] !== void 0 ? String(innerRow[innerKeyField]) : String(j);
+        cloneRow(inner.listId, innerRow, innerKey, first && j === 0, j, rowRootId, myIds, [...ancestors, row]);
+      }
+    }
+    virtualRows.push({
+      index: rowIndex,
+      key: itemKey,
+      root: rowRootId + idOffset,
+      ids: myIds.map((x) => x + idOffset)
+    });
+    if (collect) collect.push(...myIds);
+    if (opts.table) {
+      const itemSlots = opts.table.sources.flatMap((s) => s.slots).filter((x) => x.kind === "list-item" && x.listId === listId);
+      if (itemSlots.length > 0) {
+        const slotNodes = {};
+        const rowCtx = makeScopedRead(meta.scope ?? "", row, ancestors, ancestorScopesOf(listId), {
+          read: opts.read
+        });
+        for (const sl of itemSlots) {
+          const mapped = idMap.get(sl.nodeId);
+          if (mapped !== void 0) slotNodes[sl.itemSlotId] = mapped;
+          if (mapped === void 0) continue;
+          const target = byId.get(mapped);
+          if (!target) continue;
+          const f = engineFieldOf(sl.propKey);
+          if (!f) continue;
+          const ev0 = evalInitial(sl.evaluatorId, rowCtx);
+          let v;
+          if (ev0.ok) {
+            v = ev0.value;
+          } else {
+            const field = sl.itemValueField;
+            if (!field) continue;
+            v = row[field];
+            if (v === void 0) continue;
+          }
+          if (f.kind === "text") {
+            setNormText(target, v);
+          } else {
+            applyStyleField(target, sl.propKey, f.key, v, opts.table?.classRules, opts.table?.classPlans?.[String(sl.nodeId)]);
+          }
+          valuesFilled++;
+        }
+        if (opts.registry && Object.keys(slotNodes).length > 0) {
+          const shifted = {};
+          for (const [k, v] of Object.entries(slotNodes)) shifted[Number(k)] = v + idOffset;
+          opts.registry.registerItem(listId, itemKey, shifted);
+        }
+      }
+    }
+    return rowRootId;
+  };
+  const rowMemberIds = /* @__PURE__ */ new Set();
+  for (const l of tpl.lists) for (const id of l.subtreeIds) rowMemberIds.add(id);
+  for (const n of tpl.nodes) {
+    if (rowMemberIds.has(n.id)) {
+      const meta = tpl.lists.find((l) => l.rowRootId === n.id);
+      if (!meta) continue;
+      if (meta.parentListId !== void 0) continue;
+      const rows = rowsOfList(meta.listId, meta, opts.table, opts.read);
+      for (let i = 0; i < rows.length; i++) {
+        const row = rows[i];
+        const keyOf2 = () => {
+          const keyField = opts.table?.sources.flatMap((s) => s.slots).find((x) => x.kind === "list-item" && x.listId === meta.listId)?.itemKeyField;
+          return keyField && row[keyField] !== void 0 ? String(row[keyField]) : String(i);
+        };
+        cloneRow(meta.listId, row, keyOf2(), i === 0, i);
+      }
+      continue;
+    }
+    emit(n, n.id, n.parentId);
+  }
+  if (opts.table) {
+    for (const sl of opts.table.constantSlots ?? []) {
+      const target = byId.get(sl.nodeId);
+      if (!target) continue;
+      const f = engineFieldOf(sl.propKey);
+      if (!f) continue;
+      const evS = evalInitial(sl.evaluatorId, { read: opts.read });
+      if (!evS.ok) continue;
+      const v = evS.value;
+      if (f.kind === "text") {
+        setNormText(target, v);
+      } else {
+        applyStyleField(target, sl.propKey, f.key, v, opts.table?.classRules, opts.table?.classPlans?.[String(sl.nodeId)]);
+      }
+      valuesFilled++;
+    }
+    for (const src of opts.table.sources) {
+      for (const sl of src.slots) {
+        if (sl.kind === "list-item" || sl.kind === "list-data" || sl.kind === "component-prop") continue;
+        const target = byId.get(sl.nodeId);
+        if (!target) continue;
+        const f = engineFieldOf(sl.propKey);
+        if (!f) continue;
+        const evS = evalInitial(sl.evaluatorId, { read: opts.read });
+        let v;
+        if (evS.ok) {
+          v = evS.value;
+        } else {
+          v = opts.read(src.sourceName);
+          if (v === void 0) continue;
+        }
+        if (f.kind === "text") {
+          setNormText(target, v);
+        } else {
+          applyStyleField(target, sl.propKey, f.key, v, opts.table?.classRules, opts.table?.classPlans?.[String(sl.nodeId)]);
+        }
+        valuesFilled++;
+      }
+    }
+  }
+  const componentMounts = [];
+  const slotMounts = [];
+  const droppedNodeIds = /* @__PURE__ */ new Set();
+  let componentNodes = 0;
+  const subtreeOf = (list, rootId) => {
+    const doomed = /* @__PURE__ */ new Set([rootId]);
+    let grew = true;
+    while (grew) {
+      grew = false;
+      for (const x of list) {
+        if (x.parentId !== null && !doomed.has(x.id) && doomed.has(x.parentId)) {
+          doomed.add(x.id);
+          grew = true;
+        }
+      }
+    }
+    return doomed;
+  };
+  const dissolveOutlets = (list, fills, evalProps) => {
+    const consumed = /* @__PURE__ */ new Set();
+    const placed = [];
+    for (const outlet of list.filter((x) => x.slotOutlet)) {
+      if (list.indexOf(outlet) < 0) continue;
+      const name = outlet.slotOutlet.name;
+      const fill = fills.get(name);
+      const useFill = fill !== void 0 && fill.length > 0 && !consumed.has(name);
+      if (useFill) {
+        consumed.add(name);
+        const outletProps = evalProps ? evalProps(outlet) : {};
+        const doomed = subtreeOf(list, outlet.id);
+        for (const id of doomed) droppedNodeIds.add(id);
+        const idx = list.findIndex((x) => x.id === outlet.id);
+        const kept = list.filter((x) => !doomed.has(x.id));
+        kept.splice(Math.min(idx, kept.length), 0, ...fill);
+        list.length = 0;
+        list.push(...kept);
+        for (const r of fill) {
+          r.parentId = outlet.parentId;
+          delete r.slotFor;
+        }
+        slotMounts.push({ outletNodeId: outlet.id, name, filled: true, contentIds: fill.map((x) => x.id), fallbackIds: [] });
+        placed.push({ name, fill, outlet, props: outletProps });
+      } else {
+        const kids = list.filter((x) => x.parentId === outlet.id);
+        const fallbackIds = [];
+        if (kids.length > 0) {
+          for (const k of kids) k.parentId = outlet.parentId;
+          fallbackIds.push(...kids.map((x) => x.id));
+          list.splice(list.indexOf(outlet), 1);
+          droppedNodeIds.add(outlet.id);
+        } else if (typeof outlet.text === "string" && outlet.text !== "") {
+          delete outlet.slotOutlet;
+          outlet.tag = "p-text";
+        } else {
+          list.splice(list.indexOf(outlet), 1);
+          droppedNodeIds.add(outlet.id);
+        }
+        slotMounts.push({ outletNodeId: outlet.id, name, filled: false, contentIds: [], fallbackIds });
+      }
+    }
+    return { consumed, placed };
+  };
+  if (opts.table?.componentIs && opts.table.componentIs.length > 0) {
+    for (const ci of opts.table.componentIs) {
+      const target = byId.get(ci.nodeId);
+      if (!target) continue;
+      const impl = evaluators.get(ci.evaluatorId);
+      if (!impl) {
+        instNotes.push(`\u52A8\u6001\u7EC4\u4EF6 \`:is="${ci.expr}"\`\uFF08\u8282\u70B9 ${ci.nodeId}\uFF09\u6C42\u503C\u5668\u672A\u5B9E\u4F8B\u5316 \u21D2 \u672A\u89E3\u6790`);
+        continue;
+      }
+      let name;
+      try {
+        name = impl({ read: opts.read });
+      } catch (e) {
+        instNotes.push(`\u52A8\u6001\u7EC4\u4EF6 \`:is="${ci.expr}"\` \u6C42\u503C\u629B\u9519\uFF08${String(e?.message ?? e)}\uFF09\u21D2 \u672A\u89E3\u6790`);
+        continue;
+      }
+      if (name === void 0 || name === null || name === "") {
+        const doomed = subtreeOf(nodes, ci.nodeId);
+        for (const id of doomed) droppedNodeIds.add(id);
+        for (let i = nodes.length - 1; i >= 0; i--) if (doomed.has(nodes[i].id)) nodes.splice(i, 1);
+        instNotes.push(`\u52A8\u6001\u7EC4\u4EF6 \`:is="${ci.expr}"\` \u6C42\u503C\u4E3A\u5047\uFF08${String(name)}\uFF09\u21D2 \u8282\u70B9\u5DF2\u6458\u9664\uFF08Vue \u540C\uFF09`);
+        continue;
+      }
+      if (typeof name !== "string") {
+        instNotes.push(
+          `\u52A8\u6001\u7EC4\u4EF6 \`:is="${ci.expr}"\` \u6C42\u503C\u4E0D\u662F\u5B57\u7B26\u4E32\uFF08${typeof name}\uFF09\u21D2 \u672A\u89E3\u6790\uFF08\u672C\u5B9E\u73B0\u6309**\u7EC4\u4EF6\u540D**\u67E5\u6CE8\u518C\u8868\uFF1B\u7EC4\u4EF6\u5BF9\u8C61\u5F62\u6001\u4E3A\u540E\u7EED\u6279\u6B21\uFF09`
+        );
+        continue;
+      }
+      target.component = name;
+      delete target.componentIs;
+      instNotes.push(`\u52A8\u6001\u7EC4\u4EF6 \`:is="${ci.expr}"\` \u21D2 \u89E3\u6790\u4E3A ${name}\uFF08\u5B9E\u4F8B\u5316\u671F\u4E00\u6B21\u6027\u89E3\u6790\uFF09`);
+    }
+  }
+  if (opts.components) {
+    const depth = opts.componentDepth ?? 0;
+    const boundaries = nodes.filter((n) => n.component);
+    for (const boundary of boundaries) {
+      if (droppedNodeIds.has(boundary.id)) continue;
+      const name = boundary.component;
+      const def = opts.components[name];
+      if (!def) {
+        instNotes.push(`\u7EC4\u4EF6 ${name}\uFF08\u8FB9\u754C\u8282\u70B9 ${boundary.id}\uFF09\u672A\u5728\u6CE8\u518C\u8868\u91CC \u21D2 \u5185\u90E8\u7559\u7A7A\uFF08\u5360\u4F4D\uFF09`);
+        continue;
+      }
+      if (depth >= 8) {
+        instNotes.push(`\u7EC4\u4EF6 ${name} \u5C55\u5F00\u6DF1\u5EA6\u8D85\u4E0A\u9650\uFF088\uFF09\u21D2 \u505C\u6B62\u9012\u5F52\uFF08\u9632\u81EA\u5F15\u7528\uFF09`);
+        continue;
+      }
+      const boundaryLocalId = boundary.id - idOffset;
+      const props = {};
+      if (opts.table) {
+        const allSlots = [
+          ...opts.table.sources.flatMap((src) => src.slots.map((sl) => ({ sl, srcName: src.sourceName }))),
+          ...(opts.table.constantSlots ?? []).map((sl) => ({ sl, srcName: void 0 }))
+        ];
+        for (const { sl, srcName } of allSlots) {
+          if (sl.kind !== "component-prop" || sl.nodeId !== boundaryLocalId) continue;
+          const propName = sl.propKey.startsWith("component.") ? sl.propKey.slice("component.".length) : sl.propKey;
+          if (srcName !== void 0) {
+            props[propName] = opts.read(srcName);
+          } else {
+            const impl = evaluators.get(sl.evaluatorId);
+            if (impl) {
+              try {
+                props[propName] = impl({ read: opts.read });
+              } catch {
+                props[propName] = void 0;
+              }
+            }
+          }
+        }
+      }
+      const childRead = (n) => {
+        if (Object.prototype.hasOwnProperty.call(props, n)) return props[n];
+        const d = def.data;
+        if (d && Object.prototype.hasOwnProperty.call(d, n)) return d[n];
+        return opts.read(n);
+      };
+      const ctx = { read: childRead };
+      const childRegistry = opts.registry ? new ListRegistry() : void 0;
+      const childOffset = nextId;
+      const childInst = instantiateTemplate(def.template, {
+        viewport: opts.viewport,
+        read: childRead,
+        table: def.table,
+        registry: childRegistry,
+        idOffset: idOffset + childOffset,
+        components: opts.components,
+        componentDepth: depth + 1
+      });
+      const contentRoots = nodes.filter((x) => x.parentId === boundary.id && x.slotFor);
+      if (contentRoots.length > 0 || childInst.slotMounts?.length) {
+        const fills = /* @__PURE__ */ new Map();
+        const scopeOf = /* @__PURE__ */ new Map();
+        const bindingsOf = /* @__PURE__ */ new Map();
+        for (const r of contentRoots) {
+          const sf = r.slotFor;
+          const arr = fills.get(sf.name) ?? [];
+          arr.push(r);
+          fills.set(sf.name, arr);
+          if (!scopeOf.has(sf.name)) scopeOf.set(sf.name, sf.scope);
+          if (!bindingsOf.has(sf.name)) bindingsOf.set(sf.name, sf.scopeBindings);
+        }
+        const childEvaluators = def.table ? VaporRuntime.buildEvaluators(def.table.evaluators) : /* @__PURE__ */ new Map();
+        const evalOutletProps = (outlet) => {
+          const out = {};
+          const names = outlet.slotOutlet.props ?? [];
+          const outletLocal = outlet.id - (idOffset + childOffset);
+          const allSlots = def.table ? [...def.table.sources.flatMap((s) => s.slots), ...def.table.constantSlots ?? []] : [];
+          for (const propName of names) {
+            const sl = allSlots.find((s) => s.nodeId === outletLocal && s.propKey === `attr.${propName}`);
+            if (!sl) continue;
+            const impl = childEvaluators.get(sl.evaluatorId);
+            if (!impl) continue;
+            try {
+              out[propName] = impl({ read: childRead });
+            } catch {
+              out[propName] = void 0;
+            }
+          }
+          return out;
+        };
+        const { consumed, placed } = dissolveOutlets(childInst.nodes, fills, evalOutletProps);
+        for (const p of placed) {
+          const scopeVar = scopeOf.get(p.name);
+          const scopeBindings = bindingsOf.get(p.name);
+          if (!scopeVar && !scopeBindings) continue;
+          const rootIds = new Set(p.fill.map((x) => x.id));
+          const byIdOfChild = new Map(childInst.nodes.map((x) => [x.id, x]));
+          const subtree = [];
+          for (const x of childInst.nodes) {
+            let cur = x;
+            let guard = 0;
+            while (cur !== void 0 && guard++ < 64) {
+              if (rootIds.has(cur.id)) {
+                subtree.push(x);
+                break;
+              }
+              cur = cur.parentId === null ? void 0 : byIdOfChild.get(cur.parentId);
+            }
+          }
+          const scopedRead = (n2) => {
+            if (scopeVar && n2 === scopeVar) return p.props;
+            if (scopeBindings) {
+              const hit = scopeBindings.find((b) => b.local === n2);
+              if (hit) return p.props[hit.key];
+            }
+            return opts.read(n2);
+          };
+          const scopeTag = scopeVar ?? scopeBindings.map((b) => b.local).join(",");
+          for (const node of subtree) {
+            const tn = tpl.nodes.find((x) => x.id === node.id - idOffset);
+            if (tn?.textSegments && tn.textSegments.length > 0) {
+              setNormText(node, evalTextSegments(tn.textSegments, scopedRead));
+            }
+          }
+          let appliedScoped = 0;
+          for (const sc of opts.table?.slotScopedSlots ?? []) {
+            if (scopeVar !== void 0 ? sc.scope !== scopeVar : !scopeBindings.some((b) => b.local === sc.scope)) continue;
+            const target = subtree.find((x) => x.id === sc.nodeId + idOffset);
+            if (!target) continue;
+            const impl = evaluators.get(sc.evaluatorId);
+            if (!impl) continue;
+            const f = engineFieldOf(sc.propKey);
+            if (!f) continue;
+            let v;
+            try {
+              v = impl({ read: scopedRead });
+            } catch {
+              continue;
+            }
+            if (f.kind === "text") {
+              setNormText(target, v);
+            } else {
+              applyStyleField(target, sc.propKey, f.key, v, opts.table?.classRules, opts.table?.classPlans?.[String(sc.nodeId)]);
+            }
+            appliedScoped++;
+            valuesFilled++;
+          }
+          instNotes.push(
+            `\u63D2\u69FD ${name}#${p.name}\uFF1A\u4F5C\u7528\u57DF ${scopeVar ? `\`${scopeVar}\`` : `\u89E3\u6784 \`{ ${scopeBindings.map((b) => b.local).join(", ")} }\``} \u7ED1\u5B9A\u51FA\u53E3 props ${JSON.stringify(p.props)}\uFF08\u6587\u672C\u6BB5\u91CD\u6C42\u503C ${subtree.filter((x) => tpl.nodes.find((t) => t.id === x.id - idOffset)?.textSegments?.length).length} \u8282\u70B9 \xB7 \u4F5C\u7528\u57DF\u6837\u5F0F ${appliedScoped} \u5904\uFF09`
+          );
+        }
+        for (const [nm, roots] of fills) {
+          if (consumed.has(nm)) {
+            for (const r of roots) {
+              const i = nodes.indexOf(r);
+              if (i >= 0) nodes.splice(i, 1);
+            }
+            continue;
+          }
+          for (const r of roots) {
+            const doomed = subtreeOf(nodes, r.id);
+            for (const id of doomed) droppedNodeIds.add(id);
+            for (let i = nodes.length - 1; i >= 0; i--) if (doomed.has(nodes[i].id)) nodes.splice(i, 1);
+          }
+          instNotes.push(`\u63D2\u69FD ${name}#${nm} \u7684\u5185\u5BB9\u65E0\u51FA\u53E3\u63A5\u4F4F\uFF08\u5B50\u7EC4\u4EF6\u6CA1\u6709\u540C\u540D <slot>\uFF09\u21D2 \u672A\u6E32\u67D3`);
+        }
+      }
+      for (const r of childInst.nodes) if (r.parentId === null) r.parentId = boundary.id;
+      nodes.push(...childInst.nodes);
+      componentNodes += childInst.nodes.length;
+      valuesFilled += childInst.stats.valuesFilled;
+      nextId = childOffset + childInst.stats.maxLocalId + 1;
+      componentMounts.push({
+        boundaryNodeId: boundary.id,
+        name,
+        props,
+        ctx,
+        table: def.table,
+        registry: childRegistry,
+        nodeIds: childInst.nodes.map((x) => x.id),
+        idOffset: idOffset + childOffset,
+        // ★P1-3 emits：边界在**本树**的 id 空间 —— 宿主要加 idOffset 才是它看到的 id
+        treeOffset: idOffset
+      });
+      for (const m of childInst.componentMounts ?? []) componentMounts.push(m);
+      for (const sm of childInst.slotMounts ?? []) slotMounts.push(sm);
+      for (const d of childInst.stats.droppedNodeIds ?? []) droppedNodeIds.add(d);
+      for (const nt of childInst.notes ?? []) instNotes.push(nt);
+    }
+  }
+  if ((opts.componentDepth ?? 0) === 0) {
+    dissolveOutlets(nodes, /* @__PURE__ */ new Map());
+    for (const x of nodes) {
+      const rec = x;
+      if (rec.slotFor !== void 0) delete rec.slotFor;
+      if (rec.slotOutlet !== void 0) delete rec.slotOutlet;
+    }
+  }
+  return {
+    viewport: opts.viewport,
+    nodes,
+    stats: {
+      reusedTemplateIds: reused,
+      allocatedIds: allocated,
+      rows: nodes.length,
+      valuesFilled,
+      // ★P1-3：本树 local 高水位（父级据此推进自己的分配器——**不含** idOffset）
+      maxLocalId: nextId - 1,
+      componentNodes,
+      // ★P1-3 插槽分发：丢弃节点（最终 id 空间）——桥传给运行时 `skipNodeIds`
+      ...droppedNodeIds.size > 0 ? { droppedNodeIds: [...droppedNodeIds] } : {}
+    },
+    // ★只有**恰好一个**列表时才给虚拟化描述（多个列表 ⇒ 行号空间不同源，宿主按行号二分会错配）
+    virtual: virtualRows.length > 0 && tpl.lists.length === 1 ? { rows: virtualRows } : void 0,
+    ...componentMounts.length > 0 ? { componentMounts } : {},
+    ...slotMounts.length > 0 ? { slotMounts } : {},
+    ...instNotes.length > 0 ? { notes: instNotes } : {}
+  };
 }
-function degradationOf(prim) {
-  const out = {};
-  for (const p of prim.props ?? []) out[p] = degradeProp(prim.tag, p);
-  return out;
+
+// ../slot-runtime/src/dispatch.ts
+function createDispatchState() {
+  return { onceFired: /* @__PURE__ */ new Set() };
 }
-var DEGRADATION_TABLE = (() => {
-  const out = {};
-  for (const prim of PRIMITIVE_CATALOG) {
-    if (!prim.tag) continue;
-    out[prim.tag] = degradationOf(prim);
-  }
-  return out;
-})();
-var MP_UNSUPPORTED_PROPS = (() => {
-  const kebab = (s) => s.replace(/([a-z0-9])([A-Z])/g, "$1-$2").toLowerCase();
-  const out = {};
-  for (const [tag, table] of Object.entries(DEGRADATION_TABLE)) {
-    const set = /* @__PURE__ */ new Set();
-    for (const [prop, entry] of Object.entries(table)) {
-      if (entry.mp === "unsupported") set.add(kebab(prop));
+var keyOf = (nodeId, event, handler) => `${nodeId}:${event}:${handler}`;
+function indexEventBindings(bindings) {
+  const byNodeEvent = /* @__PURE__ */ new Map();
+  for (const b of bindings) byNodeEvent.set(`${b.nodeId}:${b.event}`, b);
+  return byNodeEvent;
+}
+function dispatchGesture(chain, event, index, state, run) {
+  const fired = [];
+  const skippedSelf = [];
+  const skippedOnce = [];
+  let handler = "";
+  let stopped = false;
+  const hit = chain.length > 0 ? chain[0] : -1;
+  for (const id of chain) {
+    const b = index.get(`${id}:${event}`) ?? index.get(`${id}:tap`);
+    if (!b) continue;
+    if (b.componentEmit) continue;
+    if (b.self && id !== hit) {
+      skippedSelf.push(id);
+      continue;
+    }
+    const onceKey = keyOf(id, b.event, b.handler);
+    if (b.once && state.onceFired.has(onceKey)) {
+      skippedOnce.push(id);
+      continue;
+    }
+    if (!run(b.handler, id)) continue;
+    if (b.once) state.onceFired.add(onceKey);
+    fired.push(id);
+    if (!handler) handler = b.handler;
+    if (b.stop) {
+      stopped = true;
+      break;
     }
-    if (set.size) out[tag] = set;
   }
-  return out;
-})();
+  return { fired, handler, stopped, skippedSelf, skippedOnce };
+}
+
+// ../slot-runtime/src/directives.ts
+var HOST_DIRECTIVE_SPECS = {
+  animate: {
+    argKind: "anim-preset",
+    argHint: "\u52A8\u753B\u9884\u8BBE\uFF08fade / slide-up / slide-down / slide-left / slide-right / zoom / fade-slide-up\uFF09",
+    desc: "\u503C\u53D8\u5316\uFF08\u6216\u9996\u6B21\u6C42\u503C\u4E3A\u771F\uFF09\u65F6\u5728\u8BE5\u8282\u70B9**\u64AD\u4E00\u6B21**\u9884\u8BBE\u52A8\u753B\uFF08\u8D70\u5185\u6838\u52A8\u753B\u901A\u9053\uFF0C\u4E0E <Transition> \u540C\u4E00\u5957\uFF09\u3002\u8BED\u4E49\u5BF9\u9F50\uFF1A\u6307\u4EE4\u7684 mounted\uFF08\u9996\u8BC4 truthy \u5373\u64AD\uFF09\u4E0E updated\uFF08\u503C\u53D8\u5316\u5373\u64AD\uFF09\u3002"
+  }
+};
+var HOST_DIRECTIVE_NAMES = Object.keys(HOST_DIRECTIVE_SPECS);
 
 // src/dispatcher.ts
 var DispatcherError = class extends Error {
@@ -1782,6 +4054,7 @@ function createNodeOpsDispatcher(initialBackend) {
   };
 }
 function renderIRTree(backend, ir, insertInto) {
+  if (ir.type === "#text") return backend.createText(ir.text ?? "");
   const root = backend.createElement(ir);
   for (const child of ir.children) {
     const c = renderIRTree(backend, child);
@@ -2212,6 +4485,133 @@ function createWebHostRuntime(opts = {}) {
   return rt;
 }
 
+// src/quickjs-host.ts
+function createQuickJsHostRuntime(opts = {}) {
+  const id = opts.id ?? "quickjs";
+  const capabilities = {
+    threads: { main: true, background: false, count: 1 },
+    // ★诚实声明：无后台线程
+    engine: opts.engine ?? "quickjs",
+    // 桥**机制**恒在（registerNativeHandler/invokeNative/拒绝协议都存在）；transport 是可选出口
+    nativeBridge: true,
+    lifecycle: "full",
+    // 宿主壳转发 onPause/onResume ⇒ full
+    frameDriver: opts.frameDriver ?? "manual"
+  };
+  const refusals = [];
+  const lifecycleEvents = [];
+  const handlers = /* @__PURE__ */ new Map();
+  const refuse = (op, reason) => {
+    refusals.push({ op, reason, state: rt.state });
+    throw new Error(`[${id}] \u804C\u8D23\u8FB9\u754C\u62D2\u7EDD ${op}\uFF1A${reason}\uFF08state=${rt.state}\uFF09`);
+  };
+  const rt = {
+    id,
+    state: "created",
+    threads: ["main"],
+    workers: [],
+    queue: [],
+    capabilities,
+    lifecycleEvents,
+    refusals,
+    nativeHandlers: [],
+    bootstrap() {
+      if (rt.state === "destroyed") refuse("bootstrap", "\u5DF2\u9500\u6BC1\u7684\u8FD0\u884C\u65F6\u4E0D\u53EF\u590D\u6D3B\uFF08G-39.1\uFF1A\u751F\u547D\u5468\u671F\u552F\u4E00\u62E5\u6709\uFF09");
+      if (rt.state === "suspended") refuse("bootstrap", "\u5DF2\u6302\u8D77\u72B6\u6001\u4E0B\u8BF7\u7528 resume()\uFF08bootstrap \u53EA\u8D1F\u8D23 created \u8D77\u6B65\uFF09");
+      rt.state = "running";
+      return rt;
+    },
+    suspend() {
+      if (rt.state !== "running") refuse("suspend", "\u4EC5 running \u53EF\u6302\u8D77\uFF08\u91CD\u590D suspend / \u672A bootstrap \u90FD\u88AB\u62D2\u7EDD\uFF09");
+      rt.state = "suspended";
+      lifecycleEvents.push("suspend");
+    },
+    resume() {
+      if (rt.state !== "suspended") refuse("resume", '\u4EC5 suspended \u53EF\u6062\u590D\uFF08\u9632"\u6CA1\u6302\u8D77\u8FC7\u5374\u4E0A\u62A5 resume"\u7684\u5047\u4E8B\u4EF6\uFF09');
+      rt.state = "running";
+      lifecycleEvents.push("resume");
+    },
+    destroy() {
+      if (rt.state === "destroyed") refuse("destroy", "\u91CD\u590D\u9500\u6BC1\uFF08\u7B2C\u4E8C\u6B21 destroy \u901A\u5E38\u662F\u4E0A\u5C42\u7684\u91CD\u590D\u6E05\u7406\u2014\u2014\u771F\u5B9E\u7F3A\u9677\uFF09");
+      rt.state = "destroyed";
+      rt.queue = [];
+      rt.workers = [];
+      rt.threads = ["main"];
+      lifecycleEvents.push("destroy");
+    },
+    createWorker() {
+      if (rt.state === "destroyed") refuse("createWorker", "\u5DF2\u9500\u6BC1\u7684\u8FD0\u884C\u65F6\u4E0D\u80FD\u521B\u5EFA\u6267\u884C\u57DF");
+      const w = {
+        id: `w${rt.workers.length + 1}`,
+        thread: `worker${rt.workers.length + 1}`,
+        real: false
+      };
+      rt.workers.push(w);
+      rt.threads.push(w.thread);
+      return w;
+    },
+    postMessage() {
+      return true;
+    },
+    enqueue(task, priority = 2) {
+      if (rt.state === "destroyed") refuse("enqueue", "\u5DF2\u9500\u6BC1\u7684\u8FD0\u884C\u65F6\u4E0D\u518D\u63A5\u6536\u4EFB\u52A1\uFF08\u9632\u60AC\u7A7A\u56DE\u8C03\uFF09");
+      rt.queue.push({ task, priority });
+    },
+    nextTick(fn) {
+      if (rt.state === "destroyed") refuse("nextTick", "\u5DF2\u9500\u6BC1\u7684\u8FD0\u884C\u65F6\u4E0D\u518D\u63A5\u6536\u4EFB\u52A1");
+      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;
+    },
+    /** ★宿主帧驱动（Android Choreographer / iOS CADisplayLink）：一帧消费一次队列 */
+    pumpFrame() {
+      if (rt.state === "destroyed") return 0;
+      if (rt.state === "suspended") return 0;
+      rt.queue.sort((a, b) => a.priority - b.priority);
+      let n = 0;
+      while (rt.queue.length) {
+        const { task } = rt.queue.shift();
+        task();
+        n++;
+      }
+      return n;
+    },
+    registerNativeHandler(name, handler) {
+      handlers.set(name, handler);
+      rt.nativeHandlers.push(name);
+    },
+    runOnThread(thread, task) {
+      if (thread === "main") {
+        rt.enqueue(task, 2);
+        return;
+      }
+      return refuse("runOnThread(background)", "\u672C\u5BBF\u4E3B capabilities.threads.background=false\uFF08\u5355\u7EBF\u7A0B JS \u5F15\u64CE\uFF1B\u8C03\u7528\u65B9\u5E94\u67E5 capabilities \u540E\u964D\u7EA7\uFF09");
+    },
+    async invokeNative(name, args) {
+      if (rt.state === "destroyed") refuse("invokeNative", "\u5DF2\u9500\u6BC1\u7684\u8FD0\u884C\u65F6\u4E0D\u80FD\u8C03\u539F\u751F");
+      const h = handlers.get(name);
+      if (h) return h(args);
+      if (opts.transport) {
+        const json = opts.transport.call(name, JSON.stringify(args ?? null));
+        try {
+          return JSON.parse(json);
+        } catch {
+          return json;
+        }
+      }
+      return refuse("invokeNative", `\u539F\u751F\u65B9\u6CD5\u300C${name}\u300D\u672A\u6CE8\u518C\u4E14\u65E0 transport\uFF08\u5DF2\u6CE8\u518C\uFF1A${rt.nativeHandlers.join(", ") || "\uFF08\u7A7A\uFF09"}\uFF09`);
+    }
+  };
+  return rt;
+}
+
 // src/hot-switch.ts
 function createBackendSwitcher(dispatch) {
   let currentIR = null;
@@ -3521,7 +5921,7 @@ function createSinglePageContainer(opts = {}) {
   const emit = (event, payload) => {
     for (const fn of events[event] ?? []) fn(payload);
   };
-  function createSlot(config) {
+  function createSlot2(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++;
@@ -3530,7 +5930,7 @@ function createSinglePageContainer(opts = {}) {
     return page;
   }
   function createPage(config) {
-    return createSlot(config);
+    return createSlot2(config);
   }
   async function destroyPage(handle) {
     const page = pages.get(handle.pageId);
@@ -3568,7 +5968,7 @@ function createSinglePageContainer(opts = {}) {
     destroyPage,
     async push(config) {
       for (const p of [...pages.values()]) await destroyPage(p);
-      const page = createSlot(config);
+      const page = createSlot2(config);
       await mountPage(page);
       current = page;
       return page;
@@ -3995,10 +6395,10 @@ function analyzeOwnershipSource(source, opts = {}) {
       if (src) src.activeBorrows++;
       continue;
     }
-    const call = txt.match(CALL_RE);
-    if (call) {
-      const name = call[1];
-      const op = call[2];
+    const call2 = txt.match(CALL_RE);
+    if (call2) {
+      const name = call2[1];
+      const op = call2[2];
       const info = vars.get(name);
       if (!info) continue;
       if (op === "transferTo") {
@@ -4343,10 +6743,10 @@ function insertScopeDrops(source) {
       }
       continue;
     }
-    const call = t.match(/([A-Za-z_$][\w$]*)\s*\.\s*(?:drop|transferTo)\s*\(/);
-    if (call) {
+    const call2 = t.match(/([A-Za-z_$][\w$]*)\s*\.\s*(?:drop|transferTo)\s*\(/);
+    if (call2) {
       for (const p of pending) {
-        if (p.varName === call[1] && !p.disposed) {
+        if (p.varName === call2[1] && !p.disposed) {
           p.disposed = true;
           break;
         }
@@ -4566,6 +6966,587 @@ function formatMatrixReport(report) {
   }
   return lines.join("\n");
 }
+
+// ../contracts/src/layers.ts
+var LAYER_PRIMITIVES = ["layer-content", "layer-navigation", "layer-mask", "layer-popout"];
+
+// ../contracts/src/mount-layers.ts
+var MOUNT_LAYERS = ["global", "page", "overlay"];
+var MOUNT_LAYER_ORDER = {
+  global: 0,
+  page: 1,
+  overlay: 2
+};
+var MOUNT_LAYER_NODE_OFFSET = {
+  global: 1,
+  page: 2,
+  overlay: 3
+};
+function mountLayerContainerPlans() {
+  return [...MOUNT_LAYERS].sort((a, b) => MOUNT_LAYER_ORDER[a] - MOUNT_LAYER_ORDER[b]).map((layer) => ({
+    layer,
+    nodeOffset: MOUNT_LAYER_NODE_OFFSET[layer],
+    order: MOUNT_LAYER_ORDER[layer],
+    frame: "fullscreen"
+  }));
+}
+
+// ../contracts/src/scroll.ts
+var DOCK_REQUIRES_LAYER = LAYER_PRIMITIVES.includes("layer-navigation");
+
+// src/screen-executor.ts
+function screenContentFromLayoutTemplate(template, viewport) {
+  const nodes = template.nodes.map((n) => {
+    const out = {
+      id: n.id,
+      parentId: n.parentId,
+      // ★展平：`style` 的引擎字段提到顶层（内核 NodeDto 读顶层键）
+      ...n.style ?? {}
+    };
+    if (typeof n.text === "string" && n.text.length > 0) out.text = n.text;
+    if (typeof n.tag === "string" && n.tag.length > 0) out.semantic = n.tag;
+    return out;
+  });
+  return viewport ? { viewport, nodes } : { nodes };
+}
+function createScreenExecutor(opts) {
+  const { host, anim, plan, contentOf, onScreenMounted, onEvent } = opts;
+  const nodes = /* @__PURE__ */ new Map();
+  const stats = {
+    commands: 0,
+    transitions: 0,
+    forward: 0,
+    back: 0,
+    skippedNone: 0,
+    destroyed: { pop: 0, reset: 0, freeze: 0 },
+    visibility: { shown: 0, hidden: 0 },
+    mounts: { first: 0, rebuild: 0 },
+    errors: []
+  };
+  let txn = { exiting: null, mounted: /* @__PURE__ */ new Map() };
+  const emit = (type, screenId, detail) => {
+    onEvent?.({ type, screenId, detail });
+  };
+  async function runCommand(cmd) {
+    stats.commands++;
+    switch (cmd.op) {
+      case "mount": {
+        const rebuild = cmd.rebuild === true;
+        const name = cmd.name ?? cmd.screenId;
+        const path = cmd.path ?? "";
+        const content = contentOf?.({ name, path });
+        const node = await host.mountScreen({
+          screenId: cmd.screenId,
+          name,
+          path,
+          params: cmd.params ?? null,
+          rebuild,
+          ...content ? { content } : {},
+          // ★GP3-c：三层容器计划（由**契约**算，宿主只消费——偏移量而非绝对 id，见类型注释）
+          layerContainers: mountLayerContainerPlans()
+        });
+        nodes.set(cmd.screenId, node);
+        txn.mounted.set(cmd.screenId, rebuild);
+        if (rebuild) stats.mounts.rebuild++;
+        else stats.mounts.first++;
+        emit("mount", cmd.screenId, { rebuild, node, contentNodes: content?.nodes.length ?? 0 });
+        onScreenMounted?.(cmd.screenId, rebuild);
+        return;
+      }
+      case "exit": {
+        txn.exiting = { screenId: cmd.screenId, transition: cmd.transition, destroy: null };
+        emit("exit", cmd.screenId, { transition: cmd.transition });
+        return;
+      }
+      case "unmount": {
+        const reason = cmd.reason ?? "pop";
+        if (txn.exiting && txn.exiting.screenId === cmd.screenId) {
+          txn.exiting.destroy = reason;
+          emit("unmount-deferred", cmd.screenId, { reason });
+          return;
+        }
+        await host.destroyScreen(cmd.screenId, reason, nodes.get(cmd.screenId));
+        nodes.delete(cmd.screenId);
+        stats.destroyed[reason]++;
+        emit("destroy", cmd.screenId, { reason });
+        return;
+      }
+      case "enter": {
+        const incomingNode = nodes.get(cmd.screenId);
+        if (incomingNode === void 0) {
+          stats.errors.push(`enter(${cmd.screenId})\uFF1A\u5C4F\u5B50\u6811\u4E0D\u5B58\u5728\uFF08mount \u672A\u6267\u884C\uFF1F\uFF09`);
+          emit("error", cmd.screenId, "enter-without-subtree");
+          return;
+        }
+        const exiting = txn.exiting;
+        const outgoingNode = exiting ? nodes.get(exiting.screenId) : void 0;
+        const mountedHere = txn.mounted.get(cmd.screenId);
+        const direction = mountedHere === false ? "forward" : "back";
+        const transition = cmd.transition;
+        const batch = plan(transition, { incoming: incomingNode, outgoing: outgoingNode }, { direction });
+        const normalized = typeof transition === "string" ? transition : "none";
+        await host.setScreenVisible(cmd.screenId, true, incomingNode);
+        stats.visibility.shown++;
+        emit("visible", cmd.screenId, true);
+        const hasAnims = batch.incoming.anims.length > 0 || batch.outgoing.anims.length > 0;
+        if (hasAnims) {
+          await anim.playRouteTransition(batch, { direction, transition: normalized });
+          stats.transitions++;
+          if (direction === "forward") stats.forward++;
+          else stats.back++;
+          emit("transition", cmd.screenId, { direction, transition: normalized, anims: batch.incoming.anims.length + batch.outgoing.anims.length });
+        } else {
+          stats.skippedNone++;
+          emit("transition-skipped", cmd.screenId, { transition: normalized });
+        }
+        if (exiting) {
+          if (exiting.destroy !== null) {
+            await host.destroyScreen(exiting.screenId, exiting.destroy, outgoingNode);
+            nodes.delete(exiting.screenId);
+            stats.destroyed[exiting.destroy]++;
+            emit("destroy", exiting.screenId, { reason: exiting.destroy, deferred: true });
+          } else if (outgoingNode !== void 0) {
+            await host.setScreenVisible(exiting.screenId, false, outgoingNode);
+            stats.visibility.hidden++;
+            emit("visible", exiting.screenId, false);
+          }
+        }
+        txn = { exiting: null, mounted: /* @__PURE__ */ new Map() };
+        return;
+      }
+    }
+  }
+  let queue = Promise.resolve();
+  return {
+    applyCommands(commands) {
+      queue = queue.then(async () => {
+        for (const c of commands) await runCommand(c);
+      });
+      return queue;
+    },
+    stats: () => JSON.parse(JSON.stringify(stats)),
+    subtreeNode: (screenId) => nodes.get(screenId)
+  };
+}
+
+// src/screen-executor-host.ts
+var SCREEN_ANIM_DONE_KEY = "__proteusHostScreenAnimDone";
+var instSeq = 0;
+function call(channel, method, args) {
+  const raw = channel(method, JSON.stringify(args ?? null));
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (e) {
+    throw new Error(`[screen-host] ${method} \u56DE\u6267\u975E JSON\uFF1A${String(raw).slice(0, 120)}`);
+  }
+  if (parsed && parsed.ok === false) {
+    throw new Error(`[screen-host] ${method} \u5931\u8D25${parsed.missing ? "\uFF08\u672A\u5B9E\u73B0\uFF09" : ""}\uFF1A${parsed.reason ?? "\u65E0\u539F\u56E0"}`);
+  }
+  return parsed && typeof parsed === "object" && "data" in parsed ? parsed.data : parsed;
+}
+function createHostScreenPorts(opts) {
+  const channel = opts.invoke;
+  const pending = /* @__PURE__ */ new Map();
+  let tokenSeq = 0;
+  let hookInstalled = false;
+  const INSTANCE_ID = `s${++instSeq}-`;
+  const resolveOne = (token, payload) => {
+    const r = pending.get(token);
+    if (!r) return false;
+    pending.delete(token);
+    r(payload);
+    return true;
+  };
+  if (opts.installAnimDoneHook !== false) {
+    const g = globalThis;
+    const REGISTRY_KEY = `${SCREEN_ANIM_DONE_KEY}__registry`;
+    let registry = g[REGISTRY_KEY];
+    if (!Array.isArray(registry)) {
+      registry = [];
+      g[REGISTRY_KEY] = registry;
+    }
+    const handler = (token, resultJson) => {
+      if (typeof token !== "string") return "bad-token";
+      const r = registry;
+      for (let i = 0; i < r.length; i++) {
+        if (r[i](token, resultJson)) return "ok";
+      }
+      return "unknown-token";
+    };
+    registry.push((token, payload) => resolveOne(token, payload));
+    try {
+      g[SCREEN_ANIM_DONE_KEY] = handler;
+      hookInstalled = true;
+    } catch {
+      try {
+        Object.defineProperty(g, SCREEN_ANIM_DONE_KEY, { value: handler, writable: true, configurable: true });
+        hookInstalled = true;
+      } catch {
+      }
+    }
+  }
+  const tree = {
+    mountScreen(screen) {
+      const d = call(channel, "screen.mount", {
+        screenId: screen.screenId,
+        name: screen.name,
+        path: screen.path,
+        params: screen.params,
+        rebuild: screen.rebuild,
+        // ★★★GP3-c：**三层容器计划**随 mount 下发（宿主照此建树——偏移量，宿主加到自己分配的根 id 上）。
+        //   执行器已按契约算好（见 screen-executor.ts）；本层只做**透传**（不再重复计算——
+        //   本仓纪律：同一件事两份实现 = 修一份等于没修）。
+        ...screen.layerContainers ? { layerContainers: screen.layerContainers } : {},
+        // ★★★阶段 1（2026-10-04 · App 三端对齐 B1+B2）：**屏内容**（真实页面渲染产物）透传。
+        //   执行器按 `contentOf` 提供者解析后放入 mountScreen 入参；本层只做转发（与上方同款纪律）。
+        ...screen.content ? { content: screen.content } : {}
+      });
+      const rootNodeId = Number(d?.rootNodeId ?? 0);
+      if (!rootNodeId) {
+        throw new Error(`[screen-host] screen.mount \u672A\u8FD4\u56DE rootNodeId\uFF08${JSON.stringify(d)}\uFF09\u2014\u2014\u5BBF\u4E3B\u5B9E\u73B0\u4E0D\u5B8C\u6574`);
+      }
+      return rootNodeId;
+    },
+    setScreenVisible(screenId, visible, rootNodeId) {
+      call(channel, "screen.visible", { screenId, visible, rootNodeId });
+    },
+    destroyScreen(screenId, reason, rootNodeId) {
+      call(channel, "screen.destroy", { screenId, reason, rootNodeId });
+    }
+  };
+  const anim = {
+    playRouteTransition(plan, ctx) {
+      const anims = [...plan.incoming.anims, ...plan.outgoing.anims];
+      if (anims.length === 0) return;
+      const token = `${INSTANCE_ID}screen-anim-${++tokenSeq}`;
+      const d = call(channel, "screen.anim", {
+        anims,
+        durationMs: plan.durationMs,
+        direction: ctx.direction,
+        transition: ctx.transition,
+        token
+      });
+      if (d?.immediate === true) return;
+      return new Promise((resolve) => {
+        pending.set(token, () => resolve());
+      });
+    }
+  };
+  return {
+    tree,
+    anim,
+    shared: {
+      async rect(screenId, nodeId) {
+        const d = call(channel, "screen.rect", { screenId, nodeId });
+        if (!d || typeof d.x !== "number") {
+          throw new Error(`[screen-host] screen.rect \u672A\u8FD4\u56DE\u51E0\u4F55\uFF08${JSON.stringify(d)}\uFF09`);
+        }
+        return { x: d.x, y: d.y ?? 0, w: d.width ?? 0, h: d.height ?? 0 };
+      },
+      fly(opts2) {
+        const token = `screen-shared-${++tokenSeq}`;
+        const d = call(channel, "screen.shared", { ...opts2, token });
+        if (!d || (d.started ?? 0) < 1) {
+          return Promise.reject(new Error(`[screen-host] screen.shared \u672A\u542F\u52A8\uFF08${JSON.stringify(d)}\uFF09`));
+        }
+        const geom = { fromRect: d.fromRect, toRect: d.toRect };
+        return new Promise((resolve) => {
+          pending.set(token, (v) => {
+            let extra = {};
+            if (typeof v === "string") {
+              try {
+                const o = JSON.parse(v);
+                if (o && typeof o === "object") extra = o;
+              } catch {
+              }
+            } else if (v && typeof v === "object") {
+              extra = v;
+            }
+            resolve({ ...geom, ...extra });
+          });
+        });
+      }
+    },
+    get pendingAnimations() {
+      return pending.size;
+    },
+    get animDoneHookInstalled() {
+      return hookInstalled;
+    }
+  };
+}
+
+// src/screen-runtime.ts
+function createScreenRuntime(opts) {
+  const base = opts.contentIdBase;
+  const instances = /* @__PURE__ */ new Map();
+  const note = opts.onNote ?? (() => {
+  });
+  function make(name) {
+    const art = opts.artifacts[name];
+    if (!art) throw new Error(`[screen-runtime] \u65E0\u8BE5\u5C4F\u4EA7\u7269\uFF1A${name}`);
+    const data = { ...art.data, ...opts.seedData?.[name] ?? {} };
+    const read = (n) => data[n];
+    let inst = instantiateTemplate(art.tpl, { viewport: opts.viewport, read, table: art.table, registry: new ListRegistry() });
+    let localIdsOrdered = inst.nodes.map((n) => n.id);
+    function rebuild() {
+      inst = instantiateTemplate(art.tpl, { viewport: opts.viewport, read, table: art.table, registry: new ListRegistry() });
+      localIdsOrdered = inst.nodes.map((n) => n.id);
+    }
+    if (inst.stats.componentNodes === 0 && inst.nodes.some((n) => n.component)) {
+      note(`[screen-runtime] ${name}: \u6A21\u677F\u542B\u7EC4\u4EF6\u8FB9\u754C\u4F46\u672C\u7248\u672A\u5C55\u5F00\uFF08\u8BDA\u5B9E\u8FB9\u754C\uFF09`);
+    }
+    const keys = new PropKeyTable();
+    const strings = new StringPool();
+    const slotRt = new SlotRuntime(keys, strings, (bytes) => {
+      opts.applyOps(JSON.stringify(Array.from(bytes)));
+    });
+    const vapor = new VaporRuntime(art.table, slotRt, VaporRuntime.buildEvaluators(art.table.evaluators), new ListRegistry());
+    const evalCtx = { read };
+    vapor.load(evalCtx, () => {
+    });
+    vapor.relink(evalCtx);
+    slotRt.flush();
+    const byNodeEvent = indexEventBindings(art.events);
+    const dispatchState = createDispatchState();
+    function runHandler(handlerName, _nodeId, payload) {
+      const acts = art.handlers[handlerName];
+      if (!acts) return false;
+      for (const a of acts) {
+        if (a.op === "emit") {
+          note(`[screen-runtime] ${name}: handler\u300C${handlerName}\u300D\u542B $emit\u2014\u2014\u672C\u7248\u65E0\u53BB\u5904\uFF08\u5DF2\u5FFD\u7565\uFF09`);
+          continue;
+        }
+        if (a.op === "nav") {
+          const tgt = a.target;
+          if (tgt && opts.navigate) opts.navigate(tgt);
+          else note(`[screen-runtime] ${name}: $nav('${tgt ?? ""}') \u65E0 navigate \u51FA\u53E3\uFF08\u672A\u88C5\u914D\uFF09`);
+          continue;
+        }
+        const ctx2 = { read: (n) => n === "$event" ? payload : data[n] };
+        const v = evalExpr(a.program, ctx2);
+        if (!a.source) continue;
+        if (a.op === "add") {
+          const cur = data[a.source];
+          data[a.source] = (typeof cur === "number" ? cur : 0) + (typeof v === "number" ? v : 0);
+        } else if (a.op === "set") {
+          data[a.source] = v;
+        }
+      }
+      return true;
+    }
+    function localIdOf(kernelId) {
+      if (typeof base !== "number") return kernelId;
+      const idx = kernelId - base;
+      return idx >= 0 && idx < localIdsOrdered.length ? localIdsOrdered[idx] : kernelId;
+    }
+    function refreshData() {
+      rebuild();
+      vapor.relink(evalCtx);
+      slotRt.flush();
+    }
+    return {
+      content() {
+        return { viewport: inst.viewport, nodes: inst.nodes };
+      },
+      dispatch(type, chain) {
+        const localChain = chain.map(localIdOf);
+        const r = dispatchGesture(localChain, type, byNodeEvent, dispatchState, (h, id) => runHandler(h, id));
+        if (r.fired.length > 0) refreshData();
+        return { handled: r.fired.length > 0, fired: r.fired };
+      },
+      flush() {
+        slotRt.flush();
+      },
+      refresh() {
+        refreshData();
+      },
+      data() {
+        return data;
+      },
+      snapshot() {
+        return { ...data };
+      }
+    };
+  }
+  return {
+    has: (name) => Boolean(opts.artifacts[name]),
+    instance(name) {
+      let it = instances.get(name);
+      if (!it) {
+        it = make(name);
+        instances.set(name, it);
+      }
+      return it;
+    },
+    /** ★跨调用状态导出（每屏数据浅拷贝）——一次性 VM 宿主持有、下次回灌（见 seedData） */
+    snapshot() {
+      const out = {};
+      for (const [name, it] of instances) out[name] = it.snapshot();
+      return out;
+    }
+  };
+}
+
+// src/host-invoke-contract.ts
+var HOST_SCREEN_METHODS = [
+  "screen.mount",
+  "screen.visible",
+  "screen.destroy",
+  "screen.anim",
+  "screen.rect",
+  "screen.shared",
+  "screen.stats"
+];
+var HOST_CAPABILITY_METHODS = [
+  // 宿主上下文 / 热更新 / 窗口
+  "host.context",
+  "update.check",
+  "update.apply",
+  "window.setSize",
+  // Worker（G-39 后台线程）
+  "worker.create",
+  "worker.post",
+  "worker.terminate",
+  // 空闲回调 / 预加载 / 扩展
+  "idle.request",
+  "idle.cancel",
+  "preload.assets",
+  "extension.load",
+  // 跳其他小程序（App 端对齐 Web：通常无对等）
+  "mini-program.navigate",
+  // WebAssembly（宿主运行时；★引擎内置 WASM 的端可不实现——见 HOST_METHOD_OPTIONAL）
+  "webassembly.instantiate",
+  "webassembly.validate",
+  "webassembly.call",
+  "webassembly.release",
+  // 宿主自报调用记账（判据"能力经壳执行"）
+  "native.calls"
+];
+var HOST_METHOD_OPTIONAL = {
+  // iOS JSC 内建 WebAssembly（`typeof WebAssembly === 'object'`）⇒ 壳不实现 `webassembly.*`。
+  ios: ["webassembly.instantiate", "webassembly.validate", "webassembly.call", "webassembly.release"]
+  // 鸿蒙：能力族尚未接线（memUsage/gc 之外）——★**缺失已登记**（非合法省略；门禁以"覆盖率"报告，不静默）。
+};
+var HOST_INVOKE_METHODS = [...HOST_CAPABILITY_METHODS, ...HOST_SCREEN_METHODS];
+
+// src/tab-bar-spec.ts
+var TAB_BAR_SPEC = {
+  height: 56,
+  surface: "#ffffff",
+  line: "#dcdfe5",
+  brand: "#5b5bd6",
+  text3: "#5f6673",
+  badgeBg: "#d64545",
+  iconSize: 19,
+  labelSize: 10,
+  badge: { radius: 8, fontSize: 11, offsetX: 4, offsetY: 4, padX: 4 },
+  icons: { index: "\u2302", messages: "\u2709", mine: "\u263A" },
+  labels: { index: "\u9996\u9875", messages: "\u6D88\u606F", mine: "\u6211\u7684" }
+};
+
+// src/superapp-runtime.ts
+function createSuperappRuntime(opts) {
+  const note = opts.onNote ?? (() => {
+  });
+  const cbName = opts.gestureCbName ?? "__proteusRuntimeGesture";
+  const rt = createScreenRuntime({
+    artifacts: opts.artifacts,
+    applyOps: (ops) => {
+      opts.host.applyOps(ops);
+    },
+    viewport: opts.viewport,
+    ...opts.navigate ? { navigate: opts.navigate } : {},
+    ...opts.seedData ? { seedData: opts.seedData } : {},
+    onNote: note
+  });
+  let cur = "";
+  let lastHostReply = null;
+  if (typeof opts.host.onGesture === "function") {
+    opts.host.onGesture(cbName);
+  }
+  ;
+  globalThis[cbName] = (type, _kernelId, chainJson) => {
+    let chain = [];
+    try {
+      chain = chainJson ? JSON.parse(chainJson) : [];
+    } catch {
+      note(`[superapp-runtime] \u624B\u52BF\u94FE JSON \u89E3\u6790\u5931\u8D25\uFF1A${String(chainJson).slice(0, 40)}`);
+    }
+    const r = dispatch(type, chain);
+    return JSON.stringify(r);
+  };
+  function hostOk(reply) {
+    try {
+      const o = JSON.parse(reply);
+      return o?.ok !== false;
+    } catch {
+      return true;
+    }
+  }
+  function dispatch(type, chain) {
+    if (!cur) return { handled: false, fired: [] };
+    return rt.instance(cur).dispatch(type, chain);
+  }
+  const scrollByScreen = /* @__PURE__ */ new Map();
+  const history = [];
+  let curIdx = -1;
+  return {
+    mountScreen(name) {
+      if (!rt.has(name)) {
+        note(`[superapp-runtime] \u65E0\u8BE5\u5C4F\u8FD0\u884C\u671F\u4EA7\u7269\uFF1A${name}`);
+        return false;
+      }
+      if (name === cur) return true;
+      if (cur && typeof opts.host.getScroll === "function") {
+        scrollByScreen.set(cur, opts.host.getScroll());
+      }
+      const existing = history.indexOf(name);
+      let restore = 0;
+      if (existing >= 0 && existing < curIdx) {
+        history.length = existing + 1;
+        curIdx = existing;
+        restore = scrollByScreen.get(name) ?? 0;
+      } else {
+        history.length = curIdx + 1;
+        history.push(name);
+        curIdx = history.length - 1;
+        scrollByScreen.set(name, 0);
+        restore = 0;
+      }
+      const inst = rt.instance(name);
+      const reply = opts.host.mount(JSON.stringify({ viewport: inst.content().viewport, nodes: inst.content().nodes }));
+      lastHostReply = reply;
+      if (!hostOk(reply)) {
+        note(`[superapp-runtime] \u5BBF\u4E3B mount \u5931\u8D25\uFF1A${String(reply).slice(0, 200)}`);
+        return false;
+      }
+      if (typeof opts.host.setScroll === "function") opts.host.setScroll(restore);
+      cur = name;
+      return true;
+    },
+    mountScreenInto(name) {
+      if (!rt.has(name)) {
+        note(`[superapp-runtime] \u65E0\u8BE5\u5C4F\u8FD0\u884C\u671F\u4EA7\u7269\uFF1A${name}`);
+        return false;
+      }
+      const inst = rt.instance(name);
+      const reply = opts.host.mount(JSON.stringify({ viewport: inst.content().viewport, nodes: inst.content().nodes }));
+      lastHostReply = reply;
+      if (!hostOk(reply)) {
+        note(`[superapp-runtime] \u5BBF\u4E3B mount\uFF08\u91CD\u6302\uFF09\u5931\u8D25\uFF1A${String(reply).slice(0, 200)}`);
+        return false;
+      }
+      cur = name;
+      return true;
+    },
+    dispatchGesture: dispatch,
+    current: () => cur,
+    snapshot: () => rt.snapshot(),
+    lastHostReply: () => lastHostReply
+  };
+}
 export {
   Borrow,
   CONTAINER_PROFILES,
@@ -4575,7 +7556,11 @@ export {
   FIVE_ATOMIC_STEPS,
   FORK_SIGNATURES,
   HOSTS,
+  HOST_CAPABILITY_METHODS,
   HOST_ENGINE_MATRIX,
+  HOST_INVOKE_METHODS,
+  HOST_METHOD_OPTIONAL,
+  HOST_SCREEN_METHODS,
   Managed,
   ManagedRegistry,
   OWNERSHIP_ERRORS,
@@ -4583,7 +7568,9 @@ export {
   OwnershipError,
   OwnershipGraph,
   PAGE_STATE_TRANSITIONS,
+  SCREEN_ANIM_DONE_KEY,
   SENSITIVE_CAPABILITIES,
+  TAB_BAR_SPEC,
   Weak,
   analyzeOwnershipSource,
   analyzePss,
@@ -4601,6 +7588,7 @@ export {
   createFlutterBackend,
   createHeadlessBackend,
   createHostRuntimeStub,
+  createHostScreenPorts,
   createHybridRenderer,
   createMiniProgramContainer,
   createMockNativeAdapter,
@@ -4611,12 +7599,17 @@ export {
   createPageOwnership,
   createProteusRenderer,
   createProteusRendererForBackend,
+  createQuickJsHostRuntime,
   createQuotaManager,
   createQuotaTracker,
   createResourcePool,
+  createScreenExecutor,
+  createScreenRuntime,
+  createSelfDrawBatchAdapter,
   createSinglePageContainer,
   createStackContainer,
   createSuperAppContainer,
+  createSuperappRuntime,
   createVueDomBackend,
   createVueRendererOptions,
   createWebHostRuntime,
@@ -4642,6 +7635,7 @@ export {
   runHybridConformance,
   runPss,
   scanRepoForFork,
+  screenContentFromLayoutTemplate,
   semanticSequence,
   textureRef,
   toPlainTree,