Zayden-Jung/endorphin-tessera-gui
1
1
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

docs: explain scroll projection and source hit selection

Browse Source
This commit is contained in:
Codex Bot
2026-11-12 18:57:09 +08:00
parent ac6cc82b0e
commit cd323de3ac
2 changed files with 75 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/render/scroll.rs
+50
View File
@@ -24,6 +24,7 @@ pub enum Axis {
}
impl Axis {
/// 返回内部枚举或对象对应的稳定源名称。
// model/block 的属性读取以此输出源文本，名称与 parse 接受的值保持对应。
pub fn name(self) -> &'static str {
match self {
Self::Both => "both",
@@ -32,6 +33,7 @@ impl Axis {
}
}
/// 把外部源码或属性表示转换为内部枚举/结构，并反馈不支持的输入。
// model/block 写入 ScrollBlock.axis 时调用；未知字符串返回参数错误，不降级成默认双轴。
pub fn parse(name: &str) -> Result<Self, VmError> {
match name {
"both" => Ok(Self::Both),
@@ -43,16 +45,19 @@ impl Axis {
}
}
/// 判断滚动轴配置是否允许该方向移动，避免同时把禁用轴纳入滚动范围。
// project 计算可滚范围时调用；禁用水平轴意味着该轴上限为零，旧偏移也会被投影钳到零。
pub fn horizontal(self) -> bool {
self != Self::Vertical
}
/// 判断滚动轴配置是否允许该方向移动，避免同时把禁用轴纳入滚动范围。
// project 用于纵轴范围，Both 同时允许两个轴，Horizontal 只禁用此纵轴。
pub fn vertical(self) -> bool {
self != Self::Horizontal
}
}
/// 求两个裁剪矩形的交集，空区域仍保持合法非负尺寸。
// project 的普通 clip_children 和滚动视口共同使用，裁剪数据随后供绘制与命中复用。
fn intersection(a: [f32; 4], b: [f32; 4]) -> [f32; 4] {
// 输入采用 [左, 上, 宽, 高]。交集左上取较大值，右下取较小值；
// 右/下边界再钳到左/上边界，保证完全错开时输出零面积而非负尺寸。
@@ -66,21 +71,26 @@ fn intersection(a: [f32; 4], b: [f32; 4]) -> [f32; 4] {
]
}
/// 沿出现树累计滚动偏移和裁剪；遇到独立场景视口时按其有限边界重新建立投影范围。
// ui_bridge 在完成 Mount 布局后调用，随后 viewport::project 填充相机变换；此处只完成滚动和原生绘制投影。
pub fn project(vm: &mut Vm, table: &MountTable, root: &UiNode, frame: &mut Frame) -> Result<()> {
// 第一阶段只建立查找表，不改坐标：Block ID 查语义节点，Mount ID 查帧中的出现。
// 同一个 Block 可以多次出现；滚动偏移后面按 Mount 读取，不能存入这个 Block 表。
let mut nodes = HashMap::new();
// 显式栈遍历不可变视觉树，nodes 按业务 Block 身份索引，只存语义描述而非每次出现的偏移。
let mut work = vec![root];
// 记录节点并展开子节点，后续出现用 block_id 查回同一业务视觉；最终绘制顺序来自 frame.mounts。
while let Some(node) = work.pop() {
nodes.insert(node.block_id.as_str(), node);
work.extend(node.children().iter().map(|node| node.as_ref()));
}
// Mount ID 映射到当前数组位置，后面的逆向范围汇总需要按 parent ID 直接访问父项。
let indices: HashMap<_, _> = frame
.mounts
.iter()
.enumerate()
.map(|(i, m)| (m.id, i))
.collect();
// 与 frame.mounts 等长的布尔表，每次出现都单独标记是否滚动容器，便于两个阶段共享判断。
let scrolling: Vec<_> = frame
.mounts
.iter()
@@ -92,6 +102,7 @@ pub fn project(vm: &mut Vm, table: &MountTable, root: &UiNode, frame: &mut Frame
.mounts
.iter()
.map(|m| {
// 原始布局右下界作为范围起点；只有 Scroll 扣 inset，避免空内容凭 padding 产生溢出。
let node = nodes[m.block_id.as_str()];
let inset = if matches!(node.kind, UiKind::Scroll { .. }) {
layout::insets(node)
@@ -103,9 +114,12 @@ pub fn project(vm: &mut Vm, table: &MountTable, root: &UiNode, frame: &mut Frame
.collect();
// Mount 按父先子后排列，反向扫描才能先汇总子树，再将边界向父级传播。
for i in (0..frame.mounts.len()).rev() {
// 此时所有 Mount 仍是未减滚动量的布局位置，汇总不能混入第二阶段的投影后坐标。
let m = &frame.mounts[i];
// 根出现没有父级，不向外传播；其余出现要求 parent 存在于本帧的 indices 表。
if let Some(parent) = m.parent {
let parent = indices[&parent];
// 二维/三维场景视口都以有限布局盒隔离世界内容范围，不把内部世界边界加到外层滚动上限。
if matches!(
nodes[frame.mounts[parent].block_id.as_str()].kind,
UiKind::CanvasViewport { .. } | UiKind::Viewport3D { .. }
@@ -126,17 +140,22 @@ pub fn project(vm: &mut Vm, table: &MountTable, root: &UiNode, frame: &mut Frame
// 第二阶段从父到子投影。上下文保存祖先累计位移和裁剪，而非当前节点本身的偏移。
// 重建绘制命令及其平行元数据，保证显示、命中与裁剪使用同一套投影坐标。
let mut contexts = HashMap::<u64, (f32, f32, Option<[f32; 4]>)>::new();
// 重建这一轮原生命令；command_views 先清空，后续 viewport::project 根据滚动后的几何建立变换元数据。
frame.commands.clear();
frame.command_clips.clear();
frame.command_mounts.clear();
frame.command_views.clear();
// 父项先处理，子项才能从 contexts 取到累计位移和裁剪；i 同时索引原始 extent/scrolling 表。
for (i, m) in frame.mounts.iter_mut().enumerate() {
// 无父上下文时使用零位移、无裁剪；父上下文已包含祖先各层的有效滚动量。
let (dx, dy, clip) = m
.parent
.and_then(|id| contexts.get(&id).copied())
.unwrap_or_default();
let node = nodes[m.block_id.as_str()];
// insets 含有效盒模型边距，这里的右/下分量加回内容范围，以得到视口外的实际溢出。
let padding = layout::insets(node);
// 只有 Scroll 的配置决定限轴；非滚动节点暂用 Both 计算辅助值，但不会发布 m.scroll。
let axis = match nodes[m.block_id.as_str()].kind {
UiKind::Scroll { axis, .. } => axis,
_ => Axis::Both,
@@ -158,9 +177,11 @@ pub fn project(vm: &mut Vm, table: &MountTable, root: &UiNode, frame: &mut Frame
m.x -= dx;
m.y -= dy;
m.clip = clip;
// 先继承祖先上下文，当前层的子裁剪和自身滚动随后只写入这个 child，不能影响当前容器边框。
let mut child = (dx, dy, clip);
// 普通裁剪使用边框内侧矩形，并与祖先裁剪求交，不能扩大祖先允许的区域。
if node.clip_children {
// clip_children 的区域从边框内缘开始，不把边框本身裁掉；各轴尺寸钳到非负。
let border = node.border;
let viewport = [
m.x + border.left.min(m.width),
@@ -173,11 +194,14 @@ pub fn project(vm: &mut Vm, table: &MountTable, root: &UiNode, frame: &mut Frame
.unwrap_or(viewport),
);
}
// 仅滚动容器读取托管 Mount 的独立偏移，普通节点不访问该状态，也不产生滚动协议边界。
if scrolling[i] {
// 按出现 ID 查活动弱身份，缺失表示帧与挂载表不一致，不能拿同 Block 的其他出现代替。
let weak = table
.active
.get(&m.id)
.ok_or_else(|| anyhow::anyhow!("missing scroll Mount"))?;
// 升级后得到临时拥有根，payload 读取完成即显式 release，不把 VM 对象带入纯原生帧。
let owner = vm
.upgrade(*weak)?
.ok_or_else(|| anyhow::anyhow!("expired scroll Mount"))?;
@@ -192,7 +216,9 @@ pub fn project(vm: &mut Vm, table: &MountTable, root: &UiNode, frame: &mut Frame
let x = offset[0].clamp(0.0, limits[0]);
let y = offset[1].clamp(0.0, limits[1]);
m.scroll = Some([x, y, limits[0], limits[1]]);
// 滚动内容还受整个容器盒裁剪；如果前面 clip_children 已缩到边框内，则继续与它求交。
let viewport = [m.x, m.y, m.width, m.height];
// 子项累计位移加上本容器的有效偏移，同时收窄裁剪；容器自身 m.x/y 不减自己的 x/y。
child = (
dx + x,
dy + y,
@@ -208,7 +234,9 @@ pub fn project(vm: &mut Vm, table: &MountTable, root: &UiNode, frame: &mut Frame
if matches!(node.kind, UiKind::Viewport3D { .. }) {
child = (0., 0., None);
}
// 保存当前出现对子项的最终上下文；遇到 3D 视口时已重置为其独立二维内容空间。
contexts.insert(m.id, child);
// 按当前出现的滚动后位置生成默认命令，同步附带 clip 与 owner；后续源 paint 可整体替换这些默认命令。
for command in layout::paint_commands(
nodes[m.block_id.as_str()],
m.x,
@@ -223,6 +251,7 @@ pub fn project(vm: &mut Vm, table: &MountTable, root: &UiNode, frame: &mut Frame
frame.command_mounts.push(m.id);
}
}
// 整帧重建后检查一万条上限，失败由上层放弃草稿，不在这里发布超预算帧。
if frame.commands.len() > 10_000 {
bail!("scroll paint command budget exceeded");
}
@@ -230,7 +259,9 @@ pub fn project(vm: &mut Vm, table: &MountTable, root: &UiNode, frame: &mut Frame
}
/// 把源滚动值解码为有限坐标，阻止非数或越界值进入投影。
// 除滚动协议外，Mount 坐标查询、盒模型及场景参数也复用这一有限数值转换；具体正负规则由调用边界补充。
pub fn coordinate(value: &Value) -> Result<f32, VmError> {
// 只接受 Number，本函数不对 Text 做隐式数值解析；后面的字符串转换来自 Number 自身表示。
let Value::Number(value) = value else {
return Err(VmError::InvalidArgument(
"scroll coordinates must be numbers",
@@ -241,12 +272,14 @@ pub fn coordinate(value: &Value) -> Result<f32, VmError> {
.to_string()
.parse::<f32>()
.map_err(|_| VmError::InvalidArgument("invalid scroll coordinate"))?;
// f32 转换可能溢成无穷，需在转换后同时检查有限性与绝对值预算。
if !n.is_finite() || n.abs() > 1_000_000.0 {
return Err(VmError::InvalidArgument("scroll coordinate exceeds limits"));
}
Ok(n)
}
/// 更新指定出现的滚动偏移，并钳制到本轴实际可滚动的内容范围。
// model/mount 的 scrollTo/scrollBy 和 into_view 共用入口，owner 指当前出现，desktop 为所属窗口弱身份。
pub fn set(
cx: &mut NativeContext<'_>,
owner: ObjectRef,
@@ -261,10 +294,12 @@ pub fn set(
"scroll requires committed attached Mount",
));
}
// geometry.scroll 保存上次提交的 [有效x,有效y,最大x,最大y]，缺失表示该出现不是可滚容器。
let bounds = mount
.geometry
.scroll
.ok_or(VmError::InvalidArgument("Mount is not scrollable"))?;
// 相对操作基于 Mount 保存的原始偏移加增量，绝对操作直接使用请求值，随后统一钳到已提交范围。
let next = if relative {
[
mount.scroll_offset[0] + point[0],
@@ -274,6 +309,7 @@ pub fn set(
point
};
mount.scroll_offset = [next[0].clamp(0.0, bounds[2]), next[1].clamp(0.0, bounds[3])];
// 写入前确认窗口仍存活，升级根由 NativeContext 临时管理；失效时不替换 Mount 偏移。
let desktop = cx
.upgrade(desktop)?
.ok_or(VmError::InvalidArgument("Mount window expired"))?;
@@ -283,11 +319,13 @@ pub fn set(
cx.set_attr(desktop, "scrollRequested", Value::Bool(true))
}
/// 沿祖先滚动容器调整偏移，让目标出现进入可见范围。
// model/mount 的 scrollIntoView 以及焦点相关路径调用，从最近祖先向外调整可滚容器。
pub fn into_view(
cx: &mut NativeContext<'_>,
owner: ObjectRef,
desktop: WeakObjectRef,
) -> Result<(), VmError> {
// 先克隆目标描述以跨后续写入使用，读取目标几何后只遍历父链，不修改业务 Block。
let mount = cx.store().payload::<Mount>(owner, "Mount")?.clone();
if !mount.mounted || mount.layout.is_some() {
return Err(VmError::InvalidArgument(
@@ -301,8 +339,11 @@ pub fn into_view(
mount.geometry.width,
mount.geometry.height,
];
// 父关系保存弱身份，遍历时逐个升级；不会因一次滚动操作永久强持有整条祖先链。
let mut parent = mount.parent;
// 每层先记录下一父身份，再按当前祖先类型处理，保证本层 set 替换 payload 不影响遍历游标。
while let Some(weak) = parent {
// 父身份过期时停止外层调整，避免把已失效出现当成仍挂接的滚动容器。
let Some(owner) = cx.upgrade(weak)? else {
break;
};
@@ -317,22 +358,27 @@ pub fn into_view(
mount.geometry.height,
];
}
// 只有已提交几何带滚动范围的祖先需要调整，普通祖先只用于继续沿父链前进。
if let Some(offset) = mount.geometry.scroll {
// 目标起点在视口前则向前对齐；否则只补足末端溢出，已完全可见时返回零。
let delta = |start: f32, length: f32, viewport: f32, size: f32| {
// 目标起点在视口前方时优先对齐起点；目标比视口大时不会同时追求两端可见。
if start < viewport {
start - viewport
} else {
(start + length - viewport - size).max(0.0)
}
};
// 分别计算两轴最小请求位移，再加到当前有效 offset 并按各轴最大范围钳制。
let dx = delta(rect[0], rect[2], mount.geometry.x, mount.geometry.width);
let dy = delta(rect[1], rect[3], mount.geometry.y, mount.geometry.height);
// 用帧中的有效偏移作基准，目标位置的修正也必须使用钳制后的实际差值。
let x = (offset[0] + dx).clamp(0.0, offset[2]);
let y = (offset[1] + dy).clamp(0.0, offset[3]);
// 下一层祖先看到的目标位置必须扣掉本层实际移动量，不能扣未钳制的请求量。
rect[0] -= x - offset[0];
rect[1] -= y - offset[1];
// 已完全可见或被边界钳制后不能移动时，不触发 set 的写屏障和 scrollRequested。
if x != offset[0] || y != offset[1] {
set(cx, owner, desktop, [x, y], false)?;
}
@@ -341,7 +387,9 @@ pub fn into_view(
Ok(())
}
/// 按逆出现顺序选择指针处可处理当前滚动方向的最内层容器。
// shell/app 在滚轮路由时调用，输入点已经进入页面坐标；返回出现 ID 后仍由所属 VM 执行滚动更新。
pub fn wheel_target(frame: &Frame, point: Point, delta: [f32; 2]) -> Option<u64> {
// 按 ID 建立只读祖先查找，候选搜索选定最上层命中出现后只沿这一条父链移动。
let indices: HashMap<_, _> = frame.mounts.iter().map(|mount| (mount.id, mount)).collect();
// 逆序先取最上层命中的出现，再沿其祖先寻找能消费位移的滚动容器。
// 不搜索被覆盖的兄弟容器，内层到边界后才交给外层滚动。
@@ -350,6 +398,7 @@ pub fn wheel_target(frame: &Frame, point: Point, delta: [f32; 2]) -> Option<u64>
.iter()
.rev()
.find(|mount| mount.contains(point));
// 内层先尝试消费；该层无滚动能力或当前方向已到边界时，才检查父容器。
while let Some(mount) = current {
// 只有至少一轴钳制后真正改变偏移才接收此次输入；没有任何容器可移动则返回 None。
if mount.scroll.is_some_and(|s| {
@@ -357,6 +406,7 @@ pub fn wheel_target(frame: &Frame, point: Point, delta: [f32; 2]) -> Option<u64>
}) {
return Some(mount.id);
}
// 只向命中出现的祖先回退，不改为搜索下层兄弟，也不把一次 delta 拆给多个容器。
current = mount.parent.and_then(|id| indices.get(&id).copied());
}
None
src/render/source_hit.rs
+25
View File
@@ -11,6 +11,7 @@ use endor_core::{
#[derive(Debug)]
/// 验证 hitTest 返回的是 Bool，避免把任意真值隐式当成命中。
// selector 把源 hitTest 返回值交给此适配器，之后字节码才根据 Bool 决定返回或继续查找。
struct Boolean;
impl NativeCallable for Boolean {
/// 接收 hitTest 返回的唯一值，交给 invoke 严格检查 Bool。
@@ -29,6 +30,7 @@ impl NativeCallable for Boolean {
}
#[derive(Debug)]
/// 比较按下与释放的选择结果，只有同一目标才能继续点击分发。
// Prepare 生成的驱动先执行两次 selector，最后调用此比较器；对象相等比较的是实际 Mount 身份。
struct SameTarget;
impl NativeCallable for SameTarget {
/// 接收按下与释放两次命中选择的结果。
@@ -49,6 +51,7 @@ impl NativeCallable for SameTarget {
}
}
/// 构造只读命中选择驱动所需的托管代码与函数对象。
// selector 和 Prepare 共用代码工厂；传入常量形成托管引用边，保持协议函数、实参和中间驱动存活。
fn code(
cx: &mut NativeContext<'_>,
instructions: Vec<Instruction>,
@@ -61,22 +64,27 @@ fn code(
"<tessera>",
1,
);
// 先把校验后的字节码分配到当前 NativeContext，输出函数经托管引用拥有它及其常量。
let code = cx.allocate(EndorCodeObject::new(code))?;
// 驱动只读取显式常量和局部槽，空 globals 使它不依赖或修改业务脚本全局变量。
let globals = cx.new_dict()?;
cx.new_function("pointer hitTest", code, globals)
}
/// 按逆绘制顺序构造候选 hitTest 调用，先进行几何与局部坐标筛选。
// Prepare 分别为 press/release 构造选择器；准备阶段做原生粗筛，执行阶段才调用真实 hitTest 方法。
fn selector(
cx: &mut NativeContext<'_>,
candidates: &[WeakObjectRef],
point: [f32; 2],
desktop: ObjectRef,
) -> Result<ObjectRef, VmError> {
// 所有候选共享一个 Bool 验证器，放常量槽 0，避免每个候选重复创建适配器。
let validate = cx.allocate(ContextNativeFunction::new(
"validate hitTest",
Boolean,
vec![],
))?;
// 可变指令和常量池按候选依次追加；前面候选返回 true 即提前 ReturnValue，剩余候选不会执行。
let mut instructions = Vec::new();
let mut constants = vec![Value::Object(validate)];
// 候选按绘制顺序提供，逆序使最上层先参与测试；弱引用失效视为过期输入错误。
@@ -84,6 +92,7 @@ fn selector(
let mount = cx
.upgrade(*weak)?
.ok_or(VmError::InvalidArgument("pointer Mount expired"))?;
// 克隆 Mount 描述以便后面分配源 Point；不持有跨 NativeContext 分配的 store 借用。
let target = cx.store().payload::<Mount>(mount, "Mount")?.clone();
// 先排除已卸载、非交互和几何不命中的出现，避免为明显无效候选构造源调用。
if !target.mounted
@@ -94,6 +103,7 @@ fn selector(
{
continue;
}
// 几何是本次出现的布局与投影快照，同一 Block 的其他 Mount 不能共享这里的局部坐标。
let geometry = &target.geometry;
let point = crate::geometry::Point::new(point[0], point[1]);
// 把投影坐标反算到节点逻辑空间；不可逆/无效投影没有可用于 hitTest 的局部坐标。
@@ -103,6 +113,7 @@ fn selector(
// 源 Point 以节点左上为原点；这里再次验证范围，避免变换后的点落到节点盒子之外。
let x = point.x - geometry.x;
let y = point.y - geometry.y;
// 经过逻辑逆变换后再按本地盒检查，源 hitTest 不接收明显超出该出现范围的点。
if x < 0.0 || y < 0.0 || x > geometry.width || y > geometry.height {
continue;
}
@@ -111,15 +122,18 @@ fn selector(
.store()
.type_of(target.block)?
.ok_or(VmError::InvalidArgument("untyped hit target"))?;
// 方法按实际名义类型查找，既可命中原生默认实现，也可执行源覆盖。
let function = cx
.store()
.lookup_method(definition, "hitTest")?
.ok_or(VmError::InvalidArgument("missing hitTest method"))?;
// 为本次候选分配本桌面的 Point，先写 x/y 再加入常量池，辅助代码用它作为第三实参。
let local = cx.new_object()?;
attach_desktop_type(cx, local, "Point", desktop)?;
cx.set_attr(local, "x", Value::Number((x as f64).into()))?;
cx.set_attr(local, "y", Value::Number((y as f64).into()))?;
// 每个候选占四个常量：协议函数、Block、Mount、局部 Point；索引供下面字节码复用。
// 记录当前候选四个常量的基址；start+2 是最终返回的 Mount，不能误返回共享 Block。
let start = constants.len() as u32;
constants.extend([
Value::Object(function),
@@ -129,6 +143,7 @@ fn selector(
]);
// false 分支只跳过“加载本 Mount 并返回”两条指令。按编码宽度计算，
// 常量索引大到需要扩展操作数时仍能跳到下一候选。
// 跳转偏移以两字节指令单元计，因此编码字节长度除以 2；扩展操作数的长度也计入。
let skip = (Instruction::encode_all(&[
Instruction::new(Opcode::LoadConst, start + 2),
Instruction::simple(Opcode::ReturnValue),
@@ -153,6 +168,7 @@ fn selector(
]);
}
// 所有候选均未命中时显式返回 Nil；不会把最后一个 false 当作选择结果。
// 末尾追加独立 Nil 常量，零候选或全部返回 false 都走同一个无命中返回路径。
let end = constants.len() as u32;
constants.push(Value::Nil);
instructions.extend([
@@ -164,7 +180,9 @@ fn selector(
#[derive(Debug)]
/// 在一个只读调用中准备两次指针选择所需的候选与局部坐标。
struct Prepare {
// 候选来自已提交帧的交互出现，按绘制顺序排列，构造选择器时才逐项升级。
candidates: Vec<WeakObjectRef>,
// 按下与释放点都位于输入投影空间，各自独立做逆变换和协议命中，而非仅比较粗命中矩形。
press: [f32; 2],
release: [f32; 2],
desktop: ObjectRef,
@@ -179,7 +197,9 @@ impl NativeCallable for Prepare {
fn invoke(&self, cx: &mut NativeContext<'_>, _: &[Value]) -> Result<NativeResult, VmError> {
// 按下和释放分别构造选择器，但都在本次只读执行内调用，使用同一预算域。
let down = selector(cx, &self.candidates, self.press, self.desktop)?;
// 释放点重用同一候选序列；按下 selector 的最终结果只在执行期出现，准备时不提前猜测目标。
let up = selector(cx, &self.candidates, self.release, self.desktop)?;
// 分配比较器无须捕获业务根；真正待比较的 Mount 由驱动局部槽及实参保持生命周期。
let compare = cx.allocate(ContextNativeFunction::new(
"same pointer target",
SameTarget,
@@ -202,6 +222,7 @@ impl NativeCallable for Prepare {
Instruction::new(Opcode::Call, 2),
Instruction::simple(Opcode::ReturnValue),
];
// 为两个选择结果显式声明局部槽，常量顺序与上面的 LoadConst 0/1/2 对应。
let driver = code(
cx,
instructions,
@@ -224,6 +245,7 @@ impl NativeCallable for Prepare {
}
/// Returned Mount owns one root. No-hit and mismatched targets return None.
/// 在一次有界只读调用中分别选择按下与释放目标；仅二者为同一 Mount 时返回其拥有根。
// ui_bridge 的点击分发路径调用，成功的 Some 根由调用方使用后释放；本函数不直接派发业务 click。
pub fn resolve(
vm: &mut Vm,
desktop: ObjectRef,
@@ -242,6 +264,7 @@ pub fn resolve(
},
vec![desktop],
))?;
// 同步执行整个准备、两次命中及比较过程，共享总帧深/指令预算；不把未完成续体交给输入调用方。
let result = vm.call_read_only_with_limits(
prepare,
&[],
@@ -252,7 +275,9 @@ pub fn resolve(
);
// 先保存调用结果再释放入口根，因此 VM 返回错误时也能完成入口清理。
vm.release(prepare)?;
// 只取选择值，丢弃只读依赖集合；一次性输入命中不建立绘制或布局的持久失效依赖。
let (value, _) = result.map_err(|error| crate::endor_host::runtime_error(vm, error))?;
// 接受 Mount 或 Nil 两类驱动结果，其他值先释放其可能拥有根，再报告内部协议错误。
match value {
// 成功返回的 Mount 仍拥有一次根引用，交由调用方使用并释放；None 不转移任何对象根。
Value::Object(mount) => Ok(Some(mount)),