From 7217bbde970eadbcf910899c77d0254de488d3cd Mon Sep 17 00:00:00 2001 From: Codex Bot Date: Mon, 23 Nov 2026 02:55:07 +0800 Subject: [PATCH] Extract the Nexus runtime from Tessera --- Cargo.lock | 11 + Cargo.toml | 2 + README.md | 11 + docs/architecture/README.md | 4 + docs/architecture/file-map.md | 10 +- docs/architecture/nexus-extraction.md | 69 + docs/code-comments.md | 10 +- src/README.md | 13 +- src/bridge/graphics.rs | 2 +- src/bridge/mod.rs | 3 + src/bridge/nexus_host.rs | 24 + src/main.rs | 4 +- src/runtime/endor_host.rs | 724 ++-------- src/runtime/endor_host/tests.rs | 406 +++--- src/runtime/mod.rs | 11 +- src/runtime/tasks.rs | 1226 +--------------- src/runtime/vm_sequence.rs | 243 +--- vendor/README.md | 1 + vendor/nexus/.gitignore | 1 + vendor/nexus/Cargo.lock | 220 +++ vendor/nexus/Cargo.toml | 16 + vendor/nexus/README.md | 13 + vendor/nexus/src/budget.rs | 43 + vendor/nexus/src/console.rs | 280 ++++ {src/runtime => vendor/nexus/src}/io_tasks.rs | 2 +- vendor/nexus/src/lib.rs | 30 + vendor/nexus/src/program.rs | 236 +++ vendor/nexus/src/session.rs | 157 ++ .../nexus/src/source.rs | 23 +- vendor/nexus/src/tasks.rs | 1259 +++++++++++++++++ vendor/nexus/src/vm_sequence.rs | 249 ++++ vendor/nexus/tests/console.rs | 128 ++ vendor/nexus/tests/history.rs | 117 ++ vendor/nexus/tests/host_registration.rs | 170 +++ vendor/nexus/tests/program.rs | 193 +++ vendor/nexus/tests/tasks.rs | 243 ++++ 36 files changed, 3973 insertions(+), 2181 deletions(-) create mode 100644 docs/architecture/nexus-extraction.md create mode 100644 src/bridge/nexus_host.rs create mode 100644 vendor/nexus/.gitignore create mode 100644 vendor/nexus/Cargo.lock create mode 100644 vendor/nexus/Cargo.toml create mode 100644 vendor/nexus/README.md create mode 100644 vendor/nexus/src/budget.rs create mode 100644 vendor/nexus/src/console.rs rename {src/runtime => vendor/nexus/src}/io_tasks.rs (99%) create mode 100644 vendor/nexus/src/lib.rs create mode 100644 vendor/nexus/src/program.rs create mode 100644 vendor/nexus/src/session.rs rename src/runtime/endor_script.rs => vendor/nexus/src/source.rs (91%) create mode 100644 vendor/nexus/src/tasks.rs create mode 100644 vendor/nexus/src/vm_sequence.rs create mode 100644 vendor/nexus/tests/console.rs create mode 100644 vendor/nexus/tests/history.rs create mode 100644 vendor/nexus/tests/host_registration.rs create mode 100644 vendor/nexus/tests/program.rs create mode 100644 vendor/nexus/tests/tasks.rs diff --git a/Cargo.lock b/Cargo.lock index 74b33c5..9e01c7d 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -433,6 +433,16 @@ version = "0.8.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "edf234dd1594d6dd434a8fb8cada51ddbbc593e40e4a01556a0b31c62da2775b" +[[package]] +name = "endorphin-nexus-runtime" +version = "0.1.0" +dependencies = [ + "anyhow", + "compiler", + "core", + "frontend", +] + [[package]] name = "equivalent" version = "1.0.2" @@ -1775,6 +1785,7 @@ dependencies = [ "compiler", "core", "cosmic-text", + "endorphin-nexus-runtime", "frontend", "objc2 0.5.2", "objc2-app-kit", diff --git a/Cargo.toml b/Cargo.toml index f2301c4..c1224e3 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -12,6 +12,8 @@ license = "MIT OR Apache-2.0" [dependencies] # 应用边界的错误聚合与上下文,保留底层失败原因。 anyhow = "1.0" +# 本地通用运行时库,由 Tessera 注册 UI 能力,暂不建立 Nexus 独立远程仓库。 +nexus = { package = "endorphin-nexus-runtime", path = "vendor/nexus" } # Aster 字节码编译器,把前端结果交给同一套 VM 执行。 compiler = { path = "vendor/aster/crates/compiler" } # 系统字体发现、塑形与换行,用于测量和软件文字绘制。 diff --git a/README.md b/README.md index 75929bd..1facfba 100644 --- a/README.md +++ b/README.md @@ -22,6 +22,17 @@ experimental `namespace` / `export scene` / `render` parser has been removed. Host UI integration lives in Tessera; Aster needs no Tessera-specific changes. Lyra CLI and Hestia Server are independent hosts and are not application dependencies. +### Local Nexus extraction + +The execution core now lives in the local Rust library [Nexus](vendor/nexus/README.md): +Tessera → Nexus → Aster, in the same GUI process. Tessera registers UI capabilities +through host interfaces. `vendor/nexus` is an ordinary local source directory, +with no independent Git history or remote repository yet. See the +[extraction boundaries and validation status](docs/architecture/nexus-extraction.md). +Local verification passed: Nexus tests and Clippy, Tessera tests (190 passed; one +optional performance benchmark ignored) and Clippy, and Aster's complete check script. +HTTP tests require loopback-listener access and passed when rerun outside the restricted sandbox. + ## Endor manuscript example [illustrated-manuscript.endor](examples/illustrated-manuscript.endor) implements diff --git a/docs/architecture/README.md b/docs/architecture/README.md index f083503..6a0c954 100644 --- a/docs/architecture/README.md +++ b/docs/architecture/README.md @@ -23,6 +23,10 @@ UML 已渲染为普通 PNG 图片,直接嵌入各篇说明,不依赖 Mermaid [放大组件图 SVG](uml/rendered/components.svg) +## 本地 Nexus 抽取 + +通用运行时现已在 `vendor/nexus` 作为 GUI 进程内 library 接入,宿主能力经接口注册。当前实现、仍属于 Tessera 的 worker/窗口发布适配,以及未执行的编译/运行回归见 [Nexus 抽取边界](nexus-extraction.md)。本页原有五目录说明和 UML 记录此前 Tessera 内部整理,新增边界以该抽取文档为准。 + ## 先抓住四个概念 1. **对象是程序状态**:共享内容留在 Aster 管理的对象堆内;切换标签不靠重放源码恢复对象。 diff --git a/docs/architecture/file-map.md b/docs/architecture/file-map.md index a08633e..4343998 100644 --- a/docs/architecture/file-map.md +++ b/docs/architecture/file-map.md @@ -25,9 +25,9 @@ | `src/system_ui/mod.rs` | [src/shell/system_ui/mod.rs](../../src/shell/system_ui/mod.rs) | 管理控件模块导出 | | `src/system_ui/theme.rs` | [src/shell/system_ui/theme.rs](../../src/shell/system_ui/theme.rs) | 管理表面颜色和主题 | | `src/system_ui/widgets.rs` | [src/shell/system_ui/widgets.rs](../../src/shell/system_ui/widgets.rs) | 宿主可复用控件绘制 | -| `src/tabs.rs` | [src/shell/tabs.rs](../../src/shell/tabs.rs) | 共享标签绘制/命中、密集布局、滚动、拖放及动画 | -| `src/tabs/hover.rs` | [src/shell/tabs/hover.rs](../../src/shell/tabs/hover.rs) | 标签、关闭和加号的颜色过渡 | -| `src/tabs/motion.rs` | [src/shell/tabs/motion.rs](../../src/shell/tabs/motion.rs) | 标签布局动画及 hover 重绘期限 | +| `src/tabs.rs` | [src/shell/tabs.rs](../../src/shell/tabs.rs) | 当前保留页面标签的不可变 ID/标题/选中状态投影;导航由 sidebar 绘制 | +| `src/tabs/hover.rs` | 已删除 | 当前没有独立的旧标签 hover 动画模块 | +| `src/tabs/motion.rs` | 已删除 | 当前没有独立的旧标签布局动画模块 | ## runtime @@ -37,10 +37,10 @@ | `src/api/tests.rs` | [src/runtime/api/tests.rs](../../src/runtime/api/tests.rs) | 保留原 API 测试;只调整嵌入示例路径,不执行测试 | | `src/endor_host.rs` | [src/runtime/endor_host.rs](../../src/runtime/endor_host.rs) | 候选/活跃 VM、编译执行、增量刷新、清理和诊断 | | `src/endor_host/tests.rs` | [src/runtime/endor_host/tests.rs](../../src/runtime/endor_host/tests.rs) | 保留原宿主测试;只调整嵌入示例路径,不执行测试 | -| `src/endor_script.rs` | [src/runtime/endor_script.rs](../../src/runtime/endor_script.rs) | 组织 Aster Script/Module 输入及原始源码范围 | +| `src/endor_script.rs` | [vendor/nexus/src/source.rs](../../vendor/nexus/src/source.rs) | 组织 Aster Script/Module 输入及原始源码范围 | | `src/event_dispatch.rs` | [src/runtime/event_dispatch.rs](../../src/runtime/event_dispatch.rs) | 托管事件、订阅和 capture/target/bubble 分发 | | `src/events.rs` | [src/runtime/events.rs](../../src/runtime/events.rs) | 原生输入的有界 loopback 传输 | -| `src/io_tasks.rs` | [src/runtime/io_tasks.rs](../../src/runtime/io_tasks.rs) | 有界文件/HTTP provider、纯数据完成消息和取消 | +| `src/io_tasks.rs` | [vendor/nexus/src/io_tasks.rs](../../vendor/nexus/src/io_tasks.rs) | 有界文件/HTTP provider、纯数据完成消息和取消 | | `src/tasks.rs` | [src/runtime/tasks.rs](../../src/runtime/tasks.rs) | 托管 Task、owner/key 取消和协作任务调度 | | `src/vm_sequence.rs` | [src/runtime/vm_sequence.rs](../../src/runtime/vm_sequence.rs) | 共享 VM 调用序列及同帧迭代驱动 | diff --git a/docs/architecture/nexus-extraction.md b/docs/architecture/nexus-extraction.md new file mode 100644 index 0000000..1c70a47 --- /dev/null +++ b/docs/architecture/nexus-extraction.md @@ -0,0 +1,69 @@ +# Nexus 本地抽取边界 + +目标依赖为 **Tessera → Nexus → Aster**。Nexus 是 GUI 进程内 Rust library,不是另起进程;Tessera 的 bridge 仍可显式使用同一版本的 Aster 类型。Tessera 通过 `HostRegistration` 向 Nexus 的 owning VM 注册 UI 能力,Nexus 不导入 Tessera 模块。 + +本地库暂放 `vendor/nexus`,包名 `endorphin-nexus-runtime`。它是普通源码目录,没有独立 Git 或远程仓库。后续是否建仓、所有者和可见性需用户另行授权。迁移在 Tessera 的独立工作分支上提交。 + +当前 Tessera 适配分支为 `codex/nexus-runtime`,从注释交付 `6d1ffdb` 建立,依赖 Tessera PR #10 与其引用的 Aster PR #3。经 Gitea 当前状态核对,两个注释 PR 均已合并;本次没有执行 PR 合并或向 main 推送。 + +## 已抽取 + +| 原实现 | Nexus 实现 | Tessera 保留的适配 | +| --- | --- | --- | +| `runtime/endor_script.rs` | `source.rs` | 调用方直接引用 Nexus;原 GUI 转发模块及无用别名已删除 | +| `runtime/io_tasks.rs` | `io_tasks.rs` | 任务引擎直接使用 Nexus provider;原 GUI 转发模块及无用别名已删除 | +| `runtime/vm_sequence.rs` | `vm_sequence.rs` | `FunctionHost` 适配桌面 Function 名义身份及 `` 诊断来源 | +| `endor_host::Candidate` 与错误映射 | `VmSession`、`runtime_error` | UI 会话借用同一 Aster VM,视觉刷新状态仍由 Tessera 持有 | +| AST 预算、计划编译与 `evaluate` | `budget.rs`、`program.rs` | UI 编译前显式提供宿主全局名;隔离表达式不安装 UI | +| `runtime/tasks.rs` 通用任务引擎 | `tasks.rs` | `TaskHost` 适配 owner 作用域、展示资格和 Task 类型;原 install/cancel_owner 签名保持不变 | +| Console 计数、原文历史和来源 | `ConsoleHistory`、`AcceptedInput`;共享 `source::line_starts` | Tessera 只读历史建立 Sources 投影;接受凭据消费一次后进入真实 VM | +| 完整程序准备与顶层执行 | `PreparedProgram`、`VmSession::execute_program` | 显式提供宿主名称,`main` 查找/调用与页面策略仍由 Tessera 决定;保留 Session/Execution 两种代码根生命周期 | +| 宿主调用返回值清理 | `VmSession::with_call_result` | 在回调内解释返回值,刷新/展示返回错误也归还返回根 | +| Console 输入准备与执行循环 | `console.rs` 的 `PreparedInput`、`VmSession::prepare_input/execute_input` | 先完整编译,再保留宿主清理、输入记录、代码投影、刷新、错误标注及发布的原次序 | +| 新会话 UI 安装 | `HostRegistration` 调用协议 | `bridge/nexus_host.rs` 实现注册,领域类型/窗口能力仍由 Tessera 定义 | + +搬移保留原有源码位置、预算值、指令顺序、根清理次序、I/O 线程池/租约与诊断文本。Cargo 使用相邻同一份 `vendor/aster`,不引入注册表的第二套语言实现。锁文件只新增本地包及其引用,没有升级已有依赖。 + +## Tessera 保留的宿主边界 + +| 模块 | 保留原因 | Nexus 接口 | +| --- | --- | --- | +| `runtime/api.rs` 与 `api/worker.rs` | 有界 HTTP/原生请求、回应端、submission/namespace、文档/窗口命令的一致发布;worker 线程组合这些宿主协议 | 通过 `endor_host` 使用 Nexus 会话,原子执行后只继续 UI 刷新;不另建通用语言队列 | +| `runtime/api/guide.rs` | Tessera 的在线路由和 UI API 文档 | 不属于运行时内核 | +| `runtime/events.rs` | 窗口/会话/布局版本/Mount 信封、原生手势合并和版本追随 | 不跨线程传递 VM 根 | +| `runtime/event_dispatch.rs` | capture/target/bubble、Event/Subscription 和 Mount 路由等 UI 协议 | 复用 Nexus 调用序列,不另写解释器 | +| `runtime/endor_host.rs` | UI 入口策略、代码树、布局/绘制续体、故障画面、文档和窗口生命周期 | 完整准备、输入历史、执行与 VM 根清理由 Nexus 负责;宿主经显式访问接口接入 | +| `runtime/tasks.rs`、`vm_sequence.rs` | UI owner 的有效性和名义类型附着 | `TaskHost`、`FunctionHost` | + +`api/worker.rs` 不直接使用 VM、代码模板装载或指令执行接口;其继续状态携带的是 Tessera 请求、UI 刷新元数据或独立候选。请求队列的容量、关闭优先级和发布复核继续在 Tessera,Nexus 不依赖 `tiny_http`、`winit`、NamespaceState 或窗口输入结构。 + +`ConsoleHistory` 统一持有累计次数、AST 总量、原文和输入来源;Sources 的 CodeNode 与发布文档仍由 Tessera 生成。接受凭据拥有准备结果,只能借用它生成投影并消费执行;输入失败后的历史和预算不回滚。原文本追加和 CRLF/CR 字节行索引在字段访问替换后与原实现逐 token 等价。宿主开始执行前的纯历史记录和原程序 CodeNode 转移现为两个相邻步骤,不改变业务执行或发布顺序。 + +## 交付边界 + +Tessera 的适配改动与 Nexus 源码一并保存在 `codex/nexus-runtime` 分支。Nexus 作为 Tessera 仓库内的 Rust 库交付。 + +源码复核中记录的既有行为问题保留为后续独立工作,不在本次迁移中夹带效果分析或 Scene3D 依赖算法改动。本次不声称所有潜在行为问题均已解决。 + +## 验证状态 + +源码分段和 I/O 按完整实现搬移;驱动引入宿主函数类型适配。任务引擎的 owner/key、协程、await、配额和取消顺序保留;三个 UI 策略函数逐 token 对照未变,通用引擎在还原显式宿主接口替换后逐 token 等价。`TaskHost` 不可藏有未 trace 的托管句柄,原生函数通过 captures 保活注册域;Scheduler 仅借用该域,宿主必须在释放域前停止使用调度器。为兼容现有诊断,任务 payload 的 `tessera-task` 类别文本暂保持原值。 + +持久执行循环、显示值转换和真实全局名称枚举在调整候选/输入字段访问后逐 token 等价。`PreparedInput` 私有字段保持原文、AST 与模板同源,消费后不能由该对象重复执行;它不携带 VM 根。模板也不携带目标堆根,提前在执行返回时释放编译准备数据不会释放已加载的代码/函数身份。宿主在准备和执行之间不得另行改动全局名称契约。库入口另外检查输入字节数,未初始化环境返回错误,累计预算使用饱和加法以拒绝异常大的外部计数。 + +完整程序的两种执行循环在代入代码根策略后分别与原路径逐 token 等价,宿主全局名称集合不变。`with_call_result` 额外修复宿主刷新/展示返回错误时可能跳过 main 返回根释放的路径;这项清理加强单独由析构可观察的回归覆盖,不作为纯搬移宣称等价。GUI 改用显式会话访问接口的前后整文件 token 对照,在还原 accessor 和十处回收闭包后通过。 + +原同帧循环回归随实现进入 Nexus;新增无 UI 宿主测试覆盖注册、部分安装失败的资源清理、脚本跨片全局和原文跨度。另有 `tests/tasks.rs` 使用普通对象宿主覆盖同 key 替换、真实回调次数、资格撤销、终态作用域清理和退出门闩。`tests/console.rs` 覆盖持久全局/函数身份、编译失败无副作用、运行失败保留先前写入和预算拒绝。`tests/program.rs` 覆盖两种代码根策略、装载不隐式调用入口、失败写入和宿主错误返回根清理。`tests/history.rs` 覆盖接受/失败历史、256 次输入、累计 AST、完整源码字节预算及 Unicode/CRLF/CR 位置。 + +2026-11-15 用户明确授权本次本机编译和测试,已执行: + +| 检查 | 结果 | +| --- | --- | +| Nexus `cargo test --offline --manifest-path vendor/nexus/Cargo.toml` | 14 个集成测试、1 个单元测试通过 | +| Nexus `cargo clippy --offline --manifest-path vendor/nexus/Cargo.toml --all-targets -- -D warnings` | 通过 | +| Tessera `cargo test --offline --locked` | 179 通过、11 个 HTTP 用例受沙箱端口权限限制失败、1 个可选基准忽略 | +| Tessera HTTP 组允许回环网络后重跑 | 16/16 通过;与首轮合并覆盖全部 190 个常规测试 | +| Tessera `cargo clippy --offline --locked --all-targets -- -D warnings` | 通过 | +| Aster `CARGO_NET_OFFLINE=true sh scripts/check.sh` | 生成器一致性、4 个 Python 回归、Rust/PEG 格式、workspace 测试/文档测试及全部目标 Clippy 均通过 | + +首次联网依赖解析因 DNS 失败,随后使用本机缓存完成离线编译。Tessera 首次测试编译发现测试转发器缺少显式 `VmError` 导入,补齐后编译和回归通过。实际执行结果不包含手动操作原生 GUI、可选性能基准或分发打包;示例、绘制像素、任务、窗口和输入协议由现有集成回归覆盖。 diff --git a/docs/code-comments.md b/docs/code-comments.md index 5572e5a..df69d66 100644 --- a/docs/code-comments.md +++ b/docs/code-comments.md @@ -10,7 +10,7 @@ 4. [桥接层](../src/bridge/ui_bridge.rs)、[Block](../src/model/block.rs) 与 [Mount](../src/model/mount.rs):区分共享业务对象、每次出现和展示事务。 5. [快照](../src/model/snapshot.rs)、[源布局](../src/render/source_layout.rs) 和 [源绘制](../src/render/source_paint.rs):理解依赖缓存、只读执行及挂起工作。 6. [二维视口](../src/render/viewport.rs)、[3D](../src/render/scene3d.rs) 和 [面板映射](../src/render/scene3d/panel.rs):理解布局/世界/视图的边界。 -7. [任务](../src/runtime/tasks.rs)、[provider](../src/runtime/io_tasks.rs) 和 [事件传播](../src/runtime/event_dispatch.rs):理解异步交付资格与生命周期。 +7. [任务](../src/runtime/tasks.rs)、[provider](../vendor/nexus/src/io_tasks.rs) 和 [事件传播](../src/runtime/event_dispatch.rs):理解异步交付资格与生命周期。 ## 阅读时需要保留的边界 @@ -74,10 +74,10 @@ | [src/runtime/api/worker.rs](../src/runtime/api/worker.rs) | 唯一串行执行 VM 的 API worker。保留活跃运行时,另建 PUT 候选,并在候选完整成功后切换发布。 | | [src/runtime/endor_host.rs](../src/runtime/endor_host.rs) | 把 Aster 编译/执行与 Tessera 展示生命周期连接起来。Candidate 拥有 VM 与宿主根,ReplSession 保留实际运行中的全局环境。 | | [src/runtime/endor_host/tests.rs](../src/runtime/endor_host/tests.rs) | 说明全部运行时测试和辅助函数的场景/断言,并解释新主线性能基准的 DPI 分组、预热、三类计时边界和统计方式。 | -| [src/runtime/endor_script.rs](../src/runtime/endor_script.rs) | 区分完整 Module 与顶层 Script,并保留输入源码位置。 | +| [vendor/nexus/src/source.rs](../vendor/nexus/src/source.rs) | 区分完整 Module 与顶层 Script,并保留输入源码位置。 | | [src/runtime/event_dispatch.rs](../src/runtime/event_dispatch.rs) | 托管事件与订阅的传播实现。Connection 持有回调引用,Event 保存目标、阶段与停止传播状态。 | | [src/runtime/events.rs](../src/runtime/events.rs) | 原生窗口输入到执行 worker 的纯数据传输。Input 只含窗口/会话/版本/Mount 身份及有限坐标。 | -| [src/runtime/io_tasks.rs](../src/runtime/io_tasks.rs) | 后台文件/网络 provider。线程池只携带纯数据、取消控制与弱 Task 身份,不持有 VM。 | +| [vendor/nexus/src/io_tasks.rs](../vendor/nexus/src/io_tasks.rs) | 后台文件/网络 provider。线程池只携带纯数据、取消控制与弱 Task 身份,不持有 VM。 | | [src/runtime/mod.rs](../src/runtime/mod.rs) | 运行时模块入口。VM 生命周期、API、源程序组织、事件与异步任务在这里组合。 | | [src/runtime/tasks.rs](../src/runtime/tasks.rs) | owner/key 管理的异步任务与协作式源函数调度。弱索引用于查找,回调、等待对象和协程帧是托管图中的真实边。 | | [src/runtime/vm_sequence.rs](../src/runtime/vm_sequence.rs) | 构造共享 VM 调用序列与同帧循环驱动的字节码。 | @@ -171,3 +171,7 @@ - 对工具脚本使用 `node --check` 和 `sh -n`,只检查语法,不执行渲染、构建或打包;Cargo 配置另以 TOML 解析核对。 - 检查固定行号的示例夹具、测试依赖的源码替换片段和 `git diff --check`。这些检查能证明注释外代码保持一致及语法可解析,不能替代运行时回归结果。 - 本次未执行编译、GUI 回归、Clippy 或 rustdoc;需要构建的验证应在用户已确认的远程 runner 上运行,不能把未执行步骤写成通过。实际交付结果记录在 PR 中。 + +## Nexus 本地抽取后的注释入口 + +通用实现与调用关系已转到 [Nexus 源码导航](../vendor/nexus/README.md):`source`、`program`、`console`、`session`、`budget`、`tasks`、`io_tasks` 和 `vm_sequence`。Tessera 保留 UI 宿主策略及刷新/发布。原 `runtime/endor_script.rs`、`runtime/io_tasks.rs` 转发入口已删除;迁移细节与待运行的回归见 [抽取边界](architecture/nexus-extraction.md)。 diff --git a/src/README.md b/src/README.md index 7a50acd..5ad5dc0 100644 --- a/src/README.md +++ b/src/README.md @@ -9,11 +9,13 @@ | 目录 | 责任 | | --- | --- | | `shell/` | 原生工作区、窗口输入、标签、开发工具和独立宿主管理控件 | -| `runtime/` | 本机 API、串行 VM 执行、事件和异步任务 | +| `runtime/` | Tessera 运行时适配:本机 API/worker、UI 输入与发布;通用执行由 Nexus 提供 | | `model/` | 托管对象、绑定、Mount、窗口语义、依赖与发布值 | | `render/` | 几何、布局、source/native 视觉协议、绘制、命中、字体和软件渲染 | | `bridge/` | Endor 类型/方法与宿主能力及展示刷新之间的连接 | +通用源码、编译、Console 历史/预算、VM 根、任务和驱动实现见 [本地 Nexus](../vendor/nexus/README.md);[抽取边界](../docs/architecture/nexus-extraction.md)区分实现接入与尚未执行的编译/回归。 + ## shell | 模块 | 职责 | @@ -33,13 +35,11 @@ | 模块 | 职责 | | --- | --- | | [api](runtime/api.rs) | HTTP 请求路由、队列、请求观察和响应;worker/指南拆为子模块 | -| [endor_host](runtime/endor_host.rs) | 候选/活跃 VM、编译执行、增量刷新、清理和诊断 | -| [endor_script](runtime/endor_script.rs) | 组织 Aster Script/Module 输入及原始源码范围 | +| [endor_host](runtime/endor_host.rs) | 组合 Nexus 会话与 Tessera UI 桥接,维护代码投影、增量刷新和发布 | | [events](runtime/events.rs) | 原生输入的有界 loopback 传输 | | [event_dispatch](runtime/event_dispatch.rs) | 托管事件、订阅和 capture/target/bubble 分发 | -| [io_tasks](runtime/io_tasks.rs) | 有界文件/HTTP provider、纯数据完成消息和取消 | -| [tasks](runtime/tasks.rs) | 托管 Task、owner/key 取消和协作任务调度 | -| [vm_sequence](runtime/vm_sequence.rs) | 共享 VM 调用序列及同帧迭代驱动 | +| [tasks](runtime/tasks.rs) | 为 Nexus 任务引擎提供 UI owner 作用域、窗口/页面资格和 Task 类型 | +| [vm_sequence](runtime/vm_sequence.rs) | 为 Nexus 的共享调用驱动附着 Tessera Function 名义类型 | ## model @@ -76,6 +76,7 @@ | 模块 | 职责 | | --- | --- | +| [nexus_host](bridge/nexus_host.rs) | 向 Nexus 的真实 VM 注册 UI 领域类型与全局能力 | | [ui_bridge](bridge/ui_bridge.rs) | Endor 宿主类型、窗口展示会话、布局/绘制发布协调 | ## 主要入口和运行约束 diff --git a/src/bridge/graphics.rs b/src/bridge/graphics.rs index d6f9c0d..bb2d1b8 100644 --- a/src/bridge/graphics.rs +++ b/src/bridge/graphics.rs @@ -319,7 +319,7 @@ impl NativeCallable for Function { Value::Object(resource) } ReadText => { - // 同步读取小型资源文本供模型初始化使用;后台异步读取仍走 runtime/io_tasks 的接口。 + // 同步读取小型资源文本供模型初始化使用;后台异步读取由 Nexus io_tasks 的 provider 和任务引擎处理。 if cx.store().is_read_only() { return Err(invalid("load resources outside paint/layout")); } diff --git a/src/bridge/mod.rs b/src/bridge/mod.rs index 518145c..7b7f4e5 100644 --- a/src/bridge/mod.rs +++ b/src/bridge/mod.rs @@ -8,3 +8,6 @@ pub(crate) mod ui_bridge; /// 注册图片、字体、文字流与避让形状能力,并把托管绘制参数解码为可跨线程使用的不可变资源。 /// ui_bridge 安装时调用注册入口,source_paint 解码 image 命令时复用图像检查。 pub(crate) mod graphics; + +/// 实现 Nexus 宿主注册协议,把 Tessera UI 类型与全局能力安装到同一 VM。 +pub(crate) mod nexus_host; diff --git a/src/bridge/nexus_host.rs b/src/bridge/nexus_host.rs new file mode 100644 index 0000000..54e2007 --- /dev/null +++ b/src/bridge/nexus_host.rs @@ -0,0 +1,24 @@ +//! Tessera 向 Nexus 注册 UI 能力的唯一生产安装适配器;Nexus 不引用本模块或 UiBridge。 +use anyhow::Result; +use endor_core::{ObjectRef, Vm}; + +/// 每个新会话安装一份 UI 类型/方法域,实际根交给 Nexus 会话统一持有和清理。 +pub(crate) struct UiHost; + +impl nexus::HostRegistration for UiHost { + type Installed = super::ui_bridge::UiBridge; + + /// Nexus 在已建立 globals 的 owning VM 上调用;失败由会话 Drop 清理半完成安装根。 + fn register( + &self, + vm: &mut Vm, + roots: &mut Vec, + globals: ObjectRef, + ) -> Result { + // 类型、原生方法、任务域仍由 Tessera 定义,不把其 UI 规则移入通用库。 + let bridge = super::ui_bridge::install(vm, roots)?; + // 全局别名引用刚安装的同一批名义对象,不为每条脚本重新创建类型域。 + bridge.install_globals(vm, globals)?; + Ok(bridge) + } +} diff --git a/src/main.rs b/src/main.rs index 3b6523c..4c4dac7 100644 --- a/src/main.rs +++ b/src/main.rs @@ -21,9 +21,7 @@ pub(crate) use render::{ box_model, display_list, geometry, layout, native_visual, page, scene, scene3d, scroll, software_renderer, source_hit, source_layout, source_paint, text, viewport, }; -pub(crate) use runtime::{ - api, endor_host, endor_script, event_dispatch, events, io_tasks, tasks, vm_sequence, -}; +pub(crate) use runtime::{api, endor_host, event_dispatch, events, tasks, vm_sequence}; #[cfg(target_os = "macos")] pub(crate) use shell::native_chrome; pub(crate) use shell::{ diff --git a/src/runtime/endor_host.rs b/src/runtime/endor_host.rs index be3c12a..4556192 100644 --- a/src/runtime/endor_host.rs +++ b/src/runtime/endor_host.rs @@ -1,39 +1,36 @@ -//! 把 Aster 编译/执行与 Tessera 展示生命周期连接起来。Candidate 拥有 VM 与宿主根,ReplSession 保留实际运行中的全局环境。 +//! 把 Nexus/Aster 执行与 Tessera 展示生命周期连接起来。Candidate 是 Nexus VmSession 的本地别名,拥有 VM 与宿主根。 //! 完整源码 PUT 使用隔离候选;Console 输入则在已有 VM 上执行,先前发生的写入不等于可以回放或事务回滚。 //! 刷新状态机遍历窗口并逐步推进布局/绘制。完成所有必要轮次才形成文档;取消会释放挂起调用并恢复未提交的 Mount。 //! //! api::worker 为完整 PUT 创建 ReplSession 候选,为 Console/事件/resize 调用已有会话;只有该 worker 拥有 VM。 -//! UI 类型与刷新由 bridge 适配;此模块负责源码预算、真实会话、执行结果和挂起刷新的生命周期。 +//! UI 类型与刷新由 bridge 适配;此模块组合 Nexus 的真实会话/输入预算与 UI 执行结果、挂起刷新及发布生命周期。 //! compile/evaluate 是一次性入口,关闭 Candidate 后只返回纯数据;生产持久路径使用增量入口并保存续体。 -//! 本模块仍直接依赖 UI Frame/桥接,不是已经可以独立搬走的通用 Nexus runtime,迁移需先抽出宿主接口。 +//! 通用编译、持久输入准备/执行、VM 根生命周期和结构预算已移至 Nexus;本模块继续适配 UI Frame/桥接与刷新。 //! //! 增量刷新有两层“继续”:ReplSession 保存全窗口 RefreshWork,bridge 保存当前窗口的布局或绘制续体。 //! API worker 下一量子恢复前者,step_refresh 再选择同一窗口恢复后者;两层都不重放已经执行的 Console/事件副作用。 //! 尺寸目标确实变化才由 retarget_refresh 取消当前视觉续体并重启稳定轮;取消派生几何不会撤销已发生的业务写入。 use anyhow::{Result, bail}; -use endor_core::{ExecutionLimits, ObjectRef, Value, Vm, VmError}; +use endor_core::{ExecutionLimits, Value}; use frontend::{ EndorReader, SourceUnit, Span, - ast::{AstRoot, Decl, DeclKind, Expr, ExprKind, Spanned, Stmt, StmtKind, visitor::Visitor}, + ast::{AstRoot, Decl, DeclKind, Expr, ExprKind, Spanned, Stmt, StmtKind}, +}; +pub(crate) use nexus::runtime_error; +pub use nexus::{MAX_SOURCE_BYTES, evaluate}; +use nexus::{ + VmSession as Candidate, + console::ConsoleHistory, + source::{SourcePlan, line_starts}, }; -use std::collections::BTreeSet; use crate::{ document::{CodeNode, RenderDocument}, - endor_script::{self, SourcePlan}, layout, ui_bridge, }; -/// API、完整加载、Console 与 evaluate 共用的原始输入字节预算;不是字符数或 AST 节点数量。 -pub const MAX_SOURCE_BYTES: usize = 1_048_576; -// 每次源执行的硬上限;脚本多片段会分摊指令额度,不能每段重新获得完整额度。 -const LIMITS: ExecutionLimits = ExecutionLimits { - max_frames: 128, - max_instructions: 1_000_000, -}; -// AstBudget 访问者的结构预算,在加载代码前拒绝过大或过深语法树。 -const MAX_AST_NODES: usize = 10_000; -const MAX_AST_DEPTH: usize = 64; +// 源执行预算由 Nexus 默认策略提供;UI 布局/绘制的预算仍由对应 Tessera 工作维护。 +const LIMITS: ExecutionLimits = nexus::DEFAULT_LIMITS; /// 一次性编译/现有 API 检查路径调用,在临时 VM 执行并提取文档,不返回持久可响应事件的 ReplSession。 pub fn compile(source: &str, namespace: &str, submission: u64) -> Result { @@ -43,60 +40,34 @@ pub fn compile(source: &str, namespace: &str, submission: u64) -> Result = (|| { // 同一程序的所有段共享一个 globals,真实引用由 candidate.roots 持有。 - let globals = candidate.vm.new_dict()?; - candidate.globals = Some(globals); - candidate.roots.push(globals); + let globals = candidate.create_globals()?; // 类型安装在执行前完成,全局别名引用同一批名义对象,不在每片脚本重建 UI 类型。 - let bridge = ui_bridge::install(&mut candidate.vm, &mut candidate.roots)?; - bridge.install_globals(&mut candidate.vm, globals)?; - // Script 多段分别执行,指令总额按片段数均分;Module 作为整体获得完整预算,避免每段都重获一百万。 - let limits = match &plan { - SourcePlan::Module(_) => LIMITS, - SourcePlan::Script(_) => ExecutionLimits { - max_instructions: LIMITS.max_instructions / compiled.len().max(1), - ..LIMITS - }, - }; - for template in &compiled { - // 每段加载后有一个代码拥有根,统一登记供候选失败/完成时释放。 - let code = template.load(&mut candidate.vm)?; - candidate.roots.push(code); - // 顶层语句返回值此处不作为默认展示根,脚本应显式 render;返回拥有值需立即释放。 - let value = candidate - .vm - .execute_with_limits(code, globals, limits) - .map_err(|error| runtime_error(&candidate.vm, error))?; - candidate.vm.release_value(value)?; - } - bridge.refresh_bindings(&mut candidate.vm)?; + let bridge = candidate.register_host(&crate::bridge::nexus_host::UiHost)?; + // 一次性路径保留已加载代码根到 close,与原候选清理顺序一致。 + candidate.execute_program(&program, nexus::program::CodeRetention::Session)?; + bridge.refresh_bindings(candidate.vm_mut())?; // 源业务执行后刷新绑定,再依据脚本显式页面或模块 main 返回结果选视觉树。 - let ui_root = match &plan { + let ui_root = match plan { // 脚本没有约定 main 返回值,必须有源 API 安排的页面。 SourcePlan::Script(_) => bridge - .rendered(&candidate.vm)? + .rendered(candidate.vm())? .ok_or_else(|| anyhow::anyhow!("script must call ui.page().render(root)"))?, // 模块先执行定义再调用 main;若 main 未显式 render,可将其返回值转换成展示根。 SourcePlan::Module(_) => { // 从真实全局字典找 main,不能通过 AST 名字存在就假定运行结果也是 callable。 let entry = candidate - .vm + .vm() .dict_get(globals, &Value::Text("main".into()))? .ok_or_else(|| { anyhow::anyhow!("declare main or render a page from a top-level script") @@ -105,22 +76,15 @@ pub fn compile(source: &str, namespace: &str, submission: u64) -> Result Ok(root), - None => ui_bridge::snapshot(&candidate.vm, &value), - }); - // 提取快照结果先暂存,成功或失败都释放 main 返回值的拥有根,再传播快照错误。 - candidate.vm.release_value(value)?; - snapshot? + None => ui_bridge::snapshot(vm, value), + }) + })? } }; // 输出文档只持源码/代码树/不可变视觉与几何,没有 ObjectRef 或可执行 VM 指针。 @@ -143,141 +107,13 @@ pub fn compile(source: &str, namespace: &str, submission: u64) -> Result Result { - if source.len() > MAX_SOURCE_BYTES { - bail!("expression exceeds the 1 MiB limit"); - } - // 独立来源名明确区别于持久 Console transcript,不读取其历史或对象堆。 - let source = EndorReader::from_text("console expression", source); - // 隔离 evaluate 只接受一个表达式,默认编译选项不安装 ui 桥接,也不读已发布程序的 globals。 - let ast = frontend::parse_source_ast(&source, frontend::ParseMode::Expression)?; - AstBudget::default().visit_ast_root(&ast)?; - // 默认全局只有语言内置,不为 evaluate 暗中安装 ui 或活程序用户全局。 - let compiled = compiler::compile_ast(&ast, &source, &compiler::CompileOptions::default()) - .map_err(|error| source.annotate(error))?; - // 独立候选统一持有执行根,表达式失败也由 close 释放整个域。 - let mut candidate = Candidate::new()?; - // 暂存执行/格式化错误,保证外层 close 不因这里的 ? 被跳过。 - let result = (|| { - // 表达式全局环境为空的新字典,不能用运行时 namespace 文档代替真实 globals。 - let globals = candidate.vm.new_dict()?; - candidate.globals = Some(globals); - candidate.roots.push(globals); - // 模板加载到此 VM 后才有真实代码对象,拥有根记入 Candidate。 - let code = compiled.load(&mut candidate.vm)?; - candidate.roots.push(code); - // 一次有界执行产生拥有返回值,字符串化后显式释放。 - let value = candidate - .vm - .execute_with_limits(code, globals, LIMITS) - .map_err(|error| runtime_error(&candidate.vm, error))?; - // 只把标量或对象 repr 字符串交回 API,真实 Value 随一次性 VM 清理,不跨线程交付托管引用。 - let rendered = match &value { - Value::Nil => "nil".to_owned(), - Value::Bool(v) => v.to_string(), - Value::Text(v) => format!("{v:?}"), - Value::Number(v) => v.to_string(), - Value::Object(v) => candidate.vm.repr(*v)?, - }; - candidate.vm.release_value(value)?; - Ok(rendered) - })(); - // 先尝试关闭候选,再合并执行和清理结果,不能只因表达式已有字符串结果就跳过清理。 - let cleanup = candidate.close(); - match (result, cleanup) { - (Ok(value), Ok(())) => Ok(value), - (Err(e), _) | (_, Err(e)) => Err(e), - } -} - -/// compile/prepare_program 调用,建立 UI 宿主全局名集合,再复用增量编译助手生成模板序列。 -fn compile_plan(source: &SourceUnit, plan: &SourcePlan) -> Result> { - compile_plan_with_globals( - source, - plan, - std::iter::once("ui") - .chain(ui_bridge::TYPE_NAMES.iter().copied()) - .chain(ui_bridge::QUERY_NAMES.iter().copied()) - .map(str::to_owned) - .collect(), - ) -} - -/// compile_plan 与 execute_mode 调用,按源序编译 Script 各段,同时支持完整模块和声明前向引用。 -fn compile_plan_with_globals( - source: &SourceUnit, - plan: &SourcePlan, - mut globals: BTreeSet, -) -> Result> { - // 先收集全部函数/类声明名以支持前向引用;普通绑定仍按源码执行次序逐段加入已知全局名。 - for root in plan.roots() { - if let AstRoot::Interactive(input) = root { - // 完整模块的声明可见性由 Aster 自己处理;只有拆成多个交互根时宿主需预收集声明名。 - for statement in &input.statements { - if let StmtKind::Declaration(decl) = &statement.kind { - // 只预声明函数/类,不提前把任意赋值名当作已存在业务值。 - let name = match &decl.kind { - DeclKind::Function(function) => &function.name, - DeclKind::Class(class) => &class.name, - }; - globals.insert(name.text.clone()); - } - } - } - } - // 每个根保留一个模板,执行顺序必须与原根切片一一对应,不能按名字排序。 - let mut compiled = Vec::with_capacity(plan.roots().len()); - /// 本函数在每段成功编译后调用,递归收集后续段可能引用的绑定名,不执行或预测条件真值。 - fn assigned(statement: &Stmt, globals: &mut BTreeSet) { - match &statement.kind { - StmtKind::Binding(b) => { - // 绑定给后续片段的静态名称解析提供名字;字典中的真实值仍在执行时建立。 - globals.insert(b.name.text.clone()); - } - StmtKind::Assignment(a) => { - // 顶层赋值也可能引入名字,按 Aster 交互语义让后续段可以编译引用。 - globals.insert(a.name.text.clone()); - } - StmtKind::If(b) => { - // 两个分支都收集“可能声明”名字,不在编译阶段决定哪条路径会执行。 - for s in &b.body.statements { - assigned(s, globals); - } - if let Some(other) = &b.otherwise { - // else 中的潜在绑定也要让后续片段可编译引用,但这里不预先在 globals 字典创建实际值。 - for s in &other.statements { - assigned(s, globals); - } - } - } - StmtKind::While(b) => { - // 循环体可能写入全局;是否真正执行一次由 VM 决定,宿主不展开循环。 - for s in &b.body.statements { - assigned(s, globals); - } - } - // 表达式、return、成员赋值等不引入新的普通全局名;函数内部作用域由语言编译器处理。 - _ => {} - } - } - for root in plan.roots() { - // 每段得到当前已知全局集合快照,先编译再把本段绑定加入下一段上下文。 - let options = compiler::CompileOptions { - globals: globals.iter().cloned().collect(), - }; - compiled.push( - compiler::compile_ast(root, source, &options) - .map_err(|error| source.annotate(error))?, - ); - // 每段编译成功才把绑定/赋值名字加入下一段编译上下文,语法与代码生成都继续委托 Aster。 - if let AstRoot::Interactive(input) = root { - for statement in &input.statements { - assigned(statement, &mut globals); - } - } - } - Ok(compiled) +/// 完整程序准备时显式提供已安装的 UI 名称,Nexus 不导入 Tessera 的类型表。 +fn host_global_names() -> std::collections::BTreeSet { + std::iter::once("ui") + .chain(ui_bridge::TYPE_NAMES.iter().copied()) + .chain(ui_bridge::QUERY_NAMES.iter().copied()) + .map(str::to_owned) + .collect() } /// refresh_step 挂起 paint 时创建、下一轮恢复/取消时消费,文档草稿与所属窗口续体必须成对保留。 @@ -333,11 +169,8 @@ pub struct ReplSession { bridge: ui_bridge::UiBridge, // worker 分配的运行时代际 ID,输入即使数值窗口/Mount 相同也不能跨代沿用。 pub id: u64, - // 已接受 Console 输入数量与累计 AST 节点数,完整源加载和后续输入都受各自预算控制。 - inputs: usize, - ast_nodes: usize, - // 完整程序或累加后的 Console transcript,供发布和 Sources 使用,不通过回放恢复执行状态。 - source: String, + // Nexus 管理输入计数、累计结构预算及原文历史;宿主只借用它生成 Sources/文档。 + history: ConsoleHistory, // 交互记录的纯数据代码树,与 Candidate 的真实 globals/函数引用不是同一存储。 nodes: Vec, // 回调/渲染失败后置位,拒绝继续普通业务输入;保留画面不表示堆还能安全执行。 @@ -390,8 +223,8 @@ impl ReplSession { .refresh_document()? .ok_or_else(|| anyhow::anyhow!("program did not publish a Page"))?; runtime - .bridge - .reclaim(&mut runtime.candidate.vm, &mut runtime.candidate.roots)?; + .candidate + .with_host(|vm, roots| runtime.bridge.reclaim(vm, roots))?; Ok((runtime, document)) } @@ -416,8 +249,8 @@ impl ReplSession { if !runtime.has_pending_refresh() { anyhow::ensure!(document.is_some(), "program did not publish a Page"); runtime - .bridge - .reclaim(&mut runtime.candidate.vm, &mut runtime.candidate.roots)?; + .candidate + .with_host(|vm, roots| runtime.bridge.reclaim(vm, roots))?; } Ok((runtime, document)) } @@ -436,80 +269,52 @@ impl ReplSession { } // 来源标注把 API namespace/提交号接入 Aster 错误来源,不改变用户原文。 let unit = EndorReader::from_text(format!("{namespace} [submission {submission}]"), source); - // 按 Module/Script 路径编译,脚本片段仍共享同一个 globals。 - let plan = endor_script::parse(&unit)?; - // 一份输入的所有根累计使用同一结构预算,过大 AST 在业务执行前失败。 - let mut budget = AstBudget::default(); - for ast in plan.roots() { - budget.visit_ast_root(ast)?; - } - // 全部编译成功后才创建并执行新运行时,解析/编译失败不改变任何活程序对象。 - let compiled = compile_plan(&unit, &plan)?; + // 原文、AST、模板和结构计数同源准备;全部编译成功后才创建新 VM。 + let program = nexus::program::PreparedProgram::compile(unit, host_global_names())?; + let unit = program.source(); + let plan = program.plan(); // new 安装类型和 globals,但不主动打开页面;源程序决定要展示的内容。 let mut runtime = Self::new(id)?; runtime .bridge - .set_viewport(&mut runtime.candidate.vm, viewport)?; + .set_viewport(runtime.candidate.vm_mut(), viewport)?; // 完整程序代码在候选自己的真实 globals 中执行,之后保留该堆用于事件与 Console,不通过重放历史恢复状态。 - let globals = runtime.candidate.globals.expect("program globals"); - // 根据已编译根数确定脚本每段硬额度;完整模块仍使用一份 LIMITS 执行模块定义。 - let limits = if matches!(plan, SourcePlan::Script(_)) { - // 指令硬额度在脚本段间均分,不因一个输入拆成更多交互段而放大执行总量。 - ExecutionLimits { - max_instructions: LIMITS.max_instructions / compiled.len().max(1), - ..LIMITS - } - } else { - // 模块作为一个编译单元执行定义,之后 main 有单独一次有界调用。 - LIMITS - }; - for template in &compiled { - // 代码只需此段执行期间持有,执行结果暂存,代码根释放后再传播调用错误。 - let code = template.load(&mut runtime.candidate.vm)?; - // 保存 Result 以保证失败执行也经过 vm.release(code)。 - let result = runtime - .candidate - .vm - .execute_with_limits(code, globals, limits) - .map_err(|error| runtime_error(&runtime.candidate.vm, error)); - runtime.candidate.vm.release(code)?; - runtime.candidate.vm.release_value(result?)?; - } + let globals = runtime.candidate.globals().expect("program globals"); + // 持久路径仅在执行期间持有代码根,错误也先归还局部代码根再传播。 + runtime + .candidate + .execute_program(&program, nexus::program::CodeRetention::Execution)?; if matches!(plan, SourcePlan::Module(_)) { // 模块顶层只安装定义,main 从实际 globals 查找,而非只依据 AST 声明列表。 let main = runtime .candidate - .vm + .vm() .dict_get(globals, &Value::Text("main".into()))? .ok_or_else(|| anyhow::anyhow!("declare a main function"))?; // 同名全局可能被赋为标量,先解码对象,再由 VM 完整检查可调用契约。 let Value::Object(main) = main else { bail!("main must be callable"); }; - // 返回值保留到 has_page/open_value 决策之后;无论打开成功与否都须显式释放。 - let value = runtime + // 域策略只由 Tessera 解释;Nexus 保证正常成功/错误返回都归还 main 返回根。 + let bridge = &runtime.bridge; + runtime .candidate - .vm - .call_with_limits(main, &[], LIMITS) - .map_err(|error| runtime_error(&runtime.candidate.vm, error))?; - // main 已主动打开 Page 时尊重其选择;否则把返回值经展示协议打开,不能重复创建第二个默认页面。 - let opened = if runtime.bridge.has_page()? { - Ok(()) - } else { - // 返回对象按 Presentable/普通值规则进入桥接,不要求所有模块都手写 page.render。 - runtime.bridge.open_value(&mut runtime.candidate.vm, &value) - }; - runtime.candidate.vm.release_value(value)?; - opened?; + .with_call_result(main, &[], LIMITS, |vm, value| { + if bridge.has_page()? { + Ok(()) + } else { + // main 没有主动打开页面时,把返回值按 Tessera 展示协议打开。 + bridge.open_value(vm, value) + } + })?; } if !runtime.bridge.has_page()? { // UI 程序必须有实际安排页面,单独计算出一个未打开 Block 不算可发布程序。 bail!("script must call page.render(root) or ui.open(value)"); } - runtime.source = source.into(); - runtime.ast_nodes = budget.nodes; + runtime.history = ConsoleHistory::from_program(&program); // 保存完整程序的 Sources 投影,后续 Console 追加时可移入交互记录树;不把 AST 投影当可执行堆对象。 - runtime.program_root = Some(architecture(&unit, &plan, namespace, submission)); + runtime.program_root = Some(architecture(unit, plan, namespace, submission)); Ok(runtime) } @@ -519,7 +324,7 @@ impl ReplSession { let mut runtime = Self::new(id)?; runtime .bridge - .set_viewport(&mut runtime.candidate.vm, viewport)?; + .set_viewport(runtime.candidate.vm_mut(), viewport)?; Ok(runtime) } @@ -528,19 +333,14 @@ impl ReplSession { // Candidate 的 Drop 负责异常返回时的最终清理,不让 bootstrap 半途失败泄漏 VM 根。 let mut candidate = Candidate::new()?; // globals 的拥有根留在 Candidate,实际用户绑定在以后输入中原地更新这个字典。 - let globals = candidate.vm.new_dict()?; - candidate.globals = Some(globals); - candidate.roots.push(globals); + candidate.create_globals()?; // 每个会话安装一份类型域,后续输入继续复用,不按 Console 行重复建立名义类型。 - let bridge = ui_bridge::install(&mut candidate.vm, &mut candidate.roots)?; - bridge.install_globals(&mut candidate.vm, globals)?; + let bridge = candidate.register_host(&crate::bridge::nexus_host::UiHost)?; Ok(Self { candidate, bridge, id, - inputs: 0, - ast_nodes: 0, - source: String::new(), + history: ConsoleHistory::default(), nodes: Vec::new(), faulted: false, program_root: None, @@ -578,132 +378,33 @@ impl ReplSession { "runtime stopped after a callback or rendering failure; reset the session or replace its program" ); } - if source.len() > MAX_SOURCE_BYTES { - // 单次 Console 输入也受原始字节预算约束,不能仅靠下面累计 transcript 预算替代。 - bail!("input exceeds 1 MiB"); - } - // 持久 Console 限制累计输入次数、源码文本和稍后的 AST 总节点数,用户需显式重置才能重新获得预算。 - if self.inputs >= 256 || self.source.len() + source.len() + 80 > MAX_SOURCE_BYTES { - bail!("console session exceeds 256 inputs or 1 MiB; reset the session to continue"); - } - // 对每次输入保留会话号/输入号作为来源,累计 transcript 的行号稍后再为 Sources 投影偏移。 - let source = EndorReader::from_text( - format!("console session {} input {}", self.id, self.inputs + 1), - source, - ); - // 输入可以是一段或多段交互语句,语法仍由 Aster 的 parser 决定。 - let plan = endor_script::parse(&source)?; - // 新输入的结构量先算出,再与会话累计量合并,不为每次输入重新放宽全会话上限。 - let mut budget = AstBudget::default(); - for ast in plan.roots() { - budget.visit_ast_root(ast)?; - } - if self.ast_nodes + budget.nodes > MAX_AST_NODES { - // 此处限制整个持久会话累计结构量;超限发生在记输入号、追加源码和执行用户语句之前。 - bail!("console session exceeds 10000 AST nodes; reset the session to continue"); - } - // new 已建立的字典继续原地使用,保存对象身份和闭包,不能通过历史源码重放重建它。 - let globals = self.candidate.globals.expect("live console globals"); - // 从实际 globals 枚举已有名称供增量编译,支持前次输入创建的真实对象,而非靠解析历史猜名称。 - let names = self - .candidate - .vm - .dict_items(globals)? - .iter() - .filter_map(|(key, _)| { - // 只把字符串键变成静态编译全局名,不向编译器传 VM Value 或托管引用。 - if let Value::Text(name) = key { - Some(name.clone()) - } else { - None - } - }) - .collect(); - // 所有根先编译完,任何语法/类型编译错误都不会执行输入前半部分。 - let compiled = compile_plan_with_globals(&source, &plan, names)?; - self.bridge.discard_pending(&mut self.candidate.vm)?; - self.bridge - .reclaim(&mut self.candidate.vm, &mut self.candidate.roots)?; - // 解析/编译全部成功后才记本轮输入与源码;之后运行失败仍可能保留此前语句副作用,不做事务回滚。 - self.inputs += 1; - self.ast_nodes += budget.nodes; + // Nexus 检查累计次数/字节/结构预算,使用当前真实 globals 编译;准备失败不接受输入。 + let prepared = self.history.prepare(&self.candidate, self.id, source)?; + self.bridge.discard_pending(self.candidate.vm_mut())?; + self.candidate + .with_host(|vm, roots| self.bridge.reclaim(vm, roots))?; + // 宿主清理成功后才接受输入;之后执行失败仍保留该输入和此前副作用。 + let accepted = self.history.accept(prepared)?; + let source = accepted.input().source(); + let plan = accepted.input().plan(); if let Some(root) = self.program_root.take() { - // 第一次 Console 输入把原完整程序浏览树移入 transcript 节点,不丢原程序的 Sources 内容。 + // 首次追加保留原完整程序的浏览树;历史原文和计数已由 Nexus 统一维护。 self.nodes.push(root); } - if !self.source.is_empty() && !self.source.ends_with('\n') { - // 分隔行不改变 VM 代码语义,只保证后续 Sources 行号和注释不粘到上一行末尾。 - self.source.push('\n'); - } - // 交互源码前加 Console input 注释分隔,投影节点行号再整体平移到累计 transcript 中。 - let offset = line_starts(&self.source).len(); - self.source - .push_str(&format!("// Console input {}\n", self.inputs)); - self.source.push_str(source.text()); - if !self.source.ends_with('\n') { - // transcript 的尾部补换行只服务下一条输入的浏览行号,当前执行仍使用独立 SourceUnit 原文。 - self.source.push('\n'); - } // 本轮输入的代码树先使用局部行号,再用 offset 平移到累计源码中的对应位置。 let mut node = architecture( - &source, - &plan, + source, + plan, &format!("{namespace}:console-{}", self.id), - self.inputs as u64, + self.history.inputs() as u64, ); - node.name = format!("Input {}", self.inputs); - shift_node_lines(&mut node, offset); + node.name = format!("Input {}", self.history.inputs()); + shift_node_lines(&mut node, accepted.line_offset()); self.nodes.push(node); // 保存执行/刷新失败供下面丢弃未发布请求并给 Sources 标注,已完成赋值不做事务回滚。 let result: Result = (|| { - // 多根均分本次硬预算,不让后续片段每个都获得完整一百万条指令。 - let limits = ExecutionLimits { - max_instructions: LIMITS.max_instructions / compiled.len().max(1), - ..LIMITS - }; - // 依次覆盖为最后一个片段的可显示值;本局部只保存字符串,不延长任意返回对象寿命。 - let mut rendered_value = "nil".to_owned(); - for (ast, template) in plan.roots().iter().zip(&compiled) { - // 代码根只跨一次 execute,先暂存 Result 再 release(code),失败也有清理。 - let code = template.load(&mut self.candidate.vm)?; - // VM 执行真实 globals,不把本轮 AST 当快照去覆盖旧业务状态。 - let executed = self - .candidate - .vm - .execute_with_limits(code, globals, limits) - .map_err(|error| runtime_error(&self.candidate.vm, error)); - self.candidate.vm.release(code)?; - // execute 返回拥有根,后面 repr/全局 _ 更新是否成功都必须释放这份根。 - let value = executed?; - // 绑定/赋值语句展示其新变量实际值,普通表达式展示返回值;不是仅显示该语句执行的 Unit。 - let display = if let AstRoot::Interactive(input) = ast { - match &input.statements[0].kind { - StmtKind::Binding(binding) => self - .candidate - .vm - .dict_get(globals, &Value::Text(binding.name.text.clone()))? - .unwrap_or_else(|| value.clone()), - StmtKind::Assignment(assignment) => self - .candidate - .vm - .dict_get(globals, &Value::Text(assignment.name.text.clone()))? - .unwrap_or_else(|| value.clone()), - _ => value.clone(), - } - } else { - value.clone() - }; - // 先算 repr 并把实际最后值写入全局 _,保留未命名 UI 对象;随后释放 execute 返回根,错误也逐项传播。 - let repr = value_repr(&self.candidate.vm, &display); - // _ 的字典强边独立保留最后值,避免匿名 Block 在 Console 显示后马上丢失身份。 - let retained = - self.candidate - .vm - .dict_set(globals, Value::Text("_".into()), display); - self.candidate.vm.release_value(value)?; - retained?; - rendered_value = repr?; - } + // 输入记录已接受,Nexus 负责同 VM 执行、最后值显示与 _ 的真实拥有边;错误不回滚前段写入。 + let rendered_value = accepted.execute(&mut self.candidate)?; // 有业务变更后才推进 UI 稳定循环,可能返回挂起时的 None,worker 继续保留该会话。 let document = self.refresh_after_mutation(viewports)?; Ok(ReplResult { @@ -711,18 +412,18 @@ impl ReplSession { document, bindings: self .candidate - .vm - .dict_items(globals)? + .vm() + .dict_items(self.candidate.globals().expect("live console globals"))? .len() .saturating_sub(1), - input: self.inputs, + input: self.history.inputs(), }) })(); // 失败丢弃未发布展示请求和原生命令,保留已执行业务写入,并在代码投影上明确标记非事务语义。 if result.is_err() { // 只丢待发布展示与原生命令,不假装撤销此前已完成的用户赋值或资源关闭。 self.take_window_commands()?; - self.bridge.discard_pending(&mut self.candidate.vm)?; + self.bridge.discard_pending(self.candidate.vm_mut())?; if let Some(node) = self.nodes.last_mut() { // 标记本次已记录的输入节点,保留先前 Sources 记录,不把运行失败误记为从未执行。 node.name @@ -731,8 +432,8 @@ impl ReplSession { } // 未完成只读续体仍持有临时结果,不在中途执行完整 reclaim;等刷新结束后再回收不可达宿主根。 if !self.has_pending_refresh() { - self.bridge - .reclaim(&mut self.candidate.vm, &mut self.candidate.roots)?; + self.candidate + .with_host(|vm, roots| self.bridge.reclaim(vm, roots))?; } result } @@ -838,7 +539,7 @@ impl ReplSession { // 这里是失败收尾,取消已有 paint 并丢弃配对草稿;只有正常下一量子的 step_refresh 才会恢复 paint。 if let Some(paint) = work.paint.take() { self.bridge.cancel_paint_frame( - &mut self.candidate.vm, + self.candidate.vm_mut(), paint.window, *paint.work, )?; @@ -846,7 +547,7 @@ impl ReplSession { if let Some(pending) = work.pending.take() { // 若失败发生在布局阶段,取消这份原窗口检查点配套的 Work;不会恢复执行源语句或发布其草稿。 self.bridge - .abort_layout_frame(&mut self.candidate.vm, *pending)?; + .abort_layout_frame(self.candidate.vm_mut(), *pending)?; } self.bridge.select_window(crate::window::MAIN_WINDOW)?; Err(error) @@ -860,7 +561,7 @@ impl ReplSession { // 每轮先使属性绑定达到固定点,再取窗口顺序;绑定结果应用与生命周期写入可能令依赖再次失效,因此需要多轮确认。 if work.pass_start { // 生命周期可能改窗口登记,绑定结果可能改视觉属性;新的稳定轮必须重新刷新绑定并获取窗口顺序。 - self.bridge.refresh_bindings(&mut self.candidate.vm)?; + self.bridge.refresh_bindings(self.candidate.vm_mut())?; work.windows = self.bridge.window_ids()?.into(); work.current = None; work.pass_changed = false; @@ -894,19 +595,19 @@ impl ReplSession { // 同一 owning VM 上恢复固定预算的一片绘制,Complete/Pending 由共同接收器处理。 let progress = self .bridge - .resume_paint_frame(&mut self.candidate.vm, *paint_work)?; + .resume_paint_frame(self.candidate.vm_mut(), *paint_work)?; return Self::accept_window_paint(work, window, document, progress); } // 阶段三:恢复旧布局,或在快照/依赖确实变化时建立新布局。 let progress = if let Some(pending) = work.pending.take() { // 原布局仍挂起时恢复,不能重新提取另一份根让当前续体读写不同展示上下文。 self.bridge - .resume_layout_frame(&mut self.candidate.vm, *pending)? - } else if let Some(root) = self.bridge.prepare_frame(&mut self.candidate.vm)? { + .resume_layout_frame(self.candidate.vm_mut(), *pending)? + } else if let Some(root) = self.bridge.prepare_frame(self.candidate.vm_mut())? { // 双层 Option 内层 None 也代表有空帧工作;保存准确根供布局完成后 paint 复用。 work.root = root.clone(); self.bridge - .begin_layout_frame(&mut self.candidate.vm, root)? + .begin_layout_frame(self.candidate.vm_mut(), root)? } else { // 没有任何本窗变化才切下一窗,不能把“需发布空帧”误归为这一无工作分支。 work.current = None; @@ -924,13 +625,13 @@ impl ReplSession { // 阶段四:几何完成后建立候选文档,再运行 paint;这里尚未向 GUI 发布。 let mut document = RenderDocument { windows: Default::default(), - source: self.source.clone(), + source: self.history.source().to_owned(), root: Some(self.program_root.clone().unwrap_or_else(|| CodeNode { id: format!("console-session-{}", self.id), name: format!("Console session {}", self.id), kind: "repl-session".into(), start_line: 1, - end_line: self.source.lines().count(), + end_line: self.history.source().lines().count(), children: self.nodes.clone(), })), frame, @@ -946,7 +647,7 @@ impl ReplSession { } // Frame 转移给 source_paint,document 暂留其他元数据;PendingPaint 会把两者重新配对保存。 let progress = self.bridge.begin_paint_frame( - &mut self.candidate.vm, + self.candidate.vm_mut(), document.ui_root.clone(), std::mem::take(&mut document.frame), )?; @@ -985,7 +686,7 @@ impl ReplSession { /// poll_refresh 收到全轮稳定后调用,完成关闭资源清理并生成一次多窗口发布值;不会直接写 NamespaceState。 fn finish_refresh(&mut self, mut work: RefreshWork) -> Result> { // 收敛后完成已关闭窗口退役并删其旧文档;没有实际变化时不制造额外 revision。 - self.bridge.finish_closed(&mut self.candidate.vm)?; + self.bridge.finish_closed(self.candidate.vm_mut())?; // 以桥接真实仍登记窗口为准删去旧文档,不让已关闭副窗口在下轮凭缓存“复活”。 let ids = self.bridge.window_ids()?; work.documents.retain(|id, _| ids.contains(id)); @@ -1000,19 +701,19 @@ impl ReplSession { .get(&crate::window::MAIN_WINDOW) .cloned() .unwrap_or_else(|| RenderDocument { - source: self.source.clone(), + source: self.history.source().to_owned(), frame: crate::document::Frame { session: self.id, ..Default::default() }, ..Default::default() }); - main.source = self.source.clone(); + main.source = self.history.source().to_owned(); // 优先采用源码与当前 transcript 相同的窗口代码投影,避免主窗口未重绘时 Sources 仍展示旧输入树。 main.root = work .documents .values() - .find(|document| document.source == self.source) + .find(|document| document.source == self.history.source()) .and_then(|document| document.root.clone()) .or(main.root); // 副窗口统一挂到主文档 windows 一层,子文档自身不再嵌套副窗口,最终 validate 检查完整跨线程值。 @@ -1052,7 +753,7 @@ impl ReplSession { if let Some(paint) = work.paint.take() && let Err(error) = self.bridge - .cancel_paint_frame(&mut self.candidate.vm, paint.window, *paint.work) + .cancel_paint_frame(self.candidate.vm_mut(), paint.window, *paint.work) { // 取消 paint 失败后域不再继续正常执行,不把残留续体草稿交给新一轮目标使用。 self.faulted = true; @@ -1061,7 +762,7 @@ impl ReplSession { if let Some(pending) = work.pending.take() && let Err(error) = self .bridge - .cancel_layout_frame(&mut self.candidate.vm, *pending) + .cancel_layout_frame(self.candidate.vm_mut(), *pending) { // layout 取消还要恢复 Mount 检查点,失败同样停域,不能仅删 Pending Rust 值。 self.faulted = true; @@ -1128,7 +829,7 @@ impl ReplSession { self.bridge.select_window(*id)?; changed |= self .bridge - .set_viewport(&mut self.candidate.vm, Some(*viewport))?; + .set_viewport(self.candidate.vm_mut(), Some(*viewport))?; } } self.bridge.select_window(crate::window::MAIN_WINDOW)?; @@ -1170,12 +871,12 @@ impl ReplSession { if result.is_err() { // GUI 继续使用旧完整文档,失败草稿的副作用命令不能外泄为 Resize/Focus 等原生动作。 self.take_window_commands()?; - self.bridge.discard_pending(&mut self.candidate.vm)?; + self.bridge.discard_pending(self.candidate.vm_mut())?; } if !self.has_pending_refresh() { // 仍挂起时临时对象属于原视觉调用,不能在其中完整回收;只在续体结束边界 reclaim。 - self.bridge - .reclaim(&mut self.candidate.vm, &mut self.candidate.roots)?; + self.candidate + .with_host(|vm, roots| self.bridge.reclaim(vm, roots))?; } result } @@ -1205,9 +906,9 @@ impl ReplSession { } if self.faulted { // 故障域不执行任何新用户任务,仅取消已有任务并在确实移除工作后回收引用。 - if self.bridge.cancel_tasks(&mut self.candidate.vm)? > 0 { - self.bridge - .reclaim(&mut self.candidate.vm, &mut self.candidate.roots)?; + if self.bridge.cancel_tasks(self.candidate.vm_mut())? > 0 { + self.candidate + .with_host(|vm, roots| self.bridge.reclaim(vm, roots))?; } return Ok(None); } @@ -1217,7 +918,7 @@ impl ReplSession { let result = (|| { // worker 增量轮至多启动一个任务推进,给前台输入和窗口刷新公平机会;同步路径单轮允许64项。 let limit = if viewports.is_some() { 1 } else { 64 }; - if self.bridge.poll_tasks(&mut self.candidate.vm, limit)? == 0 { + if self.bridge.poll_tasks(self.candidate.vm_mut(), limit)? == 0 { // 无实际推进就不启动视觉刷新,等待 I/O/计时器不会凭轮询本身制造新帧。 return Ok(None); } @@ -1227,14 +928,14 @@ impl ReplSession { if result.is_err() { // 任一共享 VM 任务回调故障会停整个域,不只把当前 Task 标失败后继续执行其他不安全回调。 self.faulted = true; - self.bridge.cancel_tasks(&mut self.candidate.vm)?; + self.bridge.cancel_tasks(self.candidate.vm_mut())?; self.take_window_commands()?; - self.bridge.discard_pending(&mut self.candidate.vm)?; + self.bridge.discard_pending(self.candidate.vm_mut())?; } // 任务推进或失败后才需回收,并且不能在仍有只读续体时清理其临时根。 if (completed || result.is_err()) && !self.has_pending_refresh() { - self.bridge - .reclaim(&mut self.candidate.vm, &mut self.candidate.roots)?; + self.candidate + .with_host(|vm, roots| self.bridge.reclaim(vm, roots))?; } result } @@ -1242,7 +943,7 @@ impl ReplSession { /// api::worker 准备一次发布/错误丢弃时调用,空闲边界才可排空命令,避免从未稳定草稿提前执行 OS 动作。 pub fn take_window_commands(&self) -> Result> { self.require_idle_refresh()?; - self.bridge.take_window_commands(&self.candidate.vm) + self.bridge.take_window_commands(self.candidate.vm()) } #[cfg(test)] @@ -1255,17 +956,20 @@ impl ReplSession { if self.faulted { bail!("runtime stopped after a callback or rendering failure"); } - if !self.bridge.set_viewport(&mut self.candidate.vm, viewport)? { + if !self + .bridge + .set_viewport(self.candidate.vm_mut(), viewport)? + { return Ok(None); } // 同步测试 resize 保存刷新错误,随后同样丢弃失败请求并回收引用,不让 ? 跳过清理。 let result = self.refresh_document(); if result.is_err() { self.take_window_commands()?; - self.bridge.discard_pending(&mut self.candidate.vm)?; + self.bridge.discard_pending(self.candidate.vm_mut())?; } - self.bridge - .reclaim(&mut self.candidate.vm, &mut self.candidate.roots)?; + self.candidate + .with_host(|vm, roots| self.bridge.reclaim(vm, roots))?; result } @@ -1275,7 +979,7 @@ impl ReplSession { // 从会话移走 Work 后逐项清理,检查点/临时 VM 根不能仅靠 Rust 值析构替代。 if let Some(paint) = work.paint.take() { self.bridge.cancel_paint_frame( - &mut self.candidate.vm, + self.candidate.vm_mut(), paint.window, *paint.work, )?; @@ -1283,7 +987,7 @@ impl ReplSession { if let Some(pending) = work.pending.take() { // 与 paint 清理互斥的布局续体还带 Mount 检查点,交桥接层完整取消而非直接丢弃 Rust 句柄。 self.bridge - .cancel_layout_frame(&mut self.candidate.vm, *pending)?; + .cancel_layout_frame(self.candidate.vm_mut(), *pending)?; } } Ok(()) @@ -1296,7 +1000,7 @@ impl ReplSession { // 正常域允许卸载钩子,已经故障的域只做宿主清理,不能再次执行不可靠的源回调。 let callbacks = !self.faulted; self.faulted = true; - self.bridge.shutdown(&mut self.candidate.vm, callbacks) + self.bridge.shutdown(self.candidate.vm_mut(), callbacks) } /// worker 在故障域处理原生关闭时调用,只退役指定副窗口与缓存,不允许再执行源生命周期钩子。 @@ -1305,17 +1009,17 @@ impl ReplSession { // 只用于域已停止后的宿主清理,不能将此路径当作正常 Window.close 源方法的替代。 self.faulted = true; // 专用退役只清宿主资源,不调源生命周期;删除已缓存文档和窗口命令,避免后续重发该副窗口。 - self.bridge.retire_window(&mut self.candidate.vm, id)?; + self.bridge.retire_window(self.candidate.vm_mut(), id)?; self.documents.remove(&id); // 故障退役只排空命令并丢弃,不能把失败域旧 Focus/Resize 发布到当前原生资源。 let _ = self.take_window_commands()?; - self.bridge - .reclaim(&mut self.candidate.vm, &mut self.candidate.roots) + self.candidate + .with_host(|vm, roots| self.bridge.reclaim(vm, roots)) } /// api::worker 接受 tab-drop 前调用,验证两端发布版本/页面顺序,普通非拖放信封由 bridge 返回 true。 pub fn accepts_tab_drop(&self, input: &crate::events::Input) -> bool { - self.bridge.accepts_tab_drop(&self.candidate.vm, input) + self.bridge.accepts_tab_drop(self.candidate.vm(), input) } /// api::worker 接纳窗口输入前调用,只查询资源是否仍登记且未 closing,后面仍需 session/Mount 校验。 @@ -1365,7 +1069,7 @@ impl ReplSession { self.bridge.select_window(input.window)?; // 暂存回调/刷新错误,外层始终尝试恢复主窗口选择、丢弃未发布结果并回收空闲根。 let result = (|| { - self.bridge.dispatch(&mut self.candidate.vm, input)?; + self.bridge.dispatch(self.candidate.vm_mut(), input)?; // 输入已执行一次,后续只续跑视觉刷新,不能为多片 layout 再调用同一 click 回调。 let document = self.refresh_after_mutation(viewports)?; Ok(ReplResult { @@ -1373,11 +1077,11 @@ impl ReplSession { document, bindings: self .candidate - .vm - .dict_items(self.candidate.globals.expect("live globals"))? + .vm() + .dict_items(self.candidate.globals().expect("live globals"))? .len() .saturating_sub(1), - input: self.inputs, + input: self.history.inputs(), }) })(); self.bridge.select_window(crate::window::MAIN_WINDOW)?; @@ -1385,12 +1089,12 @@ impl ReplSession { self.take_window_commands()?; // 回调失败属于共享 VM 故障,不只关闭单个按钮;丢弃未发布命令与 pending 请求,但不重放已执行写入。 self.faulted = true; - self.bridge.discard_pending(&mut self.candidate.vm)?; + self.bridge.discard_pending(self.candidate.vm_mut())?; } if !self.has_pending_refresh() { // 分派后的只读刷新若仍挂起,临时根归原调用持有;只有空闲边界才回收,不干扰下一量子恢复。 - self.bridge - .reclaim(&mut self.candidate.vm, &mut self.candidate.roots)?; + self.candidate + .with_host(|vm, roots| self.bridge.reclaim(vm, roots))?; } result } @@ -1413,117 +1117,6 @@ fn shift_node_lines(node: &mut CodeNode, offset: usize) { shift_node_lines(child, offset); } } -/// execute_mode 在保存全局 _ 前调用,把真实返回值/新绑定值转成显示字符串;返回根仍由调用者释放。 -fn value_repr(vm: &Vm, value: &Value) -> Result { - Ok(match value { - Value::Nil => "nil".into(), - Value::Bool(v) => v.to_string(), - Value::Text(v) => format!("{v:?}"), - Value::Number(v) => v.to_string(), - Value::Object(v) => vm.repr(*v)?, - }) -} - -/// 拥有 VM、全局字典与宿主保留根;关闭时按顺序释放,失败也必须收尾。 -struct Candidate { - // 实际解释器/托管堆,仅执行 worker 线程操作,不放入共享 NamespaceState。 - vm: Vm, - // 宿主安装期间保留的拥有根,close 逆序 pop;ObjectRef Rust 数值本身没有自动 release 行为。 - roots: Vec, - // 主全局字典也在 roots 中,先清字典断业务根,再统一释放根,避免闭包环残留。 - globals: Option, -} - -impl Candidate { - /// 创建独立 VM,先不保留任何宿主根或全局字典;后续安装失败也由该候选负责清理。 - fn new() -> Result { - Ok(Self { - vm: Vm::new()?, - roots: Vec::new(), - globals: None, - }) - } - - /// compile/evaluate 显式调用,Candidate::drop 兜底调用;按拥有顺序拆根并验证堆没有遗留对象。 - fn close(&mut self) -> Result<()> { - // 清全局字典先断业务对象可达根,再逆序释放宿主分配根;最后执行循环回收并验证对象计数归零。 - if let Some(globals) = self.globals.take() { - // take 使重复 close 不重复清同一身份;先断用户全局再释放类型/函数等宿主根。 - self.vm.dict_clear(globals)?; - } - // pop 逐项移出确保再次 close 不重复释放已成功处理的根;错误仍交显式关闭调用方报告。 - while let Some(root) = self.roots.pop() { - self.vm.release(root)?; - } - self.vm.collect_cycles(); - if self.vm.object_count() != 0 { - // 源程序返回了纯数据也不掩盖资源泄漏,显式 close 会把这个错误报告给调用者。 - bail!("candidate VM retained objects after cleanup"); - } - Ok(()) - } -} - -impl Drop for Candidate { - /// 析构调用 Candidate.close 释放候选根和 VM,覆盖提前返回/异常展开;析构不能向调用者报告清理错误。 - fn drop(&mut self) { - // 显式 close 可以报告引用计数/清理错误;Drop 则保证提前返回和异常展开仍经过最终清理边界。 - let _ = self.close(); - } -} - -/// 本模块和 bridge/tasks 的 VM 错误映射调用,立即取 last_traceback 拼成纯文本,避免后续调用覆盖故障栈。 -pub(crate) fn runtime_error(vm: &Vm, error: VmError) -> anyhow::Error { - // 错误发生后立即读取 VM traceback,保留函数、源文件与指令偏移;无栈信息时直接保留原 VmError。 - let locations = vm - .last_traceback() - .iter() - .map(|frame| { - // 每帧保留来源文件、函数名和指令位置,不把托管异常对象直接跨线程交付。 - format!( - "{}:{} in {} (instruction {})", - frame.filename, frame.first_line, frame.function, frame.instruction_offset - ) - }) - .collect::>() - .join("\n"); - if locations.is_empty() { - // 无 VM 栈时保留原始 VmError,不能凭当前源码猜一个错误行号。 - error.into() - } else { - // 含栈则附加每帧可读位置,Console/API 不需读取 VM 就能展示错误。 - anyhow::anyhow!("{error}\n{locations}") - } -} - -#[derive(Default)] -/// 编译前的语法节点数量/嵌套预算,限制输入结构复杂度。 -struct AstBudget { - // 当前递归路径深度,leave_node 归还;不能与累计节点数共用一个计数。 - depth: usize, - // 已访问节点总量,多个 Script 根共享累计,leave_node 不减少。 - nodes: usize, -} - -impl Visitor for AstBudget { - type Error = anyhow::Error; - /// Aster Visitor 在进入任意语法节点时调用,compile/evaluate/加载/Console 共用这个结构预算。 - fn enter_node(&mut self, _span: Span) -> Result<()> { - // 每次进入节点累计总数和当前深度;leave 只归还深度,整份输入总量不会因退出子树重置。 - self.depth += 1; - self.nodes += 1; - if self.depth > MAX_AST_DEPTH || self.nodes > MAX_AST_NODES { - // 在加载/执行代码前停止,防止巨大源码结构绕过仅约束运行指令的 LIMITS。 - bail!("Aster AST exceeds the 64-level or 10000-node host budget"); - } - Ok(()) - } - /// 离开当前语法节点时归还嵌套深度;累计节点数保留,不能通过退出子树绕过总量预算。 - fn leave_node(&mut self) { - self.depth -= 1; - } -} - /// compile/prepare_program/execute_mode 调用,将已解析 AST 投影为 Sources 浏览树,不保存可执行托管引用。 fn architecture( source: &SourceUnit, @@ -1554,7 +1147,7 @@ fn architecture( AstRoot::Expression(expression) => children.push(tree.expression(expression)), } } - // 只借根列表取首尾跨度,不克隆整棵 AST;Script 的 span 已由 endor_script 映回原文件。 + // 只借根列表取首尾跨度,不克隆整棵 AST;Script 的 span 已由 Nexus source 映回原文件。 let roots = plan.roots(); // 整体范围取首根起点至末根终点,Script 的多个交互片段在原始文本中的 span 已恢复偏移。 let span = Span::new( @@ -1570,21 +1163,6 @@ fn architecture( tree.node(namespace.to_owned(), kind, span, children) } -/// architecture/execute_mode 调用,建立字节偏移→行号的搜索索引,兼容 CRLF、LF 和孤立 CR。 -fn line_starts(source: &str) -> Vec { - // Span 使用 UTF-8 字节单位,所以不用 chars().enumerate() 的字符索引匹配它。 - let bytes = source.as_bytes(); - // 按字节扫描行终止符,CRLF 仅在 LF 记一次,孤立 CR 也换行;空文本仍保留第1行起点0。 - let mut starts = vec![0]; - for (offset, byte) in bytes.iter().enumerate() { - if *byte == b'\n' || (*byte == b'\r' && bytes.get(offset + 1) != Some(&b'\n')) { - // 记录换行符之后的下一行首,CRLF 只在 LF 分支记录一次,空末行也有可定位起点。 - starts.push(offset + 1); - } - } - starts -} - /// 构造 Sources 语法投影所需的源码与定位辅助状态。 struct Architecture { // 排好序的字节行首,node 通过 partition_point 得到一基行号。 diff --git a/src/runtime/endor_host/tests.rs b/src/runtime/endor_host/tests.rs index 137f479..ba826c6 100644 --- a/src/runtime/endor_host/tests.rs +++ b/src/runtime/endor_host/tests.rs @@ -6,6 +6,8 @@ //! r# 原始字符串中的 Endor 是验收夹具,保持其源码/行号不变;Rust 注释解释夹具意图和随后观察的行为。 use super::*; use crate::document::{NamespaceState, RenderCommand}; +// 测试转发器直接使用 Aster 句柄类型,不依赖父模块的迁移期导入。 +use endor_core::{ObjectRef, VmError}; // 一次性模块执行/错误保留测试共用的真实示例,不在测试中另造只为通过断言的近似模块。 const EXAMPLE: &str = include_str!("../../../examples/hello.endor"); @@ -522,11 +524,11 @@ fn native_signatures_validate_registration_and_deliver_the_event_argument() { ); assert!(session.poll_tasks().unwrap().is_none()); // 最后直接查 VM 元数据,检查绑定状态方法 set 的实际显式 arity,不只看错误字符串。 - let globals = session.candidate.globals.unwrap(); + let globals = session.candidate.globals().unwrap(); // received 是全局里真实状态对象,所有权仍由 globals 持有,这里只读取其句柄。 let Value::Object(received) = session .candidate - .vm + .vm() .dict_get(globals, &Value::Text("received".into())) .unwrap() .unwrap() @@ -534,11 +536,11 @@ fn native_signatures_validate_registration_and_deliver_the_event_argument() { panic!("state") }; // set 已捕获 receiver,只应接受一个新值,不能额外把 owner 计入未绑定参数。 - let Value::Object(set) = session.candidate.vm.get_attr(received, "set").unwrap() else { + let Value::Object(set) = session.candidate.vm().get_attr(received, "set").unwrap() else { panic!("set") }; assert_eq!( - session.candidate.vm.call_arity(set).unwrap(), + session.candidate.vm().call_arity(set).unwrap(), Some(endor_core::CallArity::exact(1)) ); } @@ -944,11 +946,11 @@ fn file_task_source(path: &std::path::Path, tail: &str) -> String { /// 不通过 REPL execute 查询,避免状态观察自身引入一次输入、刷新或任务调度副作用。 fn file_task_state(session: &mut ReplSession) -> String { // 直接查同一个持久 VM 的真实 globals,不执行一条额外 Console 输入改变 transcript/刷新轮次。 - let globals = session.candidate.globals.unwrap(); + let globals = session.candidate.globals().unwrap(); // loader 是测试程序保存任务的持有者,字典仍拥有它,这里只借身份定位 task 属性。 let Value::Object(loader) = session .candidate - .vm + .vm() .dict_get(globals, &Value::Text("loader".into())) .unwrap() .unwrap() @@ -956,13 +958,13 @@ fn file_task_state(session: &mut ReplSession) -> String { panic!("loader"); }; // 即使 Task 已终态也可由 loader 保留;不能从 provider 弱索引推断其状态。 - let Value::Object(task) = session.candidate.vm.get_attr(loader, "task").unwrap() else { + let Value::Object(task) = session.candidate.vm().get_attr(loader, "task").unwrap() else { panic!("Task"); }; // 查询实际 Task 类型方法,保持与源 task.status() 相同的受检查方法入口。 let definition = session .candidate - .vm + .vm() .object_store() .type_of(task) .unwrap() @@ -970,7 +972,7 @@ fn file_task_state(session: &mut ReplSession) -> String { // lookup_method 取得未绑定方法,所以下面 call 显式补一个 Task receiver。 let method = session .candidate - .vm + .vm() .object_store() .lookup_method(definition, "status") .unwrap() @@ -978,7 +980,7 @@ fn file_task_state(session: &mut ReplSession) -> String { // 返回值必须是语言字符串,状态接口若变成 Nil/对象不能被测试静默格式化成看似合法状态。 let Value::Text(status) = session .candidate - .vm + .vm_mut() .call(method, &[Value::Object(task)]) .unwrap() else { @@ -1288,11 +1290,11 @@ fn orphan_task_scope_is_collectable_and_callback_failure_stops_remaining_work() assert!(session.poll_tasks().is_err()); assert!(session.is_faulted()); // 故障域已拒绝 execute,直接只读 VM 属性验证值仍为 0,而不为了观察又执行用户代码。 - let globals = session.candidate.globals.unwrap(); + let globals = session.candidate.globals().unwrap(); // 原共享状态对象仍由 globals 持有;读取它不创建新根或恢复后续被停用的任务。 let state = match session .candidate - .vm + .vm() .dict_get(globals, &Value::Text("state".into())) .unwrap() .unwrap() @@ -1301,7 +1303,7 @@ fn orphan_task_scope_is_collectable_and_callback_failure_stops_remaining_work() _ => panic!("state object"), }; assert_eq!( - session.candidate.vm.get_attr(state, "value").unwrap(), + session.candidate.vm().get_attr(state, "value").unwrap(), Value::Number(0.into()) ); assert!(session.poll_tasks().unwrap().is_none()); @@ -1432,11 +1434,11 @@ fn stopped_window_teardown_detaches_mounts_without_running_source_hooks() { .execute("held=button.mounts().at(0)", "app.main") .unwrap(); // 故障后只能只读观察真实对象,不能经 execute 调用户函数来检查清理结果。 - let globals = session.candidate.globals.unwrap(); + let globals = session.candidate.globals().unwrap(); // lookup 仅从原 globals 借出对象身份,持有关系没有被测试添加新的长期根改变。 let lookup = |session: &ReplSession, name: &str| match session .candidate - .vm + .vm() .dict_get(globals, &Value::Text(name.into())) .unwrap() .unwrap() @@ -1453,7 +1455,7 @@ fn stopped_window_teardown_detaches_mounts_without_running_source_hooks() { // 用目标 payload 的实际几何 ID 构造输入,当前 session/副窗版本来自初始发布值。 let mount = session .candidate - .vm + .vm() .payload::(held, "Mount") .unwrap() .geometry @@ -1481,18 +1483,18 @@ fn stopped_window_teardown_detaches_mounts_without_running_source_hooks() { assert!( !session .candidate - .vm + .vm() .payload::(held, "Mount") .unwrap() .mounted ); assert!( - crate::window::pages(session.candidate.vm.object_store(), window) + crate::window::pages(session.candidate.vm().object_store(), window) .unwrap() .is_empty() ); assert_eq!( - session.candidate.vm.get_attr(marker, "value").unwrap(), + session.candidate.vm().get_attr(marker, "value").unwrap(), Value::Number(0.into()) ); assert!(session.execute("42", "app.main").is_err()); @@ -1558,11 +1560,11 @@ fn native_windows_share_business_state_move_pages_and_release_closed_contexts() ); assert!(session.execute("oldRight.bounds()", "app.main").is_err()); // 从真实全局取得副窗身份,创建弱观察句柄后删除原全局强边以检验资源可回收性。 - let globals = session.candidate.globals.unwrap(); + let globals = session.candidate.globals().unwrap(); // 读取不额外 retain Window,避免测试自己保活对象而掩盖/制造 GC 结论。 let Value::Object(window) = session .candidate - .vm + .vm() .dict_get(globals, &Value::Text("other".into())) .unwrap() .unwrap() @@ -1570,7 +1572,7 @@ fn native_windows_share_business_state_move_pages_and_release_closed_contexts() panic!("Window"); }; // 弱身份只用于回收后探测,不能因为闭窗时仍有 Rust ObjectRef 数值就延长寿命。 - let weak = session.candidate.vm.downgrade(window).unwrap(); + let weak = session.candidate.vm().downgrade(window).unwrap(); // 关闭后的最终完整文档应删除副窗,向已关闭资源 open 也必须被拒绝。 let closed = session .execute("other.close()", "app.main") @@ -1581,13 +1583,13 @@ fn native_windows_share_business_state_move_pages_and_release_closed_contexts() assert!(session.execute("right.open(other)", "app.main").is_err()); session .candidate - .vm + .vm_mut() .dict_delete(globals, &Value::Text("other".into())) .unwrap(); session.execute("0", "app.main").unwrap(); - session.candidate.vm.collect_cycles(); + session.candidate.vm_mut().collect_cycles(); // oldRight 仍可达不应通过出现的旧上下文反向保留整个 Window/desktop/Page 注册表。 - assert!(session.candidate.vm.upgrade(weak).unwrap().is_none()); + assert!(session.candidate.vm_mut().upgrade(weak).unwrap().is_none()); // 外部仍持有旧叶 Mount 时,关闭窗口的上下文也必须可释放;下一次 detach 创建新的资源编号。 let detached = session .execute("detached = right.detachToWindow()", "app.main") @@ -1689,7 +1691,7 @@ fn tab_projection_uses_page_methods_and_rejects_old_presentations() { assert!( session .bridge - .dispatch(&mut session.candidate.vm, &input) + .dispatch(session.candidate.vm_mut(), &input) .is_err() ); // 只改 second.title 后检查第二页文字更新,并核对未改动的第一页 ID;此处没有断言第二页 ID 本身不变。 @@ -1856,11 +1858,11 @@ fn closed_page_is_not_kept_alive_by_window_page_order() { ) .unwrap(); // 直接删 globals 避免用“page=nil”产生别名替换语义干扰这个生命周期断言。 - let globals = session.candidate.globals.unwrap(); + let globals = session.candidate.globals().unwrap(); // 借出身份后只建弱观察,不在测试手工 retain 新拥有根。 let Value::Object(page) = session .candidate - .vm + .vm() .dict_get(globals, &Value::Text("page".into())) .unwrap() .unwrap() @@ -1868,15 +1870,15 @@ fn closed_page_is_not_kept_alive_by_window_page_order() { panic!("Page") }; // close 解除 Window→Page 边,删除全局再收环,弱升级失败才证明没有意外保留。 - let weak = session.candidate.vm.downgrade(page).unwrap(); + let weak = session.candidate.vm().downgrade(page).unwrap(); session.execute("page.close()", "app.main").unwrap(); session .candidate - .vm + .vm_mut() .dict_delete(globals, &Value::Text("page".into())) .unwrap(); - session.candidate.vm.collect_cycles(); - assert!(session.candidate.vm.upgrade(weak).unwrap().is_none()); + session.candidate.vm_mut().collect_cycles(); + assert!(session.candidate.vm_mut().upgrade(weak).unwrap().is_none()); } #[test] @@ -1903,32 +1905,32 @@ fn source_measure_stat(session: &mut ReplSession, name: &str) -> i64 { // 布局/缓存回归共用此直接 VM 助手,绕开 Console transcript 和一次输入引起的额外刷新。 let Value::Object(function) = session .candidate - .vm + .vm() .get_attr(session.bridge.ui, "stats") .unwrap() else { panic!("stats function") }; // 返回 stats 对象有新的拥有根,读完数字字段必须显式释放,不能让观察指标自身泄漏。 - let Value::Object(stats) = session.candidate.vm.call(function, &[]).unwrap() else { + let Value::Object(stats) = session.candidate.vm_mut().call(function, &[]).unwrap() else { panic!("stats") }; // 要求确为 Number,不能将缺失字段/错误 API 值格式化成零而让缓存断言误通过。 - let Value::Number(value) = session.candidate.vm.get_attr(stats, name).unwrap() else { + let Value::Number(value) = session.candidate.vm().get_attr(stats, name).unwrap() else { panic!("stat number") }; - session.candidate.vm.release(stats).unwrap(); + session.candidate.vm_mut().release(stats).unwrap(); value.as_i64().unwrap() } /// 从 globals 中按名称找到业务 Block,再在给定完整文档中按 block_id 找对应 Mount。 /// 构造携带当前会话与该文档版本的 click,返回派发后发布的新文档,供后续动作沿新版本继续。 fn click_named(session: &mut ReplSession, document: &RenderDocument, name: &str) -> RenderDocument { // 缓存示例测试通过此助手模拟按钮点击;globals 是当前 VM 的业务对象名字表。 - let globals = session.candidate.globals.unwrap(); + let globals = session.candidate.globals().unwrap(); // 按调用方给出的名字取得 Block 引用;缺失或非对象表示测试夹具已与按钮约定不符。 let Value::Object(block) = session .candidate - .vm + .vm() .dict_get(globals, &Value::Text(name.into())) .unwrap() .unwrap() @@ -2131,11 +2133,11 @@ fn source_measure_cache_tracks_fields_of_an_existing_returned_result() { .unwrap() .id; // 从业务全局表提取 result 对象,与 measure 返回的引用保持一致。 - let globals = session.candidate.globals.unwrap(); + let globals = session.candidate.globals().unwrap(); // 要求夹具中的 result 确实是 VM 对象,便于通过 set_attr 触发写入观察。 let Value::Object(result) = session .candidate - .vm + .vm() .dict_get(globals, &Value::Text("result".into())) .unwrap() .unwrap() @@ -2145,7 +2147,7 @@ fn source_measure_cache_tracks_fields_of_an_existing_returned_result() { // 仅改已有返回对象的 width;源函数本体未读取该字段,依赖应来自返回值解码。 session .candidate - .vm + .vm_mut() .set_attr(result, "width", Value::Number(140.into())) .unwrap(); // 主动刷新消费字段变化,再检查同一 Mount 的尺寸及恰好一次缓存失效。 @@ -2214,7 +2216,7 @@ fn viewport_resize_changes_constraints_and_preserves_mount_identity_without_sour .any(|mount| mount.width == 312.0 && mount.height == 24.0) ); // resize 不计作 REPL 输入;相同视口重复通知也不应再发布文档。 - assert_eq!(session.inputs, 0); + assert_eq!(session.history.inputs(), 0); assert!( session .resize(Some(crate::layout::Size { @@ -2258,11 +2260,11 @@ fn source_layout_uses_initial_mount_links_child_measurements_and_model_dependenc // 文字的 y 坐标同时验证排列对子测量高度与间距的使用。 assert!(initial.frame.commands.iter().any(|command| matches!(command,RenderCommand::Text { value,y,.. } if value.starts_with("尺寸来自") && *y == 100.0))); // 取出示例的 Metrics 模型,直接写入源测量读过的字段。 - let globals = session.candidate.globals.unwrap(); + let globals = session.candidate.globals().unwrap(); // 夹具必须提供 Metrics 对象;类型不符应立即失败而非跳过依赖测试。 let Value::Object(metrics) = session .candidate - .vm + .vm() .dict_get(globals, &Value::Text("metrics".into())) .unwrap() .unwrap() @@ -2272,7 +2274,7 @@ fn source_layout_uses_initial_mount_links_child_measurements_and_model_dependenc // 通过 VM 字段写入通知依赖系统;没有重新执行整段页面源码。 session .candidate - .vm + .vm_mut() .set_attr(metrics, "width", Value::Number(260.into())) .unwrap(); // 刷新应重算相关几何并发布新文档。 @@ -2303,11 +2305,11 @@ fn shared_block_source_measurements_belong_to_each_occurrence() { // 在同一页面发布两个出现位置,使错误的按 Block 缓存策略可以被观察到。 let (mut session, initial) = ReplSession::load(&source, "app.main", 92, 1).unwrap(); // 从全局表取得共享 rect 的业务身份,避免按几何误匹配父容器。 - let globals = session.candidate.globals.unwrap(); + let globals = session.candidate.globals().unwrap(); // 要求共享对象存在,后续用其 ID 同时筛选两个 Mount。 let Value::Object(rect) = session .candidate - .vm + .vm() .dict_get(globals, &Value::Text("rect".into())) .unwrap() .unwrap() @@ -2492,11 +2494,11 @@ fn source_hit_rejects_wrong_result_and_business_writes_before_callbacks() { assert!(error.to_string().contains(message), "{error}"); assert!(session.is_faulted()); // 会话 faulted 后直接读取 VM,避免 execute 的停止检查遮蔽真实业务值。 - let globals = session.candidate.globals.unwrap(); + let globals = session.candidate.globals().unwrap(); // 取原 hits 状态对象,核对非法写入与 click 回调均未把零改为一。 let Value::Object(hits) = session .candidate - .vm + .vm() .dict_get(globals, &Value::Text("hits".into())) .unwrap() .unwrap() @@ -2505,7 +2507,7 @@ fn source_hit_rejects_wrong_result_and_business_writes_before_callbacks() { }; // 业务状态必须仍为零,证明写入在发生前被拒绝。 assert_eq!( - session.candidate.vm.get_attr(hits, "value").unwrap(), + session.candidate.vm().get_attr(hits, "value").unwrap(), Value::Number(0.into()) ); } @@ -2566,8 +2568,8 @@ fn collecting_lazy_helpers_does_not_invalidate_stable_layout_or_paint() { let (mut session, initial) = ReplSession::load(source, "app.main", 281, 1).unwrap(); // 显式执行桥接层回收,保留会话业务根;回收短命 helper 不应被解释为业务状态变化。 session - .bridge - .reclaim(&mut session.candidate.vm, &mut session.candidate.roots) + .candidate + .with_host(|vm, roots| session.bridge.reclaim(vm, roots)) .unwrap(); // 检查没有发布动作,再比对保存的版本,防止仅返回 None 却内部替换文档。 assert!(session.refresh_document().unwrap().is_none()); @@ -2590,12 +2592,12 @@ fn layout_and_paint_prepare_keep_only_current_occurrence_managed_helpers() { let (mut session, initial) = ReplSession::load(&resumable_paint_source(copies, 0), "app.main", 280, 1).unwrap(); // 记录开始绘制前的 VM 对象数;只计算本次准备与第一片新增的托管辅助对象。 - let before = session.candidate.vm.object_count(); + let before = session.candidate.vm().object_count(); // 对已布局的根和帧启动源绘制,避免把布局开销计入绘制阶段。 let progress = session .bridge .begin_paint_frame( - &mut session.candidate.vm, + session.candidate.vm_mut(), initial.ui_root.clone(), initial.frame, ) @@ -2606,18 +2608,22 @@ fn layout_and_paint_prepare_keep_only_current_occurrence_managed_helpers() { }; // 在首次 Pending 处检查相对 baseline 的托管对象数净增小于 256;不统计原生内存或该片中间的分配峰值。 // 两种树规模共用阈值,用于发现首次让出前为整树预建并保留 Bounds/collector 的退化。 - assert!(session.candidate.vm.object_count() < before + 256); + assert!(session.candidate.vm().object_count() < before + 256); // 取消未完成帧并检查 VM 续体释放,随后才能独立测试布局路径。 session .bridge - .cancel_paint_frame(&mut session.candidate.vm, crate::window::MAIN_WINDOW, *work) + .cancel_paint_frame( + session.candidate.vm_mut(), + crate::window::MAIN_WINDOW, + *work, + ) .unwrap(); - assert!(!session.candidate.vm.has_suspended_call()); + assert!(!session.candidate.vm().has_suspended_call()); // 改变可用视口,使接下来的布局不能直接沿用原来的约束结果。 session .bridge .set_viewport( - &mut session.candidate.vm, + session.candidate.vm_mut(), Some(crate::layout::Size { width: 900.0, height: 650.0, @@ -2627,28 +2633,28 @@ fn layout_and_paint_prepare_keep_only_current_occurrence_managed_helpers() { // 准备页面根但不一次性完成布局,后续观察 begin_layout_frame 的第一片。 let root = session .bridge - .prepare_frame(&mut session.candidate.vm) + .prepare_frame(session.candidate.vm_mut()) .unwrap() .unwrap(); // 重新取布局阶段基线,排除前一绘制测试已有对象对增长量的影响。 - let before = session.candidate.vm.object_count(); + let before = session.candidate.vm().object_count(); // 只启动布局第一片,不预先为整棵树创建 Bounds/collector。 let progress = session .bridge - .begin_layout_frame(&mut session.candidate.vm, root) + .begin_layout_frame(session.candidate.vm_mut(), root) .unwrap(); // 要求布局也实际暂停,随后检查此暂停点的托管对象数净增;这是独立布局 baseline,不累计绘制阶段。 let crate::ui_bridge::LayoutProgress::Pending(work) = progress else { panic!("layout must yield"); }; - assert!(session.candidate.vm.object_count() < before + 256); + assert!(session.candidate.vm().object_count() < before + 256); // 取消布局续体;最后同时核对暂停调用和只读范围均已关闭,避免影响后续业务执行。 session .bridge - .cancel_layout_frame(&mut session.candidate.vm, *work) + .cancel_layout_frame(session.candidate.vm_mut(), *work) .unwrap(); - assert!(!session.candidate.vm.has_suspended_call()); - assert!(!session.candidate.vm.object_store().is_read_only()); + assert!(!session.candidate.vm().has_suspended_call()); + assert!(!session.candidate.vm().object_store().is_read_only()); } } @@ -2686,7 +2692,7 @@ fn pending_paint_retargets_without_replaying_completed_mount_hooks() { .as_ref() .is_some_and(|work| work.paint.is_some()) ); - assert!(session.candidate.vm.has_suspended_call()); + assert!(session.candidate.vm().has_suspended_call()); // 绘制未完成时应继续展示初始版本,所有旧命令仍保持初始颜色。 assert_eq!( session.documents[&crate::window::MAIN_WINDOW] @@ -2705,7 +2711,7 @@ fn pending_paint_retargets_without_replaying_completed_mount_hooks() { )]); // 先只执行一次重定向,确认旧的 VM 暂停调用已被清除。 session.resize_windows_incremental(&latest, false).unwrap(); - assert!(!session.candidate.vm.has_suspended_call()); + assert!(!session.candidate.vm().has_suspended_call()); // 用同步入口推进到收敛,检查最终整帧全部为新色且没有丢失出现位置。 let settled = session.resize_windows(&latest).unwrap().unwrap(); assert_eq!(settled.frame.commands.len(), 80); @@ -2761,8 +2767,8 @@ fn paint_error_after_pause_closes_read_only_scope_and_preserves_last_picture() { // 要求两个阶段均被覆盖;故障后 VM 不能残留暂停调用或只读范围。 assert!(paused && failed); assert!(session.is_faulted()); - assert!(!session.candidate.vm.has_suspended_call()); - assert!(!session.candidate.vm.object_store().is_read_only()); + assert!(!session.candidate.vm().has_suspended_call()); + assert!(!session.candidate.vm().object_store().is_read_only()); // 对外仍保留最后成功发布的版本和颜色,不暴露无效颜色生成的半帧。 assert_eq!( session.documents[&crate::window::MAIN_WINDOW] @@ -2821,11 +2827,11 @@ fn source_paint_overrides_native_commands_and_reacts_to_heap_field_writes() { ) ); // 直接取得被 paint 读取的业务矩形对象,不通过重新执行页面源码来刷新。 - let globals = session.candidate.globals.unwrap(); + let globals = session.candidate.globals().unwrap(); // 对象身份必须来自原会话,使 set_attr 只改变已有字段并触发其依赖。 let Value::Object(rect) = session .candidate - .vm + .vm() .dict_get(globals, &Value::Text("rect".into())) .unwrap() .unwrap() @@ -2835,7 +2841,7 @@ fn source_paint_overrides_native_commands_and_reacts_to_heap_field_writes() { // 不经 Console、不写全局绑定、不改焦点,只改变 paint 读过的属性,单独验证该读依赖足以使帧失效。 session .candidate - .vm + .vm_mut() .set_attr(rect, "tint", Value::Text("#526AC7".into())) .unwrap(); // 仅靠写观察驱动刷新,两处共享出现位置都必须更新;再次刷新应稳定。 @@ -2873,11 +2879,11 @@ fn source_paint_rejects_business_mutation_before_it_happens_and_restores_scope() // 绘制失败应停止当前运行时;但停止状态不能替代检查写入确实没有发生。 assert!(session.is_faulted()); // 绕过已停止会话的 execute 入口,直接取原业务对象验证错误后的真实状态。 - let globals = session.candidate.globals.unwrap(); + let globals = session.candidate.globals().unwrap(); // 全局 rect 应已在 paint 前构造完毕,必须保留其原身份与字段值。 let Value::Object(rect) = session .candidate - .vm + .vm() .dict_get(globals, &Value::Text("rect".into())) .unwrap() .unwrap() @@ -2886,13 +2892,13 @@ fn source_paint_rejects_business_mutation_before_it_happens_and_restores_scope() }; // tint 仍是构造时的红色,说明非法写入在发生前被阻止,而非失败后仅停止后续回调。 assert_eq!( - session.candidate.vm.get_attr(rect, "tint").unwrap(), + session.candidate.vm().get_attr(rect, "tint").unwrap(), Value::Text("#FF0000".into()) ); // 宿主直接写字段应恢复为可写,验证异常展开已退出 paint 的只读范围。 session .candidate - .vm + .vm_mut() .set_attr(rect, "tint", Value::Text("#526AC7".into())) .unwrap(); // 另用独立加载检查无效颜色的命令解码错误,与上面的业务写入拒绝分开覆盖。 @@ -3020,7 +3026,7 @@ fn constructor_options_and_subclass_fields_have_independent_contracts() { // 从当前桥接 ui 对象取得真实函数引用,避免验证一份与实际发布函数无关的描述。 let Value::Object(function) = session .candidate - .vm + .vm() .get_attr(session.bridge.ui, name) .unwrap() else { @@ -3029,14 +3035,14 @@ fn constructor_options_and_subclass_fields_have_independent_contracts() { // 读取对象存储中绑定到该 native 函数的签名;缺失元数据也必须使测试失败。 let signature = session .candidate - .vm + .vm() .object_store() .native_signature(function) .unwrap() .expect("published UI signature"); // 使用同一 VM 类型表验证签名引用与结构,确保这些契约可由运行时实际使用。 signature - .validate(session.candidate.vm.object_store()) + .validate(session.candidate.vm().object_store()) .unwrap(); } } @@ -3533,11 +3539,11 @@ fn event_session(extra: &str) -> (ReplSession, RenderDocument) { /// 事件使用该文档的会话与布局版本,返回派发后的完整文档,避免用过期目标绕过真实输入检查。 fn click_document(session: &mut ReplSession, document: &RenderDocument) -> RenderDocument { // 事件测试助手从当前会话的名字表取得 button,保持业务身份与输入目标一致。 - let globals = session.candidate.globals.unwrap(); + let globals = session.candidate.globals().unwrap(); // 缺失或非对象说明夹具不满足约定,应直接失败而非挑选任意可交互节点。 let Value::Object(button) = session .candidate - .vm + .vm() .dict_get(globals, &Value::Text("button".into())) .unwrap() .unwrap() @@ -3731,11 +3737,11 @@ fn event_failure_releases_dispatch_guard_and_token_does_not_retain_target() { ) .unwrap(); // 取得名字表,便于准确删除 orphan,而保留 token 和其回调模型。 - let globals = session.candidate.globals.unwrap(); + let globals = session.candidate.globals().unwrap(); // 取目标对象句柄以创建弱引用;Rust 局部句柄不应成为 VM 的持久业务根。 let Value::Object(orphan) = session .candidate - .vm + .vm() .dict_get(globals, &Value::Text("orphan".into())) .unwrap() .unwrap() @@ -3743,20 +3749,20 @@ fn event_failure_releases_dispatch_guard_and_token_does_not_retain_target() { panic!("Block expected") }; // 弱句柄用于确认目标确实回收,不只检查 token 对外显示已断开。 - let weak = session.candidate.vm.downgrade(orphan).unwrap(); + let weak = session.candidate.vm().downgrade(orphan).unwrap(); // 删除 orphan 的最后显式全局强引用;不删除 token,专门检查 token 不强持有目标。 session .candidate - .vm + .vm_mut() .dict_delete(globals, &Value::Text("orphan".into())) .unwrap(); // 沿真实桥接根集合执行回收,测试弱订阅与 GC 的组合行为。 session - .bridge - .reclaim(&mut session.candidate.vm, &mut session.candidate.roots) + .candidate + .with_host(|vm, roots| session.bridge.reclaim(vm, roots)) .unwrap(); // 目标弱升级必须失败,且仍存活的 token 查询为未连接。 - assert!(session.candidate.vm.upgrade(weak).unwrap().is_none()); + assert!(session.candidate.vm_mut().upgrade(weak).unwrap().is_none()); assert_eq!( session .execute("token.isConnected()", "app.main") @@ -3797,11 +3803,11 @@ fn source_native_subclasses_share_live_fields_and_release_replaced_storage() { // 额外保留旧业务引用,替换 label 后 alias 应通过共享转发访问新的属性存储。 session.execute("alias = label", "app.main").unwrap(); // 取当前 label 对象,以其真实属性路径定位替换前的底层存储。 - let globals = session.candidate.globals.unwrap(); + let globals = session.candidate.globals().unwrap(); // 要求目标是原夹具中的 Block 对象,而非 Console 展示文本或另建实例。 let Value::Object(label) = session .candidate - .vm + .vm() .dict_get(globals, &Value::Text("label".into())) .unwrap() .unwrap() @@ -3811,14 +3817,14 @@ fn source_native_subclasses_share_live_fields_and_release_replaced_storage() { // 读取属性转发链,末尾存储是本用例要检查是否被替换并回收的对象。 let path = session .candidate - .vm + .vm() .object_store() .attribute_path(label) .unwrap(); // 只保存旧属性存储的弱句柄,避免测试本身强持有旧存储而阻止回收。 let previous = session .candidate - .vm + .vm() .downgrade(*path.last().unwrap()) .unwrap(); // 用同名源实例替换 label,首次新文档应已显示新字段内容。 @@ -3836,11 +3842,18 @@ fn source_native_subclasses_share_live_fields_and_release_replaced_storage() { )); // 回收不再从共享业务身份可达的旧存储;alias 不能让过时属性存储继续存活。 session - .bridge - .reclaim(&mut session.candidate.vm, &mut session.candidate.roots) + .candidate + .with_host(|vm, roots| session.bridge.reclaim(vm, roots)) .unwrap(); // 旧存储应消失,但 alias.message 必须仍读取替换后的 new field。 - assert!(session.candidate.vm.upgrade(previous).unwrap().is_none()); + assert!( + session + .candidate + .vm_mut() + .upgrade(previous) + .unwrap() + .is_none() + ); assert_eq!( session.execute("alias.message", "app.main").unwrap().value, "\"new field\"" @@ -3935,11 +3948,11 @@ fn scroll_occurrences_are_independent_and_clipped_pointer_input_is_ignored() { ) .unwrap(); // 从当前 VM 全局表取业务按钮,后续通过对象身份定位它的主窗口出现位置。 - let globals = session.candidate.globals.unwrap(); + let globals = session.candidate.globals().unwrap(); // middle 位于滚动内容的中段,初始未滚动时中心应被容器裁剪。 let Value::Object(middle) = session .candidate - .vm + .vm() .dict_get(globals, &Value::Text("middle".into())) .unwrap() .unwrap() @@ -4004,7 +4017,7 @@ fn scroll_occurrences_are_independent_and_clipped_pointer_input_is_ignored() { // 仍通过业务身份查找 last,避免用旧文档的过期几何判断 scrollIntoView。 let Value::Object(last) = session .candidate - .vm + .vm() .dict_get(globals, &Value::Text("last".into())) .unwrap() .unwrap() @@ -4064,11 +4077,11 @@ fn new_viewport_cancels_pending_layout_and_restores_saved_mount_context() { // 保存已挂载 Mount,并以它为 owner 注册长延时任务;任务状态用来检测是否误当卸载。 session.execute("saved = item.mounts().at(0)\nreceived = ui.state(0)\ntoken = ui.after(saved, \"keep\", 60000, received.increment)", "app.main").unwrap(); // 读取源 saved 引用,取消后直接检查其原生 Mount payload。 - let globals = session.candidate.globals.unwrap(); + let globals = session.candidate.globals().unwrap(); // 要求保留的是实际 Mount 对象;不使用重新查询出的新引用掩盖身份丢失。 let Value::Object(saved) = session .candidate - .vm + .vm() .dict_get(globals, &Value::Text("saved".into())) .unwrap() .unwrap() @@ -4087,12 +4100,12 @@ fn new_viewport_cancels_pending_layout_and_restores_saved_mount_context() { for _ in 0..20 { session.resize_windows_incremental(&first, false).unwrap(); // 观察到真实暂停调用即停止推进,避免把旧布局完成后再 resize 算作取消测试。 - if session.candidate.vm.has_suspended_call() { + if session.candidate.vm().has_suspended_call() { break; } } // 若始终未挂起则测试没有覆盖取消前提,必须失败。 - assert!(session.candidate.vm.has_suspended_call()); + assert!(session.candidate.vm().has_suspended_call()); // 以不同宽高替换未完成目标,新布局应以最新视口重新开始。 let latest = std::collections::BTreeMap::from([( crate::window::MAIN_WINDOW, @@ -4108,11 +4121,11 @@ fn new_viewport_cancels_pending_layout_and_restores_saved_mount_context() { .unwrap() .is_none() ); - assert!(!session.candidate.vm.has_suspended_call()); + assert!(!session.candidate.vm().has_suspended_call()); // 直接查看保存句柄的 payload:应恢复已挂载标志、清除临时 layout 并保留旧宽度。 let mount = session .candidate - .vm + .vm() .payload::(saved, "Mount") .unwrap(); // 取消准备工作不等于卸载;恢复状态后才继续完整收敛新布局。 @@ -4156,11 +4169,11 @@ fn candidate_initial_layout_retargets_without_reexecuting_program_or_hooks() { .resize_windows_incremental(&initial, false) .unwrap(); // 以 VM 的暂停调用作为取消前提,不能仅凭 has_pending_refresh 判断当前阶段。 - if candidate.candidate.vm.has_suspended_call() { + if candidate.candidate.vm().has_suspended_call() { break; } } - assert!(candidate.candidate.vm.has_suspended_call()); + assert!(candidate.candidate.vm().has_suspended_call()); assert!(candidate.documents.is_empty()); // 替换候选尚未发布的布局目标;仍沿用已经执行好的业务对象和钩子进度。 let latest = std::collections::BTreeMap::from([( @@ -4174,7 +4187,7 @@ fn candidate_initial_layout_retargets_without_reexecuting_program_or_hooks() { candidate .resize_windows_incremental(&latest, false) .unwrap(); - assert!(!candidate.candidate.vm.has_suspended_call()); + assert!(!candidate.candidate.vm().has_suspended_call()); // 最后一个宽 2 的子项位于 79×2=158;正确几何之外还要核对程序仅构建一次、挂载恰好 80 次。 let settled = candidate.resize_windows(&latest).unwrap().unwrap(); assert_eq!(settled.frame.mounts.last().unwrap().x, 158.0); @@ -4227,11 +4240,11 @@ fn incremental_input_retains_value_and_never_replays_source_while_retargeting() for _ in 0..20 { session.resize_windows_incremental(&first, false).unwrap(); // 只在 VM 实际挂起时结束推进,保证换视口取消的是活跃工作。 - if session.candidate.vm.has_suspended_call() { + if session.candidate.vm().has_suspended_call() { break; } } - assert!(session.candidate.vm.has_suspended_call()); + assert!(session.candidate.vm().has_suspended_call()); // 旧版本在未完成期间仍对外可见;输入结果和对外文档分别管理。 assert_eq!( session.documents[&crate::window::MAIN_WINDOW] @@ -4361,11 +4374,11 @@ fn large_intrinsic_layout_yields_and_retargets_without_geometry_loss() { for _ in 0..20 { session.resize_windows_incremental(&first, false).unwrap(); // 暂停一旦出现就停止本轮推进,保留未完成工作供新视口替换。 - if session.candidate.vm.has_suspended_call() { + if session.candidate.vm().has_suspended_call() { break; } } - assert!(session.candidate.vm.has_suspended_call()); + assert!(session.candidate.vm().has_suspended_call()); // 旧帧版本仍可见,说明原生布局的中间几何未提前发布。 assert_eq!( session.documents[&crate::window::MAIN_WINDOW] @@ -4383,7 +4396,7 @@ fn large_intrinsic_layout_yields_and_retargets_without_geometry_loss() { )]); // 先触发取消并检查旧暂停已清除,再继续完成新布局。 session.resize_windows_incremental(&latest, false).unwrap(); - assert!(!session.candidate.vm.has_suspended_call()); + assert!(!session.candidate.vm().has_suspended_call()); // 最终仍为 x=158、width=2;取消一次且布局跨多片,证明不是绕开分片直接复用旧帧。 let settled = session.resize_windows(&latest).unwrap().unwrap(); assert_eq!(settled.frame.mounts.last().unwrap().x, 158.0); @@ -4534,7 +4547,7 @@ fn bridge_layout_can_return_pending_before_committing_a_complete_frame() { session .bridge .set_viewport( - &mut session.candidate.vm, + session.candidate.vm_mut(), Some(crate::layout::Size { width: 500.0, height: 300.0, @@ -4544,20 +4557,20 @@ fn bridge_layout_can_return_pending_before_committing_a_complete_frame() { // 只准备根节点,后续 begin_layout_frame 才启动可分片布局。 let root = session .bridge - .prepare_frame(&mut session.candidate.vm) + .prepare_frame(session.candidate.vm_mut()) .unwrap() .unwrap(); // 保存工作枚举所有权,每次 Pending 都要把续体重新交回 resume。 let mut progress = session .bridge - .begin_layout_frame(&mut session.candidate.vm, root) + .begin_layout_frame(session.candidate.vm_mut(), root) .unwrap(); // 首次必须为 Pending 且 VM 有暂停调用,否则未测到桥接的恢复契约。 assert!(matches!( progress, crate::ui_bridge::LayoutProgress::Pending(_) )); - assert!(session.candidate.vm.has_suspended_call()); + assert!(session.candidate.vm().has_suspended_call()); // 按返回状态继续推进,只有 Complete 分支允许读取最终几何。 // 此 loop 没有测试侧轮数/墙钟截止时间,终止依赖真实 VM/布局预算与完成契约;不能称作有界轮询助手。 loop { @@ -4567,13 +4580,13 @@ fn bridge_layout_can_return_pending_before_committing_a_complete_frame() { crate::ui_bridge::LayoutProgress::Pending(pending) => { progress = session .bridge - .resume_layout_frame(&mut session.candidate.vm, *pending) + .resume_layout_frame(session.candidate.vm_mut(), *pending) .unwrap(); } // 最后子项位置为 39×2=78;完成后 VM 不得遗留暂停调用。 crate::ui_bridge::LayoutProgress::Complete(frame) => { assert_eq!(frame.mounts.last().unwrap().x, 78.0); - assert!(!session.candidate.vm.has_suspended_call()); + assert!(!session.candidate.vm().has_suspended_call()); break; } } @@ -6678,16 +6691,16 @@ returned = button.dispatch(dispatched)"#, "\"click\"" ); // 直接读 VM 全局字典里的 Value,比 repr 更严格地比较 returned 与 dispatched 是否为同一托管对象。 - let globals = session.candidate.globals.unwrap(); + let globals = session.candidate.globals().unwrap(); assert_eq!( session .candidate - .vm + .vm() .dict_get(globals, &Value::Text("returned".into())) .unwrap(), session .candidate - .vm + .vm() .dict_get(globals, &Value::Text("dispatched".into())) .unwrap() ); @@ -6730,11 +6743,11 @@ fn native_visual_identity_accepts_shared_window_registries_only() { // 真实 Window 构造注册第二窗口,不手工拼造一个看似相同的 desktop。 session.execute("second = Window()", "app.main").unwrap(); // 从全局取得第二窗口,沿其 ManagedWindow payload 找到实际所属 desktop。 - let globals = session.candidate.globals.unwrap(); + let globals = session.candidate.globals().unwrap(); // 必须为真实 Window 对象,保证后面的注册表比较来自正常窗口生命周期。 let Value::Object(window) = session .candidate - .vm + .vm() .dict_get(globals, &Value::Text("second".into())) .unwrap() .unwrap() @@ -6742,7 +6755,7 @@ fn native_visual_identity_accepts_shared_window_registries_only() { panic!("window") }; // 后续只操作候选 VM,统一使用它的对象存储来查询类型与原生方法身份。 - let vm = &mut session.candidate.vm; + let vm = session.candidate.vm_mut(); // 第二窗口记录的 desktop 是合法共享范围,不能用窗口对象自身替代注册表 owner。 let desktop = vm .payload::(window, "Window") @@ -6797,11 +6810,11 @@ fn replacing_base_visual_methods_changes_layout_and_same_identity_paint() { page.render(rect) "#, "app.main", 235, 1).unwrap(); // 名字表保存基类与 Hooks 类型,后续只提取句柄,不重新执行类定义。 - let globals = session.candidate.globals.unwrap(); + let globals = session.candidate.globals().unwrap(); // 本地查询闭包要求所有目标均为对象;它只读全局字典,不建立新业务实例。 let get = |name: &str| match session .candidate - .vm + .vm() .dict_get(globals, &Value::Text(name.into())) .unwrap() .unwrap() @@ -6816,17 +6829,17 @@ fn replacing_base_visual_methods_changes_layout_and_same_identity_paint() { // 备用 Hooks 提供 width=140 的 measure 和返回空列表的 paint 两个源实现。 let hooks = get("Hooks"); // 取待安装的源 measure 函数,类型不符表示夹具破坏。 - let Value::Object(measure) = session.candidate.vm.get_attr(hooks, "measure").unwrap() else { + let Value::Object(measure) = session.candidate.vm().get_attr(hooks, "measure").unwrap() else { panic!("measure") }; // 保留备用源 paint,稍后通过 native 转发器调用而不是直接替换函数引用。 - let Value::Object(paint) = session.candidate.vm.get_attr(hooks, "paint").unwrap() else { + let Value::Object(paint) = session.candidate.vm().get_attr(hooks, "paint").unwrap() else { panic!("paint") }; // 直接替换 Block.measure 定义,已有 rect 的下一次刷新也必须读取新实现。 session .candidate - .vm + .vm_mut() .define_method(base, "measure", measure) .unwrap(); // 刷新消费方法变更,再从同一 rect 的 Mount 核对宽度已变为 140。 @@ -6841,7 +6854,7 @@ fn replacing_base_visual_methods_changes_layout_and_same_identity_paint() { // 取得原 Block.paint 的函数对象,接下来刻意保持其 ObjectRef 不变。 let original = session .candidate - .vm + .vm() .object_store() .lookup_method(base, "paint") .unwrap() @@ -6849,7 +6862,7 @@ fn replacing_base_visual_methods_changes_layout_and_same_identity_paint() { // 沿用原 paint 签名,只更换 native payload,检验缓存是否跟踪实现版本而非仅句柄。 let signature = session .candidate - .vm + .vm() .object_store() .native_signature(original) .unwrap() @@ -6857,7 +6870,7 @@ fn replacing_base_visual_methods_changes_layout_and_same_identity_paint() { // 转发器返回 Invoke 到 Hooks.paint,roots 中的 paint 保活目标;原函数身份仍相同。 session .candidate - .vm + .vm_mut() .replace_payload( original, endor_core::ContextNativeFunction::new( @@ -6894,11 +6907,11 @@ fn same_identity_event_payload_changes_invalidate_interactivity_cache() { ) .unwrap(); // 从同一全局表取基类、备用 Hooks 与待检查矩形。 - let globals = session.candidate.globals.unwrap(); + let globals = session.candidate.globals().unwrap(); // 只读对象查询闭包供本测试局部复用,任何非对象目标都应立即失败。 let get = |name: &str| match session .candidate - .vm + .vm() .dict_get(globals, &Value::Text(name.into())) .unwrap() .unwrap() @@ -6915,11 +6928,11 @@ fn same_identity_event_payload_changes_invalidate_interactivity_cache() { // 待快照对象起初没有有效交互行为,更新后应被识别为可交互。 let rect = get("rect"); // 取备用源回调作为 VisualRedirect 的目标,后面保持引用可达。 - let Value::Object(target) = session.candidate.vm.get_attr(hooks, "onEvent").unwrap() else { + let Value::Object(target) = session.candidate.vm().get_attr(hooks, "onEvent").unwrap() else { panic!("onEvent") }; // 借用候选 VM 统一执行方法查询、payload 变更与 changes 收集。 - let vm = &mut session.candidate.vm; + let vm = session.candidate.vm_mut(); // 取原 onEvent 函数;修改 payload 而非替换这个函数身份。 let function = vm .object_store() @@ -6993,7 +7006,7 @@ fn source_effect_queries_use_compiled_instructions_without_running_functions() { ) .unwrap(); // 从实际编译后的全局对象取函数句柄,分析对象存储中的指令与调用关系。 - let globals = session.candidate.globals.unwrap(); + let globals = session.candidate.globals().unwrap(); // 只读直返、可解析转调和无写入递归应识别 ReadOnly;未知回调和业务写入都不能证明只读,返回 None。 for (name, expected) in [ ("simple", Some(endor_core::CallEffect::ReadOnly)), @@ -7005,7 +7018,7 @@ fn source_effect_queries_use_compiled_instructions_without_running_functions() { // 每次取同一 VM 中真实源函数,类型不符即失败,不能跳过某一分析场景。 let Value::Object(function) = session .candidate - .vm + .vm() .dict_get(globals, &Value::Text(name.into())) .unwrap() .unwrap() @@ -7016,7 +7029,7 @@ fn source_effect_queries_use_compiled_instructions_without_running_functions() { assert_eq!( session .candidate - .vm + .vm() .object_store() .call_effect(function) .unwrap(), @@ -7026,7 +7039,7 @@ fn source_effect_queries_use_compiled_instructions_without_running_functions() { // 取具体接收者,绑定方法的 self 类型与 helper 查找都由该对象提供上下文。 let Value::Object(model) = session .candidate - .vm + .vm() .dict_get(globals, &Value::Text("model".into())) .unwrap() .unwrap() @@ -7034,29 +7047,34 @@ fn source_effect_queries_use_compiled_instructions_without_running_functions() { panic!("model") }; // bind_attr 生成捕获 model 的方法,静态分析因能解析 self.helper 而可判定只读。 - let Value::Object(bound) = session.candidate.vm.bind_attr(model, "check").unwrap() else { + let Value::Object(bound) = session + .candidate + .vm_mut() + .bind_attr(model, "check") + .unwrap() + else { panic!("bound") }; assert_eq!( session .candidate - .vm + .vm() .object_store() .call_effect(bound) .unwrap(), Some(endor_core::CallEffect::ReadOnly) ); // 释放 bind_attr 返回的临时拥有引用,不把分析用绑定方法长期留在 VM 根中。 - session.candidate.vm.release(bound).unwrap(); + session.candidate.vm_mut().release(bound).unwrap(); // get_attr 取未绑定方法;没有具体接收者时对 self.helper 的解析应保守返回未知。 - let Value::Object(unbound) = session.candidate.vm.get_attr(model, "check").unwrap() else { + let Value::Object(unbound) = session.candidate.vm().get_attr(model, "check").unwrap() else { panic!("method") }; - assert_eq!(session.candidate.vm.call_effect(unbound).unwrap(), None); + assert_eq!(session.candidate.vm().call_effect(unbound).unwrap(), None); // 保留原 forward 函数身份,随后只重绑它在全局中读取的 simple,检验分析依赖失效。 let Value::Object(forward) = session .candidate - .vm + .vm() .dict_get(globals, &Value::Text("forward".into())) .unwrap() .unwrap() @@ -7065,11 +7083,11 @@ fn source_effect_queries_use_compiled_instructions_without_running_functions() { }; // 将被调全局名改指向写状态函数,forward 不再能被证明只读。 session.execute("simple = impure", "app.main").unwrap(); - assert_eq!(session.candidate.vm.call_effect(forward).unwrap(), None); + assert_eq!(session.candidate.vm().call_effect(forward).unwrap(), None); // 恢复原绑定后应重新识别 ReadOnly,避免未知结果被永久缓存。 session.execute("simple = original", "app.main").unwrap(); assert_eq!( - session.candidate.vm.call_effect(forward).unwrap(), + session.candidate.vm().call_effect(forward).unwrap(), Some(endor_core::CallEffect::ReadOnly) ); // marker 必须始终为零,证明所有效果查询及失效重算都没有执行 impure 的函数体。 @@ -7093,11 +7111,11 @@ fn typed_method_shadows_invalidate_cached_ancestors_and_can_be_removed() { ) .unwrap(); // 取当前业务对象句柄,不重新构造树来制造失效。 - let globals = session.candidate.globals.unwrap(); + let globals = session.candidate.globals().unwrap(); // 局部只读查询闭包要求命名值是对象,供 rect/root 两次查找复用。 let lookup = |name: &str| match session .candidate - .vm + .vm() .dict_get(globals, &Value::Text(name.into())) .unwrap() .unwrap() @@ -7124,7 +7142,7 @@ fn typed_method_shadows_invalidate_cached_ancestors_and_can_be_removed() { ); } // 后续故意在原始属性存储层制造坏状态,以覆盖快照的防御性验证和缓存失效。 - let vm = &mut session.candidate.vm; + let vm = session.candidate.vm_mut(); // 沿属性转发链找到末尾实际存储,向它写入可绕过实例层的 typed method 阴影检查。 let storage = *vm .object_store() @@ -7234,11 +7252,11 @@ fn presentable_dispatch_preserves_source_identity_and_reactive_display() { // 先确认自定义展示已生成预期文字,排除走默认回退却误通过身份检查。 assert!(initial.frame.commands.iter().any(|command| matches!(command,RenderCommand::Text { value, .. } if value == "普通对象的显式展示能力"))); // 从同一名字表取原业务 product 和生成的视图,直接比较 VM 对象身份。 - let globals = session.candidate.globals.unwrap(); + let globals = session.candidate.globals().unwrap(); // 原 Product 是展示能力的接收者,后续 view.source 必须指回它。 let Value::Object(product) = session .candidate - .vm + .vm() .dict_get(globals, &Value::Text("product".into())) .unwrap() .unwrap() @@ -7248,7 +7266,7 @@ fn presentable_dispatch_preserves_source_identity_and_reactive_display() { // 视图是可挂载的 Block,不能把复制出来的展示数据当作业务源对象。 let Value::Object(view) = session .candidate - .vm + .vm() .dict_get(globals, &Value::Text("view".into())) .unwrap() .unwrap() @@ -7257,7 +7275,7 @@ fn presentable_dispatch_preserves_source_identity_and_reactive_display() { }; // source 字段需保存同一 ObjectRef;另用 supports 检查公开能力判定。 assert_eq!( - session.candidate.vm.get_attr(view, "source").unwrap(), + session.candidate.vm().get_attr(view, "source").unwrap(), Value::Object(product) ); assert_eq!( @@ -7544,11 +7562,11 @@ fn source_render_caches_do_not_root_a_page_block_waiting_frame_cycle() { "\"running\"" ); // 取 holder 中保留的临时页面,创建弱观察句柄而不添加新的持久根。 - let globals = session.candidate.globals.unwrap(); + let globals = session.candidate.globals().unwrap(); // holder 是外部状态容器,value 指向要释放的临时 Page。 let Value::Object(holder) = session .candidate - .vm + .vm() .dict_get(globals, &Value::Text("holder".into())) .unwrap() .unwrap() @@ -7556,19 +7574,29 @@ fn source_render_caches_do_not_root_a_page_block_waiting_frame_cycle() { panic!("holder") }; // 取 Page 原身份,关闭与清理后应无法通过弱句柄升级。 - let Value::Object(page) = session.candidate.vm.get_attr(holder, "value").unwrap() else { + let Value::Object(page) = session.candidate.vm().get_attr(holder, "value").unwrap() else { panic!("page") }; // 解析页面内容树的第一个 CycleRect,同时观察页面与子项是否都能回收。 - let rect = crate::block::resolve(session.candidate.vm.object_store(), page) + let rect = crate::block::resolve(session.candidate.vm().object_store(), page) .unwrap() .1 .children[0] .block; // 页面弱引用仅作检查,不应成为回收根。 - let page_weak = session.candidate.vm.object_store().downgrade(page).unwrap(); + let page_weak = session + .candidate + .vm() + .object_store() + .downgrade(page) + .unwrap(); // 子项也用弱引用检查,防止只回收页面而缓存仍意外保留业务 Block。 - let rect_weak = session.candidate.vm.object_store().downgrade(rect).unwrap(); + let rect_weak = session + .candidate + .vm() + .object_store() + .downgrade(rect) + .unwrap(); // 仅关闭展示不等于释放业务引用,pending 仍 running;不能把这种存活误判为缓存泄漏。 // 示例 spawn/sleep 的 owner 是 CycleRect,不是 Page;Page.close 不取消仍由业务引用保留的这个 owner。 session.execute("holder.value.close()", "app.main").unwrap(); @@ -7588,8 +7616,22 @@ fn source_render_caches_do_not_root_a_page_block_waiting_frame_cycle() { .value, baseline ); - assert!(session.candidate.vm.upgrade(page_weak).unwrap().is_none()); - assert!(session.candidate.vm.upgrade(rect_weak).unwrap().is_none()); + assert!( + session + .candidate + .vm_mut() + .upgrade(page_weak) + .unwrap() + .is_none() + ); + assert!( + session + .candidate + .vm_mut() + .upgrade(rect_weak) + .unwrap() + .is_none() + ); } #[test] @@ -7618,11 +7660,11 @@ fn binding_tokens_do_not_retain_hidden_targets_and_compute_is_read_only() { ) .unwrap(); // 保留名字表以删除 rect 的强全局引用,同时继续保留 token 和 model。 - let globals = session.candidate.globals.unwrap(); + let globals = session.candidate.globals().unwrap(); // 取得原隐藏 rect 的真实身份,后续不能用另建目标代替 GC 观察。 let Value::Object(target) = session .candidate - .vm + .vm() .dict_get(globals, &Value::Text("rect".into())) .unwrap() .unwrap() @@ -7632,19 +7674,19 @@ fn binding_tokens_do_not_retain_hidden_targets_and_compute_is_read_only() { // 弱句柄用于证明目标真正消失,token 不能反向强持有该对象。 let weak = session .candidate - .vm + .vm() .object_store() .downgrade(target) .unwrap(); // 删除 rect 的全局根,随后显式循环回收,token 仍留在 globals。 session .candidate - .vm + .vm_mut() .dict_delete(globals, &Value::Text("rect".into())) .unwrap(); // 回收后目标弱升级失败且 token.isConnected=false,验证弱连接清理。 - session.candidate.vm.collect_cycles(); - assert!(session.candidate.vm.upgrade(weak).unwrap().is_none()); + session.candidate.vm_mut().collect_cycles(); + assert!(session.candidate.vm_mut().upgrade(weak).unwrap().is_none()); assert_eq!( session .execute("token.isConnected()", "app.main") @@ -7665,7 +7707,7 @@ fn binding_tokens_do_not_retain_hidden_targets_and_compute_is_read_only() { // 会话 faulted 后直接读取 VM 的 model;不能用普通 execute 查询遮蔽原值检查。 let Value::Object(model) = session .candidate - .vm + .vm() .dict_get(globals, &Value::Text("model".into())) .unwrap() .unwrap() @@ -7674,7 +7716,7 @@ fn binding_tokens_do_not_retain_hidden_targets_and_compute_is_read_only() { }; // width 仍为 80,证明错误没有先执行写入再停止后续工作。 assert_eq!( - session.candidate.vm.get_attr(model, "width").unwrap(), + session.candidate.vm().get_attr(model, "width").unwrap(), Value::Number(80.into()) ); } @@ -7722,11 +7764,11 @@ fn closing_a_page_releases_its_root_without_retaining_it_through_shared_content( ) .unwrap(); // 后面只删 page 名字,刻意保留 card,以分离页面回收与共享内容存活。 - let globals = session.candidate.globals.unwrap(); + let globals = session.candidate.globals().unwrap(); // 取原页面身份,弱观察对象必须是这次已挂载的 Page。 let Value::Object(page) = session .candidate - .vm + .vm() .dict_get(globals, &Value::Text("page".into())) .unwrap() .unwrap() @@ -7734,7 +7776,7 @@ fn closing_a_page_releases_its_root_without_retaining_it_through_shared_content( panic!("expected Page") }; // 弱句柄不增加页面持久根,最终可检查闭环引用是否释放。 - let weak = session.candidate.vm.downgrade(page).unwrap(); + let weak = session.candidate.vm().downgrade(page).unwrap(); // 第一次关闭后仍保留 page 全局引用,允许修改隐藏内容并重开验证页面可复用。 session.execute("page.close()", "app.main").unwrap(); // 隐藏时改原 card,后面只要求重开返回文档;此用例没有断言新文档命令一定采用 #FFEEDD。 @@ -7753,19 +7795,19 @@ fn closing_a_page_releases_its_root_without_retaining_it_through_shared_content( // 只删除页面全局引用,card 全局引用继续保留。 session .candidate - .vm + .vm_mut() .dict_delete(globals, &Value::Text("page".into())) .unwrap(); // 沿真实桥接根集合回收,Page 弱升级必须失败而 card 仍可从 globals 找到。 session - .bridge - .reclaim(&mut session.candidate.vm, &mut session.candidate.roots) + .candidate + .with_host(|vm, roots| session.bridge.reclaim(vm, roots)) .unwrap(); - assert!(session.candidate.vm.upgrade(weak).unwrap().is_none()); + assert!(session.candidate.vm_mut().upgrade(weak).unwrap().is_none()); assert!( session .candidate - .vm + .vm() .dict_get(globals, &Value::Text("card".into())) .unwrap() .is_some() @@ -8448,18 +8490,18 @@ pending = ui.sleep(ui,"pending",30000) /// 直接读取退出测试中的 log 托管状态,不通过 execute,因关闭后普通输入已经被禁止。 fn exit_log(session: &ReplSession) -> Value { // 退出测试调用此助手,直接读取仍保留的业务全局,不经过已禁止输入的 execute。 - let globals = session.candidate.globals.unwrap(); + let globals = session.candidate.globals().unwrap(); // 要求夹具中的 log 存在且为状态对象,避免关闭后缺失日志被当作零。 let Some(Value::Object(log)) = session .candidate - .vm + .vm() .dict_get(globals, &Value::Text("log".into())) .unwrap() else { panic!("log") }; // 只读 value 用于比较 onUnmount 执行次数,不恢复或推进任何源代码。 - session.candidate.vm.get_attr(log, "value").unwrap() + session.candidate.vm().get_attr(log, "value").unwrap() } #[test] diff --git a/src/runtime/mod.rs b/src/runtime/mod.rs index 3d3d18c..7989d91 100644 --- a/src/runtime/mod.rs +++ b/src/runtime/mod.rs @@ -1,22 +1,19 @@ //! 运行时模块入口。VM 生命周期、API、源程序组织、事件与异步任务在这里组合。 //! main 调用 api::start 建立服务;worker 通过 endor_host 操作所属 VM,events 客户端将原生输入排队交付。 //! 任务后台只完成纯数据 I/O,结果是否仍可交付以及如何回到源回调,由串行运行时检查和推进。 +//! 通用源码/编译、持久输入执行、VM 根清理、任务、I/O 和驱动实现逐步移入 Nexus;这里保留应用组合与兼容适配路径。 //! // 目录确定模块归属;main 中的 crate 根别名保持内部调用路径稳定。 /// 提供 HTTP 路由、有界请求队列与串行 worker,协调候选 VM 和已发布 namespace。 pub(crate) mod api; -/// 拥有真实 Aster VM 会话,组合源执行、增量刷新、事件、任务和资源清理。 +/// 通过 Nexus VmSession 持有真实 Aster VM,适配 UI 源执行、增量刷新、事件、任务和资源清理。 pub(crate) mod endor_host; -/// 识别并组织 Endor 源输入,保留原始诊断位置,支持脚本和兼容入口形式。 -pub(crate) mod endor_script; /// 在 VM 中执行捕获/目标/冒泡路由,处理监听器断开、传播停止与事件结果。 /// 监听器错误会中断序列;末尾 Finish 是正常路径步骤,不是确保异常后仍运行的 finally。 pub(crate) mod event_dispatch; /// 定义原生输入信封与有界客户端,将窗口输入送往运行时而不跨线程调用源函数。 pub(crate) mod events; -/// 执行后台文件/HTTP 文本读取,使用租约拒绝取消后的交付;后台不操作 VM 对象。 -pub(crate) mod io_tasks; -/// 维护 owner/key 任务身份、定时器、协作执行与 await 依赖,统一处理替换和取消。 +/// 为 Nexus 任务引擎适配 UI owner 作用域、窗口页面资格及 Task 类型,保留原安装/取消入口。 pub(crate) mod tasks; -/// 封装可恢复 VM 工作的推进次序,使源布局/绘制在预算内保留同一续体而不重放。 +/// 为 Nexus 的调用序列驱动适配桌面 Function 类型,使布局/绘制保留同一续体而不重放。 pub(crate) mod vm_sequence; diff --git a/src/runtime/tasks.rs b/src/runtime/tasks.rs index 267fe08..fd587e6 100644 --- a/src/runtime/tasks.rs +++ b/src/runtime/tasks.rs @@ -1,155 +1,15 @@ -//! owner/key 管理的异步任务与协作式源函数调度。弱索引用于查找,回调、等待对象和协程帧是托管图中的真实边。 -//! 任务可能处于等待 I/O、定时器、可执行协程或等待另一任务的状态;取消 owner/key 不能让晚到结果再次执行。 -//! 调度使用有界量子和公平推进;await 挂起后保留操作数与帧,不重放此前副作用。失败和依赖环有明确处理路径。 -//! -//! ui_bridge::bootstrap 调用 install,注册 ui.after/sleep/readText/fetchText/spawn 并取得每 VM 的 Scheduler。 -//! 源 API 经 After 创建 Task;UiBridge/endor_host 的轮询调用 Scheduler::poll,才在所属 VM 交付结果或推进协程。 -//! 页面/窗口关闭调用 cancel_owner,运行时退出调用 quiesce;只取消身份和执行边,不允许旧 I/O 结果复活它们。 -//! 这里同时含通用调度和 Tessera 展示资格检查,未来迁移 Nexus 时需将 scope/eligible 的 UI 规则留在宿主适配中。 -//! -//! 一次交付需要三项同时成立:Task 仍处于可推进状态、owner 仍有宿主资格、owner/key 字典仍指向这个精确 Task。 -//! eligible 只检查宿主资格,current 只检查同键身份,不能互相替代;Task.status/active 的查询也使用同一划分。 -//! poll 先把邮箱纯数据转入 Task,再按工作预算轮转;advance_coroutine 保存 await/软挂起状态,finish 才清理执行边。 -//! Completed/Failed 的 token 可由源变量继续持有和查询;finish 撤销仍匹配的 owner/key 边,prune 在轮末移除终态弱索引。 -use std::{ - sync::{ - Arc, Mutex, - atomic::{AtomicBool, Ordering}, - }, - time::{Duration, Instant}, -}; - -use anyhow::{Result, bail}; -use endor_core::{ - ContextNativeFunction, NativeCallable, NativeContext, NativeResult, ObjectPayload, ObjectRef, - ObjectStore, Value, Vm, VmError, WeakObjectRef, -}; - +//! Tessera 的任务宿主策略:保存 Block/Mount/Window 作用域并检查窗口页面资格。 +//! 通用调度、协程与 owner/key 身份维护在 Nexus;现有调用路径通过本模块转接。 use crate::{block::Block, mount::Mount, ui_bridge::desktop_type, window::ManagedWindow}; +use anyhow::Result; +use endor_core::{NativeContext, ObjectRef, ObjectStore, Value, Vm, VmError}; +use std::sync::Arc; -// 普通对象的私有任务字典属性名;Block/Mount/Window 则把同一拥有关系保存在宿主 payload。 +pub use nexus::tasks::Scheduler; + +// 普通业务对象用私有属性,UI payload 则持有受 trace 管理的任务字典边。 const SCOPE: &str = "\0tessera.tasks"; -// 单 VM 弱调度索引的活任务预算;已完成任务可被源变量持有,但不继续占调度槽。 -const MAX_TASKS: usize = 1024; -// 单 owner 作用域字典的项数上限;同 key 替换不新增一项,允许在满额度时进行。 -const MAX_OWNER_TASKS: usize = 64; -// 一轮 poll 最多完成/推进/取消的工作数,避免任务队列独占 VM worker。 -const MAX_READY: usize = 64; -// 调度器只保存弱任务身份,不因排队把任务、回调或 owner 隐式保活。 -type Index = Arc>>; - -#[derive(Debug, Clone, Copy, PartialEq, Eq)] -/// 任务对源代码可见的生命周期状态,完成/取消/失败各有不同 await 语义。 -enum State { - // 等截止时间、I/O 或首次推进;不表示后台操作尚未开始。 - Pending, - // 普通回调正在执行,或协作任务已有保存的协程,仍可能处于 await 等待。 - Running, - // 正常终态,允许 await/result 读取保存的结果或 Nil。 - Completed, - // 失去 owner/key 资格或主动取消的终态,await 应报告 AwaitCancelled。 - Cancelled, - // provider/回调/协程失败,error 保存诊断而非可当作成功值交付的文字。 - Failed, -} -impl State { - /// Task.status 方法调用,返回稳定的小写 API 状态字符串,不用于控制调度分支。 - fn name(self) -> &'static str { - match self { - Self::Pending => "pending", - Self::Running => "running", - Self::Completed => "completed", - Self::Cancelled => "cancelled", - Self::Failed => "failed", - } - } -} - -#[derive(Debug, Clone)] -/// 托管异步对象,保存 owner/key、结果与真正拥有的回调/协程/等待引用。 -struct Task { - // owner 通过 scope 字典强持有 Task,Task 的 owner 字段反向使用弱边;callback/协程仍可能形成由 GC 处理的真实引用环。 - owner: WeakObjectRef, - // owner 内唯一键,作用域字典决定它是否仍是当前任务;不是跨运行时的全局 ID。 - key: String, - // 单调时钟截止点;ready 与到期是两个独立条件,I/O 完成不受系统日期调整影响。 - due: Instant, - // 定时/I/O 的零参回调或 spawn 的初始函数,由 trace 声明真实强边。 - callback: Option, - // 真实执行状态;只读 status 可能因失去资格投影为 cancelled,而不立刻改写此字段。 - state: State, - // 定时/协作任务创建即 ready,但仍等 due;I/O 任务等 provider 结果写回后才 ready。 - ready: bool, - // I/O 成功纯文本,普通回调执行期间也可通过 Task.result 查询;非托管字符串不需 trace。 - text: Option>, - // provider/执行失败的有界预览,Completed 的成功值不能与此混用。 - error: Option>, - // 仅任务 payload 持有 I/O 租约;取消/终态清除此边即可撤销后台交付并归还额度。 - lease: Option>, - // 仅 spawn 为 true:使用可恢复 Coroutine 和软量子,其余回调一次有界调用完成。 - cooperative: bool, - // spawn 首次推进创建的托管协程帧,后续 resume 保留此前副作用与累计硬预算。 - coroutine: Option, - // 协程 await 的对象是真实托管强边;等待期间由它保活被等待值,不以弱调度索引代替。 - waiting: Option, - // 协程最终返回的任意语言值;对象结果也经 trace 保活,取消时清掉。 - result: Option, -} -impl ObjectPayload for Task { - /// 提供受检查的 Any 下转型入口,让宿主按具体 payload 类型读取数据。 - fn as_any(&self) -> &dyn std::any::Any { - self - } - /// 返回运行时诊断/类型检查使用的稳定 payload 名称。 - fn kind_name(&self) -> &'static str { - "tessera-task" - } - /// 声明此 payload 的赋值遵循引用身份语义,避免把内部宿主状态当作可复制值。 - fn reference_assignment_only(&self) -> bool { - true - } - /// Aster 的 await 执行和 Scheduler 的等待检查调用,查询状态而不递归推进任务或 VM。 - fn poll_await(&self) -> Result { - match self.state { - // I/O 已收到 ready 文本但尚未真正处理到终态时,await 仍不能抢先越过回调。 - State::Pending | State::Running => Ok(endor_core::AwaitPoll::Pending), - // 协作任务优先返回保存的任意 Value,I/O 返回 text,普通定时器默认为 Nil。 - State::Completed => Ok(endor_core::AwaitPoll::Ready( - self.result.clone().unwrap_or_else(|| { - // 协作返回值优先,否则 I/O 文本转语言字符串,纯计时器/sleep 无值则返回 Nil。 - self.text - .as_ref() - .map(|text| Value::Text(text.to_string())) - .unwrap_or(Value::Nil) - }), - )), - State::Cancelled => Err(VmError::AwaitCancelled), - State::Failed => Err(VmError::AwaitFailed( - self.error.as_deref().unwrap_or("task failed").into(), - )), - } - } - /// 枚举本对象真正拥有的托管强引用,供 Aster 引用追踪和循环回收使用。 - fn trace(&self, visit: &mut dyn FnMut(ObjectRef)) { - // Aster GC 只追踪真实拥有边,owner/调度索引的弱身份均不得在这里访问。 - if let Some(callback) = self.callback { - visit(callback); - } - if let Some(coroutine) = self.coroutine { - // spawn 的保存帧是真实拥有边,包含已执行到的位置和局部值;不能靠弱索引让挂起帧碰巧存活。 - visit(coroutine); - } - if let Some(waiting) = self.waiting { - // await 的目标在等待期间必须可达,取消或 finish 会清此边;它与 coroutine 自身的身份不同。 - visit(waiting); - } - if let Some(Value::Object(result)) = self.result { - // 成功协程可返回任意对象,Task.result 要在外层创建根释放后继续拥有它;标量结果无托管边可追踪。 - visit(result); - } - } -} /// API 解码和 Task 方法检查共用错误构造器,调用位置与源栈由外层 VM 诊断补充。 fn invalid(message: &'static str) -> VmError { VmError::InvalidArgument(message) @@ -267,1054 +127,50 @@ fn eligible(store: &ObjectStore, owner: ObjectRef, desktop: ObjectRef) -> Result // 非展示类普通业务 owner 仅需可达;其作用域/当前 key 条件由 current 另行检查。 Ok(true) } -/// After 替换、Task 方法、Scheduler 和 finish 调用,验证 owner/key 字典仍精确指向本任务,防止旧代际交付。 -fn current( - store: &ObjectStore, - owner: ObjectRef, - reference: ObjectRef, - task: &Task, -) -> Result { - // key 指向的对象必须恰是当前 Task,替换后旧 Task 即使还被外部持有,也不能接收结果或执行回调。 - Ok(match scope(store, owner)? { - Some(scope) => { - // 外部仍持有旧 Task token 也不能绕过同键替换,必须精确比对 Value::Object 身份。 - store.dict_get(scope, &Value::Text(task.key.clone()))? == Some(Value::Object(reference)) - } - None => false, - }) -} -/// window/页面关闭与 Mount 退役边界调用,取消 owner 全部任务;同一输入 close 后再 open 也不能复活旧任务。 -pub fn cancel_owner(cx: &mut NativeContext<'_>, owner: ObjectRef) -> Result<(), VmError> { - // 无作用域表示从未拥有任务,关闭仍正常成功,不为取消动作反而分配一个新字典。 - let Some(scope) = scope(cx.store(), owner)? else { - return Ok(()); - }; - // 克隆条目后逐个变更字典;取消 pending/running 的执行边,再删除所有 owner/key 拥有边。 - for (key, value) in cx.store().dict_items(scope)?.to_vec() { - // 复制字典项使删除不会使迭代借用失效;每个值必须是当前 VM 的 Task。 - let reference = object(&value)?; - // 取消修改副本并经写屏障提交,释放 callback/coroutine/waiting 的真实托管强边。 - let mut task = cx.store().payload::(reference, "Task")?.clone(); - if matches!(task.state, State::Pending | State::Running) { - // 终态内容不重新改成 Cancelled,但所有 owner/key 字典边最后都会解除。 - task.state = State::Cancelled; - task.callback = None; - task.lease = None; - task.coroutine = None; - task.waiting = None; - task.text = None; - task.result = None; - cx.replace_payload(reference, task)?; - } - cx.dict_delete(scope, &key)?; - } - Ok(()) -} - -#[derive(Debug, Clone, Copy, PartialEq, Eq)] -/// 当前宿主 API 的操作分类,分派代码负责参数校验与状态更新。 -enum Operation { - Timer, - Sleep, - ReadText, - FetchText, - Spawn, -} #[derive(Debug)] -/// 创建定时/I/O/协作任务时的原生调用适配器。 -struct After { - // 区分计时、无回调 sleep、后台读取与协作 spawn,决定参数形状和初始 ready 状态。 - operation: Operation, - // 源 API 和轮询 Scheduler 共用同一个 Provider mailbox,I/O 线程不接触此 VM。 - provider: crate::io_tasks::Provider, - // install 按具体 API 构造的完整数量/类型/效果契约,进入 invoke 前由 VM 检查。 - signature: endor_core::CallSignature, - // 弱调度索引,不是 Task 的拥有者;真正拥有边在 owner 的作用域字典。 - index: Index, - // spawn 创建后置位,让 worker 知道有可推进协程,prune 在轮末重新计算。 - runnable: Arc, - // shutdown/quiesce 置位的单向门闩,清理回调不得再提交新任务。 - quiescing: Arc, - // 主资源域用于 Task 类型和跨窗口 owner 登记校验,不把 Task 固定到某个 current 页。 - desktop: ObjectRef, -} -impl NativeCallable for After { - /// 给出参数与返回值的托管类型契约;实际操作在 invoke 中执行。 - fn signature(&self) -> Option { - Some(self.signature.clone()) +/// 无状态策略不保存托管句柄,宿主注册域由 Nexus 原生函数的 captures 保活。 +struct TesseraTaskPolicy; +impl nexus::tasks::TaskHost for TesseraTaskPolicy { + /// 读取真实拥有字典,不创建新作用域。 + fn scope(&self, store: &ObjectStore, owner: ObjectRef) -> Result, VmError> { + scope(store, owner) } - /// 直接使用创建时准备的 after/sleep/readText/fetchText/spawn 签名数量,和具体 API 一致。 - fn arity(&self) -> Option { - Some(self.signature.arity) + /// 保留原有 payload/普通对象的写屏障路径。 + fn install_scope( + &self, + cx: &mut NativeContext<'_>, + owner: ObjectRef, + scope: ObjectRef, + ) -> Result<(), VmError> { + install_scope(cx, owner, scope) } - - /// VM 执行 ui.after/sleep/readText/fetchText/spawn 时调用,验证全部输入再建立新 owner/key 身份,最后取消旧项。 - fn invoke(&self, cx: &mut NativeContext<'_>, args: &[Value]) -> Result { - // 退出域先拒绝新任务;只读渲染也禁止异步提交,即使某构造操作只分配新的任务对象。 - if self.quiescing.load(Ordering::Acquire) { - // 退出门闩优先于任何分配/外部 I/O,卸载回调不能重建任务延长资源域寿命。 - return Err(invalid("runtime is exiting; new tasks are forbidden")); - } - if cx.store().is_read_only() { - // 提交任务会改作用域/调度资格,即使只分配新 Task 也不是合法的纯测量/绘制操作。 - return Err(invalid( - "asynchronous work is forbidden during read-only rendering", - )); - } - // 统一解码不同 API 参数:spawn 用零延时与回调,sleep 无回调,I/O 第三个位置是路径/URL。 - // spawn 没有延时参数,借一个局部零值复用后面的毫秒校验,不扩展源 API 参数表。 - let zero = Value::Number(0_i64.into()); - // 统一得到 owner/key/输入/可选回调四部分;此处只借源实参,不在尚未验证时分配 Task。 - let (owner, key, delay, callback) = match args { - [owner, key, callback] if self.operation == Operation::Spawn => { - // spawn 的第三实参是零参源函数,不能误作 delay 或路径解析。 - (owner, key, &zero, Some(callback)) - } - // sleep 无回调,只通过 await/Task 结果状态通知完成。 - [owner, key, delay] if self.operation == Operation::Sleep => (owner, key, delay, None), - // 四参形状服务 after 和带回调 I/O;第三位稍后依据 operation 解释成毫秒或路径。 - [owner, key, delay, callback] => (owner, key, delay, Some(callback)), - [owner, key, path] - if matches!(self.operation, Operation::ReadText | Operation::FetchText) => - { - // 三参 I/O 返回可 await Task,不要求为了接收文本而人为提供一个空回调。 - (owner, key, path, None) - } - _ => { - // 元数据检查外仍防御直接调用/不匹配形状,不让后面按错误的位置读取输入。 - return Err(invalid( - "asynchronous request requires owner, key, delay/path and optional I/O callback", - )); - } - }; - // owner 必须是真正托管对象,随后 eligible 再检查其展示生命周期。 - let owner = object(owner)?; - // Some(错误值) 传播类型错误,None 仅表示合法无回调 API,二者不可混同。 - let callback = callback.map(object).transpose()?; - // 所有回调都按零显式参数执行,必须是 Function 且参数元数据确认接受零参,不能等执行时再碰运气。 - if let Some(callback) = callback { - // 是否带 receiver 已由 VM 绑定函数体现,数量校验针对调用者仍需传的未绑定实参。 - if !cx.store().object(callback)?.payload().is_function() { - return Err(invalid("task callback must be a Function")); - } - if !cx - .store() - .call_arity(callback)? - .ok_or(invalid("task callback requires positional metadata"))? - .accepts(0) - { - return Err(invalid("task callback requires zero unbound parameters")); - } - } - // key 是相同 owner 内的替换身份,不允许用任意对象 repr 当作不稳定字典键。 - let Value::Text(key) = key else { - return Err(invalid("task key must be text")); - }; - // key 是 owner 内替换/取消身份,限制 UTF-8 字节长度与控制字符,禁止空 key。 - if key.is_empty() || key.len() > 128 || key.chars().any(char::is_control) { - return Err(invalid("invalid task key")); - } - // I/O 得到零计时延迟和后台 Request,计时/协作则得到毫秒数且没有外部请求。 - let (milliseconds, request) = - if matches!(self.operation, Operation::ReadText | Operation::FetchText) { - // 原局部名 delay 此时借用的是路径/URL 字符串,按 operation 先分流再判断实际类型。 - let Value::Text(path) = delay else { - return Err(invalid("I/O input must be a String")); - }; - // 只创建纯数据请求,provider 提交发生在 Task 已分配并有可取消租约的位置。 - let request = match self.operation { - Operation::ReadText => { - // 路径允许平台路径语义但拒绝空、过长或 NUL;文件类型/字节预算由 worker 再查。 - if path.is_empty() || path.len() > 4096 || path.contains('\0') { - return Err(invalid("invalid text path")); - } - crate::io_tasks::Request::ReadText(path.clone()) - } - Operation::FetchText => { - // 在创建后台工作前拒绝不支持 URL,worker 仍再次校验以维护独立边界。 - if !crate::io_tasks::valid_url(path) { - return Err(invalid( - "expected HTTP(S) URL without credentials or control characters", - )); - } - crate::io_tasks::Request::FetchText(path.clone()) - } - Operation::Timer | Operation::Sleep | Operation::Spawn => unreachable!(), - }; - (0, Some(request)) - } else { - // 只有计时/sleep/spawn 进入这里,spawn 由上面借用零 Number,因此也受同一整数约束。 - let Value::Number(delay) = delay else { - return Err(invalid( - "task delay must be an integer number of milliseconds", - )); - }; - // 定时延迟要求整数毫秒,范围为零到一天;spawn 复用零延迟路径,禁止小数/负数。 - let milliseconds = delay - .as_i64() - .filter(|delay| (0..=86_400_000).contains(delay)) - .ok_or(invalid( - "task delay must be 0..86400000 integer milliseconds", - ))?; - (milliseconds, None) - }; - if !eligible(cx.store(), owner, self.desktop)? { - // 不允许关闭/卸载对象创建新工作,即使源代码仍通过变量持有它的 ObjectRef。 - return Err(invalid("task owner is closed or detached")); - } - // 在分配新任务前找同 key 旧身份,额度检查允许替换但不允许借其他 key 继续增加总量。 - let existing_scope = scope(cx.store(), owner)?; - // 读取可选旧 Task,不删除旧项;新任务的参数/预算/分配失败时应保留旧身份。 - let previous = existing_scope - .map(|scope| cx.store().dict_get(scope, &Value::Text(key.clone()))) - .transpose()? - .flatten() - .map(|value| object(&value)) - .transpose()?; - // 短锁覆盖调度索引剪枝及最终换表,过程不运行源回调,避免看到半次替换索引。 - let mut index = self - .index - .lock() - .map_err(|_| invalid("task index poisoned"))?; - // 提交时压缩弱索引,只保留还存活且 pending/running 的任务;终态不占调度名额。 - let mut live = Vec::new(); - for weak in index.iter().copied() { - if let Some(task) = cx.upgrade(weak)? - && matches!( - cx.store().payload::(task, "Task")?.state, - State::Pending | State::Running - ) - { - // NativeContext 临时升级的根在本次调用结束释放,live 保存的仍只有弱身份。 - live.push(weak); - } - } - if live.len() >= MAX_TASKS && previous.is_none() { - // 同 key 替换不是扩容;新 key 在总量上限时必须失败,不能通过长期保存 Task token 绕过。 - return Err(VmError::ExecutionLimit("1024 pending tasks per runtime")); - } - if let Some(scope) = existing_scope - && cx.store().dict_items(scope)?.len() >= MAX_OWNER_TASKS - && previous.is_none() - { - // owner 局部额度独立于全运行时额度,同 key 仍可原位更新已有槽。 - return Err(VmError::ExecutionLimit("64 pending tasks per owner")); - } - // 先分配并设置截止点/状态,再安装 I/O 租约和 owner 字典边;弱 owner 不承担保活作用。 - let task = cx.allocate(Task { - owner: cx.store().downgrade(owner)?, - key: key.clone(), - due: Instant::now() - .checked_add(Duration::from_millis(milliseconds as u64)) - .ok_or(invalid("task deadline overflow"))?, - callback, - state: State::Pending, - ready: matches!( - self.operation, - Operation::Timer | Operation::Sleep | Operation::Spawn - ), - text: None, - error: None, - lease: None, - cooperative: self.operation == Operation::Spawn, - coroutine: None, - waiting: None, - result: None, - })?; - cx.attach_type(task, desktop_type(cx.store(), "Task", self.desktop)?)?; - if let Some(request) = request { - // 只有旧任务仍待完成且真的持有 I/O 租约才使用 provider 临时替换额度,不给普通任务扩大 I/O 上限。 - let replacing = previous - .map(|previous| { - // 只有实际未完成 I/O 能归还一个旧租约,终态/纯定时器不能借来放宽 provider 上限。 - cx.store().payload::(previous, "Task").map(|task| { - matches!(task.state, State::Pending | State::Running) - && task.lease.is_some() - }) - }) - .transpose()? - .unwrap_or(false); - // 非阻塞提交拿到交付资格;后台即使很快完成,VM 交付仍等后续 poll 核验 owner/key。 - let lease = self - .provider - .submit(cx.store().downgrade(task)?, request, replacing)?; - // 把租约写进 Task payload 才成为其生命周期资源,后台 Job 自己不持有 Lease。 - let mut value = cx.store().payload::(task, "Task")?.clone(); - value.lease = Some(lease); - cx.replace_payload(task, value)?; - } - - // 首次提交才安装字典;以后同 owner 复用 scope,key 替换始终在同一拥有表中发生。 - let task_scope = if let Some(scope) = existing_scope { - // 已有作用域保持原字典身份;替换不使其他 key 的 Task 所有权发生变化。 - scope - } else { - // 第一个任务才分配字典并建立 owner→scope 强边,之后 dict_set 建立 scope→Task 强边。 - let scope = cx.new_dict()?; - install_scope(cx, owner, scope)?; - scope - }; - // 先保存新旧身份所需弱键,下面登记成功才取消旧 Task;此处不是向 GUI 发布画面。 - let previous_weak = previous.map(|old| cx.store().downgrade(old)).transpose()?; - // 替换字典边前临时升级旧任务,避免 dict_set 删除最后拥有边后,清理旧 payload 时对象已被回收。 - if let Some(weak) = previous_weak { - cx.upgrade(weak)?; - } - cx.dict_set(task_scope, Value::Text(key.clone()), Value::Object(task))?; - // 新 key 身份登记成功后再将旧任务取消,切断回调/协程/等待/结果与 I/O 租约,晚到结果不得复活。 - if let Some(previous) = previous { - // 前面临时升级旧身份保护它跨过字典替换,即使用户没有保存旧 Task token 也能安全清理。 - if cx.store().object(previous).is_ok() { - // 只取消仍活跃项,已完成/失败的旧 token 保留自己的终态结果供已持有者检查。 - let mut old = cx.store().payload::(previous, "Task")?.clone(); - if matches!(old.state, State::Pending | State::Running) { - old.state = State::Cancelled; - old.callback = None; - old.lease = None; - old.coroutine = None; - old.waiting = None; - old.text = None; - old.result = None; - cx.replace_payload(previous, old)?; - } - } - } - // 新 Task 的真正根已经在作用域字典中,调度器只需要弱索引,不附加第二条隐藏拥有边。 - let weak = cx.store().downgrade(task)?; - // 弱索引也移除被替换身份;spawn 额外设置 runnable 唤醒标志,使外层知道存在可推进协程。 - live.retain(|old| Some(*old) != previous_weak); - live.push(weak); - *index = live; - if self.operation == Operation::Spawn { - // cooperative 工作首次即可执行,唤醒标志让 worker 不误以为只有未来计时器而进入长等待。 - self.runnable.store(true, Ordering::Release); - } - Ok(NativeResult::Return(Value::Object(task))) + /// 页、出现位置与窗口的生命周期仍由 Tessera 定义。 + fn eligible( + &self, + store: &ObjectStore, + owner: ObjectRef, + context: ObjectRef, + ) -> Result { + eligible(store, owner, context) + } + /// 复用当前 desktop 已安装的 Task 名义类型。 + fn task_type(&self, store: &ObjectStore, context: ObjectRef) -> Result { + desktop_type(store, "Task", context) } } -#[derive(Debug, Clone, Copy)] -/// 该原生能力的查询/操作分类,方法包装用它选择具体实现。 -enum Query { - Cancel, - Status, - Active, - Result, - Error, -} -#[derive(Debug)] -/// install 安装到 Task 类型的原生方法包装;VM 绑定 receiver 后调用,不为每个 Task 单独创建闭包。 -struct Method { - // 包含隐式 Task receiver 的签名,查询只读,cancel 修改任务与 owner/key 字典。 - signature: endor_core::CallSignature, - // 五个 API 共用 receiver/资格检查后,各按不同状态可读性规则返回结果。 - query: Query, - // eligible 的跨窗口注册表检查使用所属 VM 主资源域,不能以 current 窗口替代。 - desktop: ObjectRef, -} -impl NativeCallable for Method { - /// 给出参数与返回值的托管类型契约;实际操作在 invoke 中执行。 - fn signature(&self) -> Option { - Some(self.signature.clone()) - } - /// Task 方法无显式参数;底层调用包含唯一一个隐式 Task 接收者。 - fn arity(&self) -> Option { - Some(endor_core::CallArity::exact(1)) - } - - /// VM 执行 task.status/active/result/error/cancel 时调用,重新核验活任务资格,查询不因失效偷偷改 payload。 - fn invoke(&self, cx: &mut NativeContext<'_>, args: &[Value]) -> Result { - // 方法无显式参数,实际 args 唯一一项是隐式 Task 接收者。 - let [value] = args else { - return Err(invalid("Task methods accept no arguments")); - }; - // 解码 receiver 后验证真实 Task payload,普通对象无法靠同名方法字段伪造任务。 - let reference = object(value)?; - // 状态副本用于 cancel 的写屏障提交;只读查询保留原 Task 不变。 - let mut task = cx.store().payload::(reference, "Task")?.clone(); - // pending 这里同时涵盖 Running 协程,不等同于严格的 State::Pending 枚举值。 - let pending = matches!(task.state, State::Pending | State::Running); - // 只有活任务才需验证 owner;终态结果不因 owner 后续销毁而突然不可读。 - let owner = if pending { - cx.upgrade(task.owner)? - } else { - None - }; - // active 同时要求展示资格和当前 key 精确身份,单看 Task.state 会漏掉尚未轮询清理的旧项。 - let active = if let Some(owner) = owner { - eligible(cx.store(), owner, self.desktop)? - && current(cx.store(), owner, reference, &task)? - } else { - false - }; - // 各方法返回类型由 install 签名对应;result 的可用性不同于 active,不能共享一个布尔快路。 - let value = match self.query { - // pending/running 但已失去 owner/key 资格时,对源报告 cancelled;只读查询不因此改写 payload。 - Query::Status => Value::Text( - if pending && !active { - State::Cancelled.name() - } else { - task.state.name() - } - .into(), - ), - Query::Active => Value::Bool(active), - // I/O 回调执行期间可读取已保存 text;协作任务必须真正 Completed 才能读最终 result,错误任务不返回成功值。 - Query::Result => { - if !matches!(task.state, State::Running | State::Completed) - || task.error.is_some() - || (task.cooperative && task.state != State::Completed) - { - // 协程未完成不能返回半成品;I/O 错误也不能把 text/Nil 当成功返回。 - return Err(invalid( - "task result is not available; inspect status and error", - )); - } - task.result.clone().unwrap_or_else(|| { - task.text - .as_ref() - .map(|text| Value::Text(text.to_string())) - .unwrap_or(Value::Nil) - }) - } - Query::Error => Value::Text( - // 只有 Failed 返回保存诊断;取消/运行中返回空错误文本,空文本本身不能作为任务已经成功的判断依据。 - if task.state == State::Failed { - task.error.as_deref().unwrap_or_default() - } else { - "" - } - .into(), - ), - Query::Cancel => { - if cx.store().is_read_only() { - // 即使任务已失效也不允许在只读渲染里执行具有取消语义的方法。 - return Err(invalid( - "task cancellation is forbidden during read-only rendering", - )); - } - if pending { - // pending 同时覆盖 Running;即使 active 已因 owner/key 失效而为 false,也清执行边,但最终返回值仍报告未取消有效任务。 - task.state = State::Cancelled; - task.callback = None; - // 取消立即放弃 I/O 租约与执行边,下面也清掉 text/result;不保留可交付的成功结果。 - task.lease = None; - task.coroutine = None; - task.waiting = None; - task.text = None; - task.result = None; - cx.replace_payload(reference, task.clone())?; - if let Some(owner) = owner - && current(cx.store(), owner, reference, &task)? - && let Some(scope) = scope(cx.store(), owner)? - { - // 必须仍是当前 key 的同一 Task 才删 owner 边,旧 token.cancel 不能删掉替换后的新任务。 - cx.dict_delete(scope, &Value::Text(task.key))?; - } - } - // 返回本次是否取消了仍有效的待执行任务;重复 cancel 或已失去资格的任务返回 false。 - Value::Bool(pending && active) - } - }; - Ok(NativeResult::Return(value)) - } -} - -/// bootstrap 返回给 UiBridge 的每 VM 调度能力,endor_host 轮询/退出时使用,原生字段不持有 Task 强根。 -pub struct Scheduler { - // 弱项顺序也是轮转顺序,实际推进过的任务在 poll 尾部移到末尾。 - index: Index, - // worker 等待策略读取此标志;只表示可能存在可运行协程,不保证下次一定完成一个任务。 - runnable: Arc, - // 退出后不可重新打开,新任务 API 与本调度器共享门闩。 - quiescing: Arc, - // 跨窗口 owner 生命周期核验的主注册域,不持 GUI 窗口指针。 - desktop: ObjectRef, - // 后台只提交 Completion 到邮箱,本调度器才有权在 VM 中写入 Task 与执行回调。 - provider: crate::io_tasks::Provider, -} -impl Scheduler { - /// UiBridge::shutdown 调用,先关新任务入口再取消所有活任务,允许退出钩子执行但不能重建工作。 - pub fn quiesce(&self, vm: &mut Vm) -> Result { - // 先设置不可逆的退出门闩再取消全部任务,防止清理回调间隙继续接收新工作。 - self.quiescing.store(true, Ordering::Release); - self.cancel_all(vm) - } - /// UiBridge/endor_host 的等待策略查询,不扫描 VM 堆,仅读取上次创建/prune 得到的可运行标志。 - pub fn has_cooperative_work(&self) -> bool { - self.runnable.load(Ordering::Acquire) - } - /// UiBridge::poll_tasks 由 endor_host 调用,在 owning VM 内交付邮箱、推进至多 limit 项工作并更新公平索引。 - /// 不在空闲轮询中扫描整堆;不可达 owner/回调环由外层变更边界的 collect_cycles 清理。 - pub fn poll(&self, vm: &mut Vm, limit: usize) -> Result { - // limit 是本轮工作预算而非毫秒超时,零或超过 MAX_READY 都不能进入调度。 - anyhow::ensure!((1..=MAX_READY).contains(&limit), "invalid task poll limit"); - // provider 只产纯数据,VM worker 此处重新核对任务 pending、租约仍在、owner 有效且 key 仍当前。 - for (weak, completion) in self.provider.take_ready()? { - if let Some(reference) = vm.upgrade(weak)? { - // 保存邮箱交付 Result,外层先释放 upgrade 得到的 Task 根,再传播任意中途错误。 - let result = (|| -> Result<()> { - // 任务可能在后台运行时已被源代码取消/替换,不能直接把 Completion 写进旧副本。 - let mut task = vm.payload::(reference, "Task")?.clone(); - if task.state != State::Pending || task.lease.is_none() { - // 已终态或放弃租约的晚到结果直接忽略,不设置 ready 把旧任务重新变为可执行。 - return Ok(()); - } - // 临时拥有 owner 跨过资格检查,不能在完成邮箱里保存一个长期 owner 根。 - let owner = vm.upgrade(task.owner)?; - // 即使 eligible/current 报错,也先走下面 owner 根释放路径。 - let active = (|| -> Result { - Ok(if let Some(owner) = owner { - eligible(vm.object_store(), owner, self.desktop)? - && current(vm.object_store(), owner, reference, &task)? - } else { - false - }) - })(); - if let Some(owner) = owner { - // 邮箱阶段仅临时升级 owner 以检查资格,无论 active 检查成功或失败都先释放这个临时根再传播结果。 - vm.release(owner)?; - } - if !active? { - // 身份/生命周期已失效,留给后续有界扫描清理,不交付回调或保存可观察成功文本。 - return Ok(()); - } - // 收到后台结果只设置 ready/text/error,实际终态与回调交付由下面的有界调度扫描决定。 - task.ready = true; - match completion { - // provider 的纯文本结果在 VM 线程转换为 Task 字段,后台不直接改对象版本。 - Ok(text) => task.text = Some(text.into()), - Err(error) => task.error = Some(error.into()), - } - vm.replace_payload(reference, task)?; - Ok(()) - })(); - vm.release(reference)?; - result?; - } - } - // 复制本轮弱索引后释放锁,用户回调可在 poll 期间提交任务,不应因重入同一索引锁死锁。 - let snapshot = self - .index - .lock() - .map_err(|_| anyhow::anyhow!("task index poisoned"))? - .clone(); - // 本轮使用同一 now 判断到期,避免长回调执行后在同轮无限吸收后来才到期的定时器。 - let now = Instant::now(); - // 取消无效任务也消耗工作预算,避免大量死亡 owner 使一次轮询无限延长。 - let mut work = 0; - // 记录本轮实际执行的弱身份,扫描结束后移到队尾形成 round-robin,不边迭代边改原表。 - let mut advanced = Vec::new(); - for weak in snapshot { - if work >= limit { - // 未扫描的任务保留原索引,下一次 poll 继续有机会运行,而非丢弃余下项。 - break; - } - // Task 已不可达时不复活它,失效弱项由 prune 最后清理。 - let Some(reference) = vm.upgrade(weak)? else { - continue; - }; - // 一项扫描的任何 VM 错误都先回到 Task 根释放,再让外层按运行时故障规则处理。 - let result = (|| -> Result<()> { - // 每轮重读当前 payload,不能沿用 mailbox 阶段或上轮协程恢复前的状态副本。 - let mut task = vm.payload::(reference, "Task")?.clone(); - if !matches!(task.state, State::Pending | State::Running) { - // 已终态仍可被用户变量持有,但不再消耗执行量子,也不能重复执行 callback。 - return Ok(()); - } - // owner 弱边可能已死亡,按取消处理而不是把当前运行时当作替代 owner。 - let owner = vm.upgrade(task.owner)?; - // 内层结果暂存,使任何回调/完成错误都不会跳过 owner 根释放。 - let result = (|| -> Result<()> { - // owner 展示资格和同 key 当前身份都必须满足,保留旧 Task token 不能继续取得执行权。 - let active = if let Some(owner) = owner { - eligible(vm.object_store(), owner, self.desktop)? - && current(vm.object_store(), owner, reference, &task)? - } else { - false - }; - // owner 回收、页面关闭或 key 被替换都使任务取消;取消也计一次 work,避免清理无限占用一轮。 - if !active { - work += 1; - return finish(vm, reference, State::Cancelled); - } - // 被等待对象未就绪则不消费量子;被取消会取消等待者,失败等其他结果交回协程 await 语义处理。 - if let Some(waiting) = task.waiting { - // 仅查询 AwaitPoll,不递归执行被等待对象,公平调度仍由外层轮询负责。 - match vm.object(waiting)?.payload().poll_await() { - Ok(endor_core::AwaitPoll::Pending) => return Ok(()), - Err(VmError::AwaitCancelled) => { - // 被等待任务取消会取消等待者;失败则留给恢复后的 await 按语言语义抛出。 - work += 1; - return finish(vm, reference, State::Cancelled); - } - _ => {} - } - } - if task.due > now || !task.ready { - // 时间到了不代表 I/O 已就绪,I/O 就绪也不能越过计时截止;两条件均需满足。 - return Ok(()); - } - work += 1; - // 记录实际推进的任务,轮末移到索引尾部,保证一回调空闲预算下仍能轮转多个协程。 - advanced.push(weak); - // spawn 使用可恢复协程而非普通 call;其余 I/O/定时器回调作为一次完整有界调用执行。 - if task.cooperative { - // 只推进一次软量子,完成/await/仍可运行分别由 advance_coroutine 处理。 - return advance_coroutine(vm, reference); - } - if task.error.is_some() { - // provider 失败不调用成功回调,用 Failed 终态让 await/error 观察原始文本诊断。 - return finish(vm, reference, State::Failed); - } - // sleep 或无回调 I/O 直接完成,结果已保存在 Task,不需为了 await 虚构空函数。 - let Some(callback) = task.callback else { - return finish(vm, reference, State::Completed); - }; - // provider 已完成,回调开始前归还 I/O 名额;text 暂留给回调中的 Task.result 查询。 - task.lease = None; - task.coroutine = None; - task.waiting = None; - // 先发布 Running 状态再进入用户代码,回调可查询任务或取消/替换自身。 - let mut running = task.clone(); - running.state = State::Running; - vm.replace_payload(reference, running)?; - // 普通回调必须一次有界完成,不是 spawn 的可恢复协程;预算不因别的任务回调重入而累加到无限。 - let result = vm - .call_with_limits( - callback, - &[], - endor_core::ExecutionLimits { - max_frames: 128, - max_instructions: 100_000, - }, - ) - .map_err(|error| crate::endor_host::runtime_error(vm, error)); - match result { - Ok(value) => { - // 普通异步回调契约要求 Unit;先释放实际返回值,再把不符合契约的回调标失败并向外报告。 - let unit = matches!(value, Value::Nil); - vm.release_value(value)?; - if !unit { - // 已释放非 Unit 返回根后再标记失败并报告,不能因契约错误泄漏任意对象返回值。 - fail_callback( - vm, - reference, - "asynchronous callback must return Unit", - )?; - bail!("asynchronous callback must return Unit"); - } - finish(vm, reference, State::Completed) - } - Err(error) => { - // 存有界诊断并清执行资源,同时把实际错误交给 endor_host 的故障处理。 - fail_callback(vm, reference, &format!("{error:#}"))?; - Err(error) - } - } - })(); - if let Some(owner) = owner { - // 调度回调或协程推进可能失败;先释放本项的 owner 临时根,外层再释放 Task 根,最后才传播错误。 - vm.release(owner)?; - } - result - })(); - vm.release(reference)?; - result?; - } - // 实际推进项移到末尾,空闲 limit=1 时一个长协程不能每轮都抢在其他可执行任务前。 - if !advanced.is_empty() { - // 回调可能新建任务,所以重新取得当前索引再移动已推进项,不能拿旧 snapshot 覆盖新登记。 - let mut index = self - .index - .lock() - .map_err(|_| anyhow::anyhow!("task index poisoned"))?; - index.retain(|weak| !advanced.contains(weak)); - index.extend(advanced); - } - // 轮末移除终态/死亡任务并重算 runnable,等待外部 I/O 的任务不应导致忙轮询协程。 - self.prune(vm)?; - Ok(work) - } - /// UiBridge 取消和 Scheduler::quiesce 调用,逐项 finish 并清空弱索引,不执行用户取消回调。 - pub fn cancel_all(&self, vm: &mut Vm) -> Result { - // 不在锁内调用 finish;它会变更 owner 作用域,但索引不需在整个 VM 清理过程中借用。 - let snapshot = self - .index - .lock() - .map_err(|_| anyhow::anyhow!("task index poisoned"))? - .clone(); - for weak in snapshot { - if let Some(task) = vm.upgrade(weak)? { - // 升级是拥有根,先保存 finish 错误再 release,避免失败时遗留额外 Task 引用。 - let result = finish(vm, task, State::Cancelled); - vm.release(task)?; - result?; - } - } - // VM 清理完成后再锁索引,取原项数供诊断并一次性清表。 - let mut index = self - .index - .lock() - .map_err(|_| anyhow::anyhow!("task index poisoned"))?; - // cancel_all 返回清空前索引项数,包含升级失败的弱项,不能等同于实际执行过的回调数。 - let count = index.len(); - index.clear(); - self.runnable.store(false, Ordering::Release); - Ok(count) - } - /// poll 的轮末收尾调用,移除死亡/终态弱项并计算“是否有可运行协程”,防止等待 I/O 时忙循环。 - fn prune(&self, vm: &mut Vm) -> Result<()> { - // 本函数不执行用户函数,短暂持锁扫描弱项及查询 AwaitPoll,不需把整个 VM 堆遍历一遍。 - let mut index = self - .index - .lock() - .map_err(|_| anyhow::anyhow!("task index poisoned"))?; - // live 保留待处理状态任务,终态由源变量自己持有,不因调度索引延长寿命。 - let mut live = Vec::new(); - // 累加是否有任意协程不用等待外部事件即可推进,不把普通未来计时器视为 runnable。 - let mut runnable = false; - for weak in index.iter().copied() { - if let Some(task) = vm.upgrade(weak)? { - // 先保存 payload 查询 Result,让升级临时根在返回错误之前也能被 release。 - let pending = vm.payload::(task, "Task").map(|task| { - // 此局部 pending 是状态布尔,与外层承载查询结果的 Result 区分。 - let pending = matches!(task.state, State::Pending | State::Running); - // 可运行标记仅针对协作任务:无等待对象可立即推进,有等待对象则看其 poll_await 是否不再 Pending。 - runnable |= pending && task.cooperative && task.waiting.is_none(); - pending - }); - if pending.as_ref().is_ok_and(|pending| *pending) { - // 只对成功读出的活任务继续看 waiting,失败则留给释放后的 pending? 传播。 - let value = vm.payload::(task, "Task")?; - if value.cooperative - && let Some(waiting) = value.waiting - { - // 等待值已完成/失败/取消都可以恢复处理;只有明确 Pending 才继续休眠。 - runnable |= !matches!( - vm.object(waiting)?.payload().poll_await(), - Ok(endor_core::AwaitPoll::Pending) - ); - } - } - vm.release(task)?; - if pending? { - // 查询成功且仍为 Pending/Running 才留下弱索引;终态 token 可以继续存在,但不再占下一轮调度槽。 - live.push(weak); - } - } - } - *index = live; - self.runnable.store(runnable, Ordering::Release); - Ok(()) - } -} -/// advance_coroutine 准备保存 await 依赖前调用,沿 Task.waiting 判断自等/互等,非 Task 值由其自身 await 协议处理。 -fn cyclic_wait(vm: &Vm, source: ObjectRef, mut target: ObjectRef) -> Result { - // seen 记录目标身份,既识别回到 source,也识别原本已有的封闭依赖环。 - let mut seen = std::collections::HashSet::new(); - loop { - // 等待链到达 source 或重复已有目标都表示环;不是 Task 或没有 waiting 边时链终止,不判环。 - if target == source || !seen.insert(target) { - return Ok(true); - } - // 非本模块 Task 的 awaitable 没有可遍历 waiting 边,不能臆测其内部依赖结构。 - let Some(task) = vm.object(target)?.payload().as_any().downcast_ref::() else { - return Ok(false); - }; - // 一个尚未等待其他对象的任务是链尾,当前这次新增等待不会自行形成环。 - let Some(waiting) = task.waiting else { - return Ok(false); - }; - target = waiting; - } -} - -/// Scheduler::poll 只为 cooperative Task 调用,首次创建协程后每轮恢复 256 指令软量子,保留累计硬预算。 -fn advance_coroutine(vm: &mut Vm, reference: ObjectRef) -> Result<()> { - // 保存初始执行边用于第一次准备,运行源代码后必须重读状态,不能让旧副本覆盖自取消结果。 - let mut task = vm.payload::(reference, "Task")?.clone(); - // 首次推进把 callback 转成托管 Coroutine,后续复用同一帧与预算,不重放已发生的源副作用。 - let coroutine = if let Some(coroutine) = task.coroutine { - // 已有协程直接继续原帧,不从 callback 起点回放写属性/I/O 等副作用。 - coroutine - } else { - // 只有第一次推进才取 callback,成功保存协程后会清 callback 强边避免重复准备。 - let callback = task - .callback - .ok_or_else(|| anyhow::anyhow!("spawn callback missing"))?; - // 协程自身保存硬预算,软量子每轮刷新也不会让总指令限制重新从零计算。 - let prepared = vm - .new_coroutine( - callback, - &[], - endor_core::ExecutionLimits { - max_frames: 128, - max_instructions: 100_000, - }, - ) - .map_err(|error| crate::endor_host::runtime_error(vm, error)); - // 准备可能因回调/类型/预算错误失败,统一标记任务失败并保留源诊断。 - let coroutine = match prepared { - Ok(coroutine) => coroutine, - Err(error) => { - fail_callback(vm, reference, &format!("{error:#}"))?; - return Err(error); - } - }; - // 准备 coroutine 期间原生代码也可能取消/替换任务,必须重读当前状态,不能把旧 task 副本覆盖回去。 - // 看真实当前 payload 的状态,而不是此函数入口保存的 task.state。 - let current = vm.payload::(reference, "Task")?.state; - if !matches!(current, State::Pending | State::Running) { - // 已失去执行资格,刚准备出的协程返回根仍需释放,不能写回 Task 复活它。 - vm.release(coroutine)?; - return Ok(()); - } - task.state = State::Running; - task.callback = None; - task.coroutine = Some(coroutine); - // 先由 payload 建立协程拥有边,再释放创建根;安装失败也尝试释放局部根。 - // 先暂存安装结果,让创建根不管写屏障成功/失败都经过下面 release。 - let installed = vm.replace_payload(reference, task); - vm.release(coroutine)?; - installed?; - coroutine - }; - // 续体结果先保存,运行函数可能主动取消/替换 Task,交付前还要核验真实状态。 - let result = vm - // 每次最多执行 256 指令软量子,达到量子时仅挂起;总 100000 指令上限仍由协程本身累计。 - .resume_coroutine(coroutine, 256) - .map_err(|error| crate::endor_host::runtime_error(vm, error)); - // 源代码运行期间可取消自身,取消/替换优先于本轮完成;完成值即使不交付也必须释放其拥有根。 - let active = matches!( - vm.payload::(reference, "Task")?.state, - State::Pending | State::Running - ); - // Waiting 保存依赖,Pending 等下一软量子,Complete 保存任意返回值;三条成功路径都先尊重本片执行期间发生的取消。 - match result { - Ok(endor_core::CoroutineProgress::Waiting { awaitable, .. }) => { - if !active { - // 等待来自已取消旧执行时不再登记 Task.waiting,让取消/替换优先。 - return Ok(()); - } - // 登记等待强边前检查依赖环,拒绝永不满足的互相 await,并把当前任务转失败。 - if cyclic_wait(vm, reference, awaitable)? { - fail_callback(vm, reference, "cyclic task await")?; - bail!("cyclic task await"); - } - // 保存强等待边,让被等待值在协程挂起期间真实可达,而不是靠弱调度表保活。 - let mut task = vm.payload::(reference, "Task")?.clone(); - task.waiting = Some(awaitable); - vm.replace_payload(reference, task)?; - Ok(()) - } - // 软量子挂起不代表等待外部值,清 waiting 后下一轮仍视作可运行。 - Ok(endor_core::CoroutineProgress::Pending { .. }) => { - if active { - // 本片量子用尽但并未 await,清旧 waiting 让 prune 把它判为下一轮可运行。 - let mut task = vm.payload::(reference, "Task")?.clone(); - task.waiting = None; - vm.replace_payload(reference, task)?; - } - Ok(()) - } - Ok(endor_core::CoroutineProgress::Complete { value, .. }) => { - if !active { - // 完成值来自 VM 返回拥有根;即使不再交付也不能直接 drop Rust Value 而不 release。 - vm.release_value(value)?; - return Ok(()); - } - // 重新读可能被源函数更新过的字段,仅附加本次成功结果,避免入口旧副本覆盖新状态。 - let mut task = vm.payload::(reference, "Task")?.clone(); - // 结果先写入受 trace 管理的 payload,再释放 VM 返回值根,最后 finish 清执行边但保留成功结果。 - task.result = Some(value.clone()); - task.waiting = None; - // 结果对象先由 Task.trace 保活;局部返回根随后释放,即使存储失败也不跳过释放。 - let stored = vm.replace_payload(reference, task); - vm.release_value(value)?; - stored?; - finish(vm, reference, State::Completed) - } - Err(error) => { - if active { - // 已终态任务不再改成 Failed,保持自取消/替换结果;实际执行错误仍返回上层。 - fail_callback(vm, reference, &format!("{error:#}"))?; - } - Err(error) - } - } -} - -/// Scheduler::poll/advance_coroutine 的回调错误分支调用,保存有界诊断,再经 finish 统一清理执行资源。 -fn fail_callback(vm: &mut Vm, reference: ObjectRef, message: &str) -> Result<()> { - // 只更新 error 字段,不自行复制 Task 结果或重新分配一份故障任务对象。 - let mut task = vm.payload::(reference, "Task")?.clone(); - // 错误预览按字符限长,保证 UTF-8 完整;记录后统一走终态清理而非保留失败协程。 - task.error = Some(message.chars().take(1024).collect::().into()); - vm.replace_payload(reference, task)?; - finish(vm, reference, State::Failed) -} - -/// poll、cancel_all、协程收尾和 fail_callback 共用的终态转换,清执行边并只撤销仍匹配的 owner/key 拥有关系。 -fn finish(vm: &mut Vm, reference: ObjectRef, state: State) -> Result<()> { - // 先核对当前真实状态,已完成/失败/取消不再被另一个迟到的收尾覆盖。 - let mut task = vm.payload::(reference, "Task")?.clone(); - if !matches!(task.state, State::Pending | State::Running) { - return Ok(()); - } - // finish 只允许从 pending/running 转终态,重复调用不改变既有 Completed/Cancelled/Failed 的语义。 - task.state = state; - task.callback = None; - task.lease = None; - task.coroutine = None; - task.waiting = None; - if state == State::Cancelled { - // 取消不保存成功结果;Completed/Failed 的诊断/结果由保留 Task token 的源代码继续观察。 - task.text = None; - task.result = None; - } - vm.replace_payload(reference, task.clone())?; - if let Some(owner) = vm.upgrade(task.owner)? { - // owner 可能已经回收,无 owner 时无需删表;升级成功则先保留清理结果再 release。 - let result = (|| -> Result<()> { - // 只有 key 仍指向本任务才删 owner 边,避免旧任务结束时误删同 key 新任务。 - if current(vm.object_store(), owner, reference, &task)? - && let Some(scope) = scope(vm.object_store(), owner)? - { - vm.dict_delete(scope, &Value::Text(task.key))?; - } - Ok(()) - })(); - vm.release(owner)?; - result?; - } - Ok(()) -} - -/// ui_bridge::bootstrap 在 Task 类型建立后调用,注册五种创建 API 和 Task 实例方法,返回同域 Scheduler。 +/// bootstrap 在 UI 类型建立后注册通用任务 API,保持原有调用签名。 pub fn install( vm: &mut Vm, roots: &mut Vec, ui: ObjectRef, desktop: ObjectRef, ) -> Result { - // 每个运行时一份弱索引、可运行/退出标记和 provider mailbox,UI API 与 Scheduler 共享这些原生状态。 - let index = Arc::new(Mutex::new(Vec::new())); - // 初始化没有可推进协程,spawn 及轮末 prune 才会更新这个唤醒提示。 - let runnable = Arc::new(AtomicBool::new(false)); - // 运行时退出单向门闩共享给所有 After callable,不能只在 Scheduler 自己保留一个无效本地副本。 - let quiescing = Arc::new(AtomicBool::new(false)); - // 所有 API 返回同一 Task 名义类型,不能为 after/sleep 各建一个不兼容 Task 类。 - let definition = desktop_type(vm.object_store(), "Task", desktop)?; - // 每运行时独立完成邮箱/租约额度,工作线程池由 Provider 内部全进程共用。 - let provider = crate::io_tasks::Provider::default(); - for (name, operation) in [ - ("after", Operation::Timer), - ("sleep", Operation::Sleep), - ("readText", Operation::ReadText), - ("fetchText", Operation::FetchText), - ("spawn", Operation::Spawn), - ] { - // I/O 第三参数为字符串并声明 External;其余初始模板用毫秒 Number/Mutating。 - let external = matches!(operation, Operation::ReadText | Operation::FetchText); - // After 共享索引/门闩/Provider,只有 operation 与签名不同,仍保留各源 API 独立名字。 - let function = vm.allocate(ContextNativeFunction::new( - name, - After { - operation, - provider: provider.clone(), - signature: { - // 基础四参模板为 owner、key、delay/path、callback,随后针对无回调/零延时 API 收窄。 - let mut signature = endor_core::CallSignature::exact( - vec![ - endor_core::AnnotationType::Any, - endor_core::AnnotationType::String, - if external { - // readText/fetchText 使用路径/URL,不能让 API 签名把它误认作计时延迟。 - endor_core::AnnotationType::String - } else { - // Timer/Sleep 使用整数毫秒,整数性与范围由 After::invoke 再查。 - endor_core::AnnotationType::Number - }, - endor_core::AnnotationType::Function, - ], - endor_core::AnnotationType::Nominal(definition), - if external { - // I/O 签名声明 External;与下面纯计时/协作的 Mutating 不同,二者都不能在只读渲染中提交。 - endor_core::CallEffect::External - } else { - endor_core::CallEffect::Mutating - }, - ); - // I/O 可带可选回调;spawn 去掉延时参数,sleep 去掉回调参数,保留各自正确 arity。 - if external { - // I/O 允许不传回调并直接 await 返回 Task,但 owner/key/path 三参始终必填。 - signature.arity = endor_core::CallArity::range(3, 4); - } - if operation == Operation::Spawn { - // 第三位改为源函数,去掉延时注解而非只把 required 数量改成 3。 - signature.parameters.remove(2); - signature.arity = endor_core::CallArity::exact(3); - } - if operation == Operation::Sleep { - // sleep 无回调,不能把三参 API 的注解末尾遗留成任意函数尾参。 - signature.parameters.pop(); - signature.arity = endor_core::CallArity::exact(3); - } - signature - }, - index: index.clone(), - runnable: runnable.clone(), - quiescing: quiescing.clone(), - desktop, - }, - vec![desktop], - ))?; - roots.push(function); - vm.set_attr(ui, name, Value::Object(function))?; - } - // Task 类型安装 cancel/status/active/result/error:只有 cancel 声明 Mutating,其余只读查询。 - for (name, query) in [ - ("cancel", Query::Cancel), - ("status", Query::Status), - ("active", Query::Active), - ("result", Query::Result), - ("error", Query::Error), - ] { - // 方法存在 Task 类型表上,receiver 由 VM 绑定;返回值契约按 query 区分。 - let method = vm.allocate(ContextNativeFunction::new( - name, - Method { - query, - desktop, - signature: endor_core::CallSignature::exact( - vec![endor_core::AnnotationType::Nominal(definition)], - match query { - // status/error 返回文本,result 保留任意源值,cancel/active 则返回布尔。 - Query::Status | Query::Error => endor_core::AnnotationType::String, - Query::Result => endor_core::AnnotationType::Any, - _ => endor_core::AnnotationType::Bool, - }, - if matches!(query, Query::Cancel) { - // 查询和取消的效果不同,不能让 cancel 在只读布局里改变任务资格。 - endor_core::CallEffect::Mutating - } else { - endor_core::CallEffect::ReadOnly - }, - ), - }, - vec![desktop], - ))?; - roots.push(method); - vm.define_method(definition, name, method)?; - } - // 返回与全部 After callable 相同的共享状态,UiBridge 后续通过它轮询/退出本 VM 的任务。 - Ok(Scheduler { - index, - runnable, - quiescing, - desktop, - provider, - }) + nexus::tasks::install(vm, roots, ui, desktop, Arc::new(TesseraTaskPolicy)) +} + +/// 窗口/页面关闭和出现位置退役仍在原边界取消 owner 的全部任务。 +pub fn cancel_owner(cx: &mut NativeContext<'_>, owner: ObjectRef) -> Result<(), VmError> { + nexus::tasks::cancel_owner(&TesseraTaskPolicy, cx, owner) } diff --git a/src/runtime/vm_sequence.rs b/src/runtime/vm_sequence.rs index 4953d41..f4f8da2 100644 --- a/src/runtime/vm_sequence.rs +++ b/src/runtime/vm_sequence.rs @@ -1,93 +1,42 @@ -//! 构造共享 VM 调用序列与同帧循环驱动的字节码。 -//! 用托管函数串联步骤,避免为每个布局节点反复创建独立解释器调用;重复驱动会保留同一个执行帧和预算域。 -//! -//! mount::synchronize 与 event_dispatch::dispatch 用 build 串起生命周期/事件回调。 -//! source_layout/source_paint 用 repeat_call 循环推进出现位置,并用 collect_and_continue 收集单次源调用结果。 -//! 本模块只生成驱动字节码和托管函数,不在 Rust 中自行解释语句,也不替调用方重置 VM 预算。 -//! 原生调用返回 Invoke 后,VM 在既有帧循环中执行驱动,因此可挂起工作仍有明确的 owning VM。 -//! build 串联的是普通调用序列,任一步报错便中断后续步骤;末项不是 finally,错误时临时根/检查点仍须由所属工作收尾路径释放。 -use endor_core::{ - CodeLayout, EndorCode, EndorCodeObject, Instruction, NativeContext, ObjectRef, Opcode, Value, - VmError, -}; +//! Tessera 的 Nexus 驱动适配:保留原调用签名,桌面 Function 绑定仍由 UI bridge 执行。 +use endor_core::{NativeContext, ObjectRef, Value, VmError}; -/// 将零参数调用列表编成一个托管驱动,按输入顺序执行,返回最后一次调用的值。 -/// 空列表返回 Nil。所有调用都在调用者的 VM 预算内运行,避免宿主逐个调用时重置预算。 -/// name 用于诊断位置;desktop 用来给生成函数挂接桌面 Function 类型。 -/// 调用者是 Mount 生命周期同步和事件路由;返回值是驱动函数身份,不是已经执行完的最后结果。 +/// 只在同步驱动构造期间借用 desktop,实际生成函数由其名义类型边保活领域定义。 +struct DesktopFunctions(ObjectRef); +impl nexus::vm_sequence::FunctionHost for DesktopFunctions { + /// Nexus 在驱动创建后调用,保持原先类型附着和错误传播顺序。 + fn attach_function( + &self, + cx: &mut NativeContext<'_>, + function: ObjectRef, + ) -> Result<(), VmError> { + crate::ui_bridge::attach_desktop_type(cx, function, "Function", self.0) + } + /// 保持既有 Tessera 原生驱动回溯标签,移动实现不改变诊断来源。 + fn source_name(&self) -> &'static str { + "" + } +} + +/// Mount/事件适配调用;通用序列指令及根关系由 Nexus 生成,不重置 VM 执行预算。 pub fn build( cx: &mut NativeContext<'_>, calls: Vec, name: &'static str, desktop: ObjectRef, ) -> Result { - // 每个函数放入常量池。LoadConst/PushNull/Call 组成零参数调用, - // 中间结果由 PopTop 丢弃;最后结果留在栈顶交给 ReturnValue。 - // 每个中间调用至多四条指令,额外空间覆盖空序列和 ReturnValue;只是预留容量,不是指令预算。 - let mut instructions = Vec::with_capacity(calls.len() * 4 + 2); - // 常量池强持有每个 callable,驱动存活期间不依赖调用方的 Rust Vec 保活。 - let mut constants: Vec = calls.into_iter().map(Value::Object).collect(); - for index in 0..constants.len() { - // LoadConst 放函数,PushNull 建立 VM Call 所需前缀,Call 0 执行无显式实参的回调。 - instructions.push(Instruction::new(Opcode::LoadConst, index as u32)); - instructions.push(Instruction::simple(Opcode::PushNull)); - instructions.push(Instruction::new(Opcode::Call, 0)); - if index + 1 != constants.len() { - // 只丢中间结果,避免把最后一个结果也弹掉而让 ReturnValue 面对空栈。 - instructions.push(Instruction::simple(Opcode::PopTop)); - } - } - // 没有调用时也必须给 ReturnValue 提供合法栈顶,不能返回一个空栈。 - if constants.is_empty() { - constants.push(Value::Nil); - instructions.push(Instruction::new(Opcode::LoadConst, 0)); - } - instructions.push(Instruction::simple(Opcode::ReturnValue)); - // 编码阶段校验字节码布局,诊断位置使用宿主 name 而不是伪造用户源码行列。 - let code = EndorCode::from_instructions(&instructions, constants, CodeLayout::default())? - .with_location(name, "", 1); - // NativeContext 暂持代码根,输出函数会通过托管边继续拥有代码与常量。 - let code = cx.allocate(EndorCodeObject::new(code))?; - // 驱动只读取常量,无需共享用户字典,空私有 globals 不污染 REPL 或主模块。 - let globals = cx.new_dict()?; - // 函数作为本次原生调用的输出被提升,其余临时拥有根由 NativeContext 退出时释放。 - let driver = cx.new_function(name, code, globals)?; - crate::ui_bridge::attach_desktop_type(cx, driver, "Function", desktop)?; - Ok(driver) + nexus::vm_sequence::build(cx, calls, name, &DesktopFunctions(desktop)) } - -/// source_layout/source_paint 安装一轮出现遍历时调用,生成固定大小的重复驱动,不按节点数展开字节码。 -/// callback 每次返回 Bool,false 退出;同帧回跳让所有出现和委托源函数共用当前 VM 的执行预算。 +/// 源布局/绘制适配调用,生成固定大小、同一帧回跳的重复驱动。 pub fn repeat_call( cx: &mut NativeContext<'_>, callback: ObjectRef, name: &'static str, desktop: ObjectRef, ) -> Result { - // 内部 Advance 回调约定返回 Bool;repeat_while 生成的是 VM 真值条件跳转,不额外验证返回值必须是 Bool。 - // 退出后显式返回 Nil,回调的继续条件不会泄露为驱动返回值。 - let mut instructions = vec![ - Instruction::new(Opcode::LoadConst, 0), - Instruction::simple(Opcode::PushNull), - Instruction::new(Opcode::Call, 0), - ]; - repeat_while(&mut instructions)?; - // 条件已由 PopJumpIfFalse 消费;退出时重新装 Nil,不能把最后条件冒充业务返回值。 - instructions.extend([ - Instruction::new(Opcode::LoadConst, 1), - Instruction::simple(Opcode::ReturnValue), - ]); - driver( - cx, - instructions, - vec![Value::Object(callback), Value::Nil], - name, - desktop, - ) + nexus::vm_sequence::repeat_call(cx, callback, name, &DesktopFunctions(desktop)) } - -/// source_layout/source_paint 的推进回调调用,为当前出现生成“调用源方法→collector 收结果→返回 true”的助手。 -/// 每次只捕获当前源函数/实参,不预先为全部节点建立助手帧;外层重复驱动再决定下一次出现。 +/// 单次源调用的收集器适配;保持 collector/function/实参顺序和原生输出根协议。 pub fn collect_and_continue( cx: &mut NativeContext<'_>, collector: ObjectRef, @@ -96,140 +45,12 @@ pub fn collect_and_continue( name: &'static str, desktop: ObjectRef, ) -> Result { - // 常量布局固定为 collector、function、各实参、true。 - // function 或 collector 失败时不会装入最终 true,外层循环也不会自动跳过失败节点;本助手不捕获或重试源错误。 - // 先把 collector 的调用前缀压栈,再执行 function,使其返回值直接成为 collector 的唯一实参。 - // count 同时确定 Call 的显式参数数和 true 常量的池位置,不能把 collector 的一参计入它。 - let count = arguments.len(); - // 先保存两个 callable,再追加业务实参;这份强边关系使源调用挂起期间输入仍可达。 - let mut constants = vec![Value::Object(collector), Value::Object(function)]; - constants.extend(arguments); - constants.push(Value::Bool(true)); - // 先压 collector 的调用前缀,再压 function 的调用前缀;内部返回值自然成为外部单一实参。 - let mut instructions = vec![ - Instruction::new(Opcode::LoadConst, 0), - Instruction::simple(Opcode::PushNull), - Instruction::new(Opcode::LoadConst, 1), - Instruction::simple(Opcode::PushNull), - ]; - for index in 0..count { - // 参数常量从 2 开始,0/1 已被 collector/function 占用,保持源方法原始实参顺序。 - instructions.push(Instruction::new(Opcode::LoadConst, index as u32 + 2)); - } - // 收集器返回值不参与外层调度;丢弃后返回 true,通知重复驱动继续取下一项。 - instructions.extend([ - Instruction::new(Opcode::Call, count as u32), - Instruction::new(Opcode::Call, 1), - Instruction::simple(Opcode::PopTop), - Instruction::new(Opcode::LoadConst, count as u32 + 2), - Instruction::simple(Opcode::ReturnValue), - ]); - driver(cx, instructions, constants, name, desktop) -} - -/// repeat_call/collect_and_continue 的共同分配助手,把已组装指令与常量变成有宿主 Function 类型的 callable。 -fn driver( - cx: &mut NativeContext<'_>, - instructions: Vec, - constants: Vec, - name: &'static str, - desktop: ObjectRef, -) -> Result { - // 编码常量池与指令后带上宿主诊断位置;字节码有效性由 Aster 的代码构造接口检查。 - let code = EndorCode::from_instructions(&instructions, constants, CodeLayout::default())? - .with_location(name, "", 1); - // NativeContext 跟踪临时代码根;函数的 trace 边持有代码,不能只靠 Rust ObjectRef 数值保活。 - let code = cx.allocate(EndorCodeObject::new(code))?; - // 生成驱动不查用户名字,私有 globals 隔离它的空命名环境。 - let globals = cx.new_dict()?; - // 返回函数根由原生输出机制提升,代码和 globals 的临时根在域结束后可安全清理。 - let function = cx.new_function(name, code, globals)?; - crate::ui_bridge::attach_desktop_type(cx, function, "Function", desktop)?; - Ok(function) -} - -/// repeat_call 和本模块测试调用,在现有指令尾部追加消费 Bool 条件的分支与回跳。 -/// true 回到本驱动偏移零,false 跳过回跳指令;不新建调用帧,因此不会用递归栈模拟循环。 -pub fn repeat_while(instructions: &mut Vec) -> Result<(), VmError> { - // 跳转单位是编码后的双字节 code unit,不是 Instruction 数量。 - // 大操作数会生成 EXTENDED_ARG,因此必须编码后计算实际长度。 - let body = Instruction::encode_all(instructions)?.len() / 2; - // 先用最短零操作数估计回跳宽度,下面迭代直到最终操作数与编码宽度自洽。 - let mut back = Instruction::new(Opcode::JumpBackward, 0); - // 回跳距离包含自身宽度;而距离变大又可能扩大自身编码宽度。 - // 迭代到宽度/距离一致后,false 跳过回跳指令,true 回到整个驱动的起点。 - loop { - // units 是当前回跳指令实际占用的 code unit,可能因 EXTENDED_ARG 大于一。 - let units = Instruction::encode_all(&[back])?.len() / 2; - // 距离覆盖原 body、一个条件分支和回跳自身;目标为开头,不是仅回到上一个 Call。 - let distance = u32::try_from(body + 1 + units) - .map_err(|_| VmError::ExecutionLimit("layout bytecode"))?; - if back.argument == distance { - // 已收敛时 false 跳过 units 个单元,true 落到 JumpBackward 回到开头。 - instructions.push(Instruction::new(Opcode::PopJumpIfFalse, units as u32)); - instructions.push(back); - return Ok(()); - } - // 更新操作数后再次编码量宽度;不能只计算一次,跨 255 等边界可能新增 EXTENDED_ARG。 - back.argument = distance; - } -} - -#[cfg(test)] -mod tests { - use super::*; - use endor_core::{ExecutionLimits, Vm}; - #[test] - /// Rust 测试框架调用,构造大于单字节跳距的循环,分别验证退出、指令预算及无泄漏清理。 - fn repeated_bytecode_handles_extended_operands_and_keeps_one_frame() { - // 300 个 Nop 强制跨越单字节跳转距离:false 应正常退出;true 应耗尽指令预算, - // 而非耗尽帧预算,从而验证循环确实复用同一个执行帧。 - for condition in [false, true] { - // Nop 扩大 body 编码长度,与实际布局节点数量无关,直接覆盖回跳扩展操作数的边界。 - let mut instructions = vec![Instruction::simple(Opcode::Nop); 300]; - instructions.push(Instruction::new(Opcode::LoadConst, 0)); - repeat_while(&mut instructions).unwrap(); - instructions.extend([ - Instruction::new(Opcode::LoadConst, 1), - Instruction::simple(Opcode::ReturnValue), - ]); - // 条件从常量池读取,false 分支跳过回跳后装入 Nil 并正常返回。 - let code = EndorCode::from_instructions( - &instructions, - vec![Value::Bool(condition), Value::Nil], - CodeLayout::default(), - ) - .unwrap(); - // 每种条件独立 VM,统计回收时不受另一轮遗留对象影响。 - let mut vm = Vm::new().unwrap(); - // 将纯代码值注册到 VM,执行结束后显式释放此拥有根。 - let code = vm.new_code(code).unwrap(); - // 空全局字典满足执行接口,不引入额外用户对象。 - let globals = vm.new_dict().unwrap(); - // 故意只允许一帧:如果实现递归重复而非同帧跳转,会得到错误的帧数耗尽。 - let result = vm.execute_with_limits( - code, - globals, - ExecutionLimits { - max_frames: 1, - max_instructions: 1000, - }, - ); - if condition { - // true 永不自然退出,应耗尽 instructions 而非 frames,证明循环复用了同一帧。 - assert!(matches!( - result, - Err(VmError::ExecutionLimit("instructions")) - )); - } else { - // false 只走一次 body 然后返回 Nil,证明分支跳过长度包含完整扩展回跳指令。 - assert_eq!(result.unwrap(), Value::Nil); - } - vm.release(code).unwrap(); - vm.release(globals).unwrap(); - // 释放代码与全局字典后执行循环回收,确认生成的常量/函数没有遗留托管对象。 - vm.collect_cycles(); - assert_eq!(vm.object_count(), 0); - } - } + nexus::vm_sequence::collect_and_continue( + cx, + collector, + function, + arguments, + name, + &DesktopFunctions(desktop), + ) } diff --git a/vendor/README.md b/vendor/README.md index 4cfc954..c24cdd5 100644 --- a/vendor/README.md +++ b/vendor/README.md @@ -3,6 +3,7 @@ | Entry | Purpose | | --- | --- | | `README.md` | Source checkout, version selection, and update instructions | +| [nexus](nexus/README.md) | Local `endorphin-nexus-runtime` Rust library; ordinary source directory, no separate Git or remote yet | | [aster](aster/README.md) | `endorphin-aster-vm` source submodule; provides the Endor frontend, compiler, objects, and VM | ## Checkout diff --git a/vendor/nexus/.gitignore b/vendor/nexus/.gitignore new file mode 100644 index 0000000..ea8c4bf --- /dev/null +++ b/vendor/nexus/.gitignore @@ -0,0 +1 @@ +/target diff --git a/vendor/nexus/Cargo.lock b/vendor/nexus/Cargo.lock new file mode 100644 index 0000000..7afb968 --- /dev/null +++ b/vendor/nexus/Cargo.lock @@ -0,0 +1,220 @@ +# This file is automatically @generated by Cargo. +# It is not intended for manual editing. +version = 4 + +[[package]] +name = "anyhow" +version = "1.0.104" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "330a5ed07fa54e4702c9d6c4174f74427fc0ef6e214bbd677ae50a5099946470" + +[[package]] +name = "autocfg" +version = "1.5.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f2032f911046de80f0a198e0901378627c33f59ea0ac00e363d481118bd70a53" + +[[package]] +name = "compiler" +version = "0.1.0" +dependencies = [ + "core", + "frontend", +] + +[[package]] +name = "core" +version = "0.1.0" +dependencies = [ + "objects", +] + +[[package]] +name = "endorphin-nexus-runtime" +version = "0.1.0" +dependencies = [ + "anyhow", + "compiler", + "core", + "frontend", +] + +[[package]] +name = "frontend" +version = "0.1.0" +dependencies = [ + "peg", + "serde", + "serde_json", +] + +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + +[[package]] +name = "memchr" +version = "2.8.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cf8baf1c55e62ffcace7a9f06f4bd9cd3f0c4beb022d3b367256b91b87513d98" + +[[package]] +name = "num-bigint" +version = "0.4.8" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c89e69e7e0f03bea5ef08013795c25018e101932225a656383bd384495ecc367" +dependencies = [ + "num-integer", + "num-traits", +] + +[[package]] +name = "num-integer" +version = "0.1.47" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7ce2d95d4b3734dc35aa2f45e1aa22cd416814592a4f9d9205e11affd5b8e10b" +dependencies = [ + "num-traits", +] + +[[package]] +name = "num-rational" +version = "0.4.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f83d14da390562dca69fc84082e73e548e1ad308d24accdedd2720017cb37824" +dependencies = [ + "num-bigint", + "num-integer", + "num-traits", +] + +[[package]] +name = "num-traits" +version = "0.2.19" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "071dfc062690e90b734c0b2273ce72ad0ffa95f0c74596bc250dcfd960262841" +dependencies = [ + "autocfg", +] + +[[package]] +name = "objects" +version = "0.1.0" +dependencies = [ + "num-bigint", + "num-rational", + "num-traits", +] + +[[package]] +name = "peg" +version = "0.8.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0aad070be5b63aa72103f2fcdd70a83adbd5e90112ce5b574171ff1c65501773" +dependencies = [ + "peg-macros", + "peg-runtime", +] + +[[package]] +name = "peg-macros" +version = "0.8.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ddd8ef6825cae95355031ae26a99b616a2a21f22ba2de0197c43dfb05acbe7ee" +dependencies = [ + "peg-runtime", + "proc-macro2", + "quote", +] + +[[package]] +name = "peg-runtime" +version = "0.8.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7011d97b484a5ebdc4b1fdb3b12d5e4bbbea56e9d22b688f2e79e04b65a7d8a6" + +[[package]] +name = "proc-macro2" +version = "1.0.107" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "985e7ec9bb745e6ce6535b544d84d6cd6f7ad8bd711c398938ae983b91a766d9" +dependencies = [ + "unicode-ident", +] + +[[package]] +name = "quote" +version = "1.0.47" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1fbf4db142a473a8d80c26bbf18454ed458bf8d26c8219c331daecfdbd079001" +dependencies = [ + "proc-macro2", +] + +[[package]] +name = "serde" +version = "1.0.229" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4148590afebada386688f18773da617792bf2ef03ffc1e4cbd2b1d45b023e0ba" +dependencies = [ + "serde_core", + "serde_derive", +] + +[[package]] +name = "serde_core" +version = "1.0.229" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "67dca2c9c51e58a4791a4b1ed58308b39c64224d349a935ab5039aa360942a48" +dependencies = [ + "serde_derive", +] + +[[package]] +name = "serde_derive" +version = "1.0.229" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7a5d71263a5a7d47b41f6b3f06ba276f10cc18b0931f1799f710578e2309348" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + +[[package]] +name = "syn" +version = "3.0.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d78c8dee4c7bf0e14673097256fed6142ce9d3b85a408189d07482442145823b" +dependencies = [ + "proc-macro2", + "quote", + "unicode-ident", +] + +[[package]] +name = "unicode-ident" +version = "1.0.27" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a2c754d6c33795a1c324727428e5a7dedb5b06195f9890bdbcba760d3e246563" + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/vendor/nexus/Cargo.toml b/vendor/nexus/Cargo.toml new file mode 100644 index 0000000..5ee82e5 --- /dev/null +++ b/vendor/nexus/Cargo.toml @@ -0,0 +1,16 @@ +# 本地 Nexus Rust library;暂未初始化独立 Git,也没有远程仓库。 +[package] +name = "endorphin-nexus-runtime" +version = "0.1.0" +edition = "2024" +rust-version = "1.91" +description = "Host-extensible Endor runtime built on Aster" +license = "MIT OR Apache-2.0" + +[dependencies] +# 运行时边界的错误聚合;UI 类型与窗口依赖由宿主自行维护。 +anyhow = "1.0" +# 与 Tessera 显式依赖同一份 Aster,避免托管句柄来自不同版本/堆实现。 +compiler = { path = "../aster/crates/compiler" } +endor_core = { package = "core", path = "../aster/crates/core" } +frontend = { path = "../aster/crates/frontend" } diff --git a/vendor/nexus/README.md b/vendor/nexus/README.md new file mode 100644 index 0000000..80b3edf --- /dev/null +++ b/vendor/nexus/README.md @@ -0,0 +1,13 @@ +# Endorphin Nexus Runtime(本地抽取中) + +这是 GUI 进程内运行的 Rust library,包名为 `endorphin-nexus-runtime`。目前放在 `vendor/nexus` 普通目录,尚未初始化独立 Git,也没有远程仓库。后续建仓需另获用户明确授权。 + +依赖方向为 Tessera → Nexus → Aster。Nexus 通过相邻的 `vendor/aster` 使用与 Tessera 相同版本的语言 crate,没有 Tessera、窗口或渲染依赖。`HostRegistration` 由 Tessera 的 `bridge/nexus_host.rs` 实现,为同一个 owning VM 注册 UI 类型和全局能力。 + +当前已抽取源码分段/位置修正、计划编译与隔离表达式求值、AST 预算、VM 根清理、I/O provider、同帧调用序列以及定时/I/O/协作任务引擎。持久输入通过 `VmSession::prepare_input` 完整准备后,再由 `execute_input` 消费执行,保留原全局对象和最后值 `_`。任务宿主通过 `TaskHost` 提供作用域存储、资格检查与名义类型,通用引擎不检查 UI payload。Tessera 保留任务/驱动的 UI 策略适配;源码和 I/O 的无用转发模块已删除。 + +完整程序由 `PreparedProgram` 统一准备并执行,`main`/页面策略由宿主决定;`with_call_result` 负责宿主处理后的返回根清理。会话 VM/根表/环境字段已限制在库内,宿主通过显式借用和根转交接口接入。`ConsoleHistory` 管理累计预算、原文和接受凭据;UI 代码投影仍由 Tessera 生成。HTTP/原生 worker 属于 Tessera 的宿主组合,不放入通用语言库。实现已接入,并已完成本次本地编译与回归。窗口、Mount 路由、布局/绘制刷新、文档发布与 UI API 属于 Tessera 适配,不能靠 Nexus 反向依赖来搬运。 + +`tests/host_registration.rs` 覆盖无 UI 宿主注册、部分失败清理、源码计划的跨片全局与跨度;`tests/tasks.rs` 通过普通对象宿主覆盖同键替换、交付前资格撤销及退出门闩;`tests/console.rs` 覆盖持久输入和编译/执行失败边界;`tests/program.rs` 覆盖完整装载及宿主处理错误后的清理;`tests/history.rs` 覆盖历史与累计限额;原驱动循环回归随实现保留。本次已获明确本机编译/测试授权:14 个集成回归与 1 个单元回归全部通过,所有目标 Clippy(警告视为错误)通过。Tessera 的 190 个常规测试均覆盖通过,1 个可选性能基准忽略;Aster 完整检查脚本通过。首次沙箱运行中的 11 个 HTTP 用例因禁止监听本地端口失败,允许回环网络后该组 16 个测试全部通过。 + +后续验证应分别执行 Tessera 的集成测试和 `cargo test --manifest-path vendor/nexus/Cargo.toml`。Tessera 单独执行 `cargo test` 不会自动运行依赖库 Nexus 的单元/集成测试;不能把它的通过替代本库验证。 diff --git a/vendor/nexus/src/budget.rs b/vendor/nexus/src/budget.rs new file mode 100644 index 0000000..72a395f --- /dev/null +++ b/vendor/nexus/src/budget.rs @@ -0,0 +1,43 @@ +//! 执行前语法结构预算;脚本各根共享累计节点数,位置与语法节点由 Aster 提供。 +use anyhow::{Result, bail}; +use frontend::{Span, ast::visitor::Visitor}; + +/// 一份输入最多访问的 AST 节点数,与运行指令预算分开。 +pub const MAX_AST_NODES: usize = 10_000; +/// 单个根的嵌套路径上限,leave_node 归还深度。 +pub const MAX_AST_DEPTH: usize = 64; + +#[derive(Default)] +/// 编译前的语法节点数量/嵌套预算,限制输入结构复杂度。 +pub struct AstBudget { + // 当前递归路径深度,leave_node 归还;不能与累计节点数共用一个计数。 + depth: usize, + // 已访问节点总量,多个 Script 根共享累计,leave_node 不减少。 + nodes: usize, +} + +impl Visitor for AstBudget { + type Error = anyhow::Error; + /// PreparedProgram::compile、VmSession::prepare_input 与 evaluate 调用 Aster Visitor;进入任意节点时共用本检查。 + fn enter_node(&mut self, _span: Span) -> Result<()> { + // 每次进入节点累计总数和当前深度;leave 只归还深度,整份输入总量不会因退出子树重置。 + self.depth += 1; + self.nodes += 1; + if self.depth > MAX_AST_DEPTH || self.nodes > MAX_AST_NODES { + // 在加载/执行代码前停止,防止巨大源码结构绕过仅约束运行指令的 LIMITS。 + bail!("Aster AST exceeds the 64-level or 10000-node host budget"); + } + Ok(()) + } + /// 离开当前语法节点时归还嵌套深度;累计节点数保留,不能通过退出子树绕过总量预算。 + fn leave_node(&mut self) { + self.depth -= 1; + } +} + +impl AstBudget { + /// 宿主累计 Console/程序结构预算时读取已检查节点总量,不改变遍历状态。 + pub fn nodes(&self) -> usize { + self.nodes + } +} diff --git a/vendor/nexus/src/console.rs b/vendor/nexus/src/console.rs new file mode 100644 index 0000000..fce60d3 --- /dev/null +++ b/vendor/nexus/src/console.rs @@ -0,0 +1,280 @@ +//! 持久输入的完整编译与同 VM 执行;不包含窗口、代码浏览树、文档发布或 UI 刷新。 +//! Tessera 在 prepare_input 成功后处理宿主清理与输入记录,再消费 PreparedInput 执行一次。 +//! 编译失败不执行任何片段;运行失败不回滚已经完成的全局写入或外部副作用。 +use crate::{ + DEFAULT_LIMITS as LIMITS, MAX_SOURCE_BYTES, VmSession, + budget::{AstBudget, MAX_AST_NODES}, + program::compile_plan, + runtime_error, + source::{self, SourcePlan}, +}; +use anyhow::{Result, bail}; +use endor_core::{ExecutionLimits, Value, Vm}; +use frontend::{ + EndorReader, SourceUnit, + ast::{AstRoot, StmtKind, visitor::Visitor}, +}; + +#[derive(Default)] +/// 已接受输入的计数与原文历史,不保留 VM 句柄或任何 UI 投影。 +/// prepare 只验证/编译;宿主完成前置清理后 accept,再执行已接受输入,失败也不回滚历史。 +pub struct ConsoleHistory { + // 接受的 Console 输入数;从完整程序开始时仍为零。 + inputs: usize, + // 完整程序加所有已接受输入的节点总量,不因一次执行错误而退回。 + ast_nodes: usize, + // 完整程序原文和输入分隔记录;运行时不通过回放它恢复业务堆。 + source: String, +} + +/// 已接受输入的拥有型凭据,保留同一准备结果及投影位置;不携带 VM 根。 +pub struct AcceptedInput { + // 转移准备结果的所有权,避免同一准备值被重复接受或执行。 + input: PreparedInput, + // 一基输入号,与来源标签和 transcript 分隔注释一致。 + number: usize, + // 当前输入局部一基行号需要增加的偏移;分隔注释也占一行。 + line_offset: usize, +} +impl AcceptedInput { + /// 宿主生成代码投影时借用已接受的同一份原文和 AST。 + pub fn input(&self) -> &PreparedInput { + &self.input + } + /// 投影建立后执行已接受输入;消费凭据且不取回准备结果,避免被再次接受或重放。 + pub fn execute(self, runtime: &mut VmSession) -> Result { + runtime.execute_input(self.input) + } + /// 宿主建立投影身份或响应输入编号时读取。 + pub fn number(&self) -> usize { + self.number + } + /// 宿主平移输入投影时读取,保留 CRLF、CR 和末尾空行规则。 + pub fn line_offset(&self) -> usize { + self.line_offset + } +} +impl ConsoleHistory { + /// 完整程序加载成功后建立历史;AST 预算从完整程序计数开始,Console 输入数从零开始。 + pub fn from_program(program: &crate::program::PreparedProgram) -> Self { + Self { + inputs: 0, + ast_nodes: program.ast_nodes(), + source: program.source().text().to_owned(), + } + } + /// 宿主发布文档时借用原文,不允许适配层直接改写预算所依据的文本。 + pub fn source(&self) -> &str { + &self.source + } + /// 已接受的输入数,执行失败不会使编号重用。 + pub fn inputs(&self) -> usize { + self.inputs + } + /// 已接受输入及原程序累计的结构量,供宿主统计或检查。 + pub fn ast_nodes(&self) -> usize { + self.ast_nodes + } + + /// 先限制原始输入,再限制累计次数和含分隔余量的字节预算;不修改历史。 + fn check_input(&self, text: &str) -> Result<()> { + if text.len() > MAX_SOURCE_BYTES { + bail!("input exceeds 1 MiB"); + } + // 80 字节余量沿用原 Console 契约,涵盖输入注释与换行;饱和加法也拒绝异常的大外部状态。 + if self.inputs >= 256 + || self + .source + .len() + .saturating_add(text.len()) + .saturating_add(80) + > MAX_SOURCE_BYTES + { + bail!("console session exceeds 256 inputs or 1 MiB; reset the session to continue"); + } + Ok(()) + } + /// 同步串行宿主调用:完整编译前不记输入号,也不改文本;使用 VM 当前真实 globals。 + pub fn prepare( + &self, + runtime: &VmSession, + session_id: u64, + text: &str, + ) -> Result { + self.check_input(text)?; + // 来源使用下一接受号,但准备失败不消耗它;完整原文仍交给同一个 SourceUnit。 + let source = EndorReader::from_text( + format!("console session {} input {}", session_id, self.inputs + 1), + text, + ); + runtime.prepare_input(source, self.ast_nodes) + } + /// 消费完整准备结果并立即记历史,调用方随后执行;串行宿主不得把准备结果跨历史错配。 + pub fn accept(&mut self, input: PreparedInput) -> Result { + // 再检查当前预算,避免宿主在 prepare 与 accept 之间接受其他输入后绕过限额。 + self.check_input(input.source().text())?; + if self.ast_nodes.saturating_add(input.ast_nodes()) > MAX_AST_NODES { + bail!("console session exceeds 10000 AST nodes; reset the session to continue"); + } + // 所有检查成功才一起推进编号与结构计数;之后的执行错误仍占用本次预算。 + self.inputs += 1; + self.ast_nodes += input.ast_nodes(); + // 仅给已有文本补分隔行,不修改被编译输入本身的换行与跨度。 + if !self.source.is_empty() && !self.source.ends_with('\n') { + self.source.push('\n'); + } + // 与代码投影共用字节行首规则,CRLF 只记一次,孤立 CR 也计行。 + let line_offset = crate::source::line_starts(&self.source).len(); + // 显式输入分隔让 Sources 可对应编号;它不作为本次 VM 执行的源文本。 + self.source + .push_str(&format!("// Console input {}\n", self.inputs)); + self.source.push_str(input.source().text()); + // 只为下一条 transcript 记录补尾换行;当前执行仍读取准备结果中的独立原文。 + if !self.source.ends_with('\n') { + self.source.push('\n'); + } + Ok(AcceptedInput { + input, + number: self.inputs, + line_offset, + }) + } +} + +/// 一份已经完整编译的输入;字段私有,确保 AST、原文、编译片段与节点计数来自同一次准备。 +/// 不保存托管根或 VM 句柄;准备和执行之间宿主不得另行改变全局名称契约。 +pub struct PreparedInput { + // 拥有原始 UTF-8 快照,宿主可用它生成诊断和源码浏览投影。 + source: SourceUnit, + // AST 片段与 compiled 同源同序,执行时不重新解析或回放历史。 + plan: SourcePlan, + // 模板还不拥有 VM 代码对象,load 后的代码根只跨一次执行。 + compiled: Vec, + // 当前输入的累计结构量,宿主接受输入时才合并到会话计数。 + ast_nodes: usize, +} +impl PreparedInput { + /// 宿主记录原文和来源,不规范化文本或更改编译时的跨度。 + pub fn source(&self) -> &SourceUnit { + &self.source + } + /// 宿主创建纯数据代码投影时借用 AST,不暴露可被错配的独立模板列表。 + pub fn plan(&self) -> &SourcePlan { + &self.plan + } + /// 成功准备不等于接受输入;调用方在宿主清理成功后再累计此值。 + pub fn ast_nodes(&self) -> usize { + self.ast_nodes + } +} +impl VmSession { + /// 用实际 globals 中的名称完整编译输入;不改业务堆,也不更新宿主的历史或计数。 + pub fn prepare_input( + &self, + source: SourceUnit, + ast_nodes_used: usize, + ) -> Result { + // 公共库入口也检查原文字节预算,不能依赖某个 GUI 调用方预先检查。 + if source.text().len() > MAX_SOURCE_BYTES { + bail!("input exceeds 1 MiB"); + } + // plan 保留完整模块或同源交互片段;这里不执行已解析的任何前半段。 + let plan = source::parse(&source)?; + // 输入内共享计数器,结构预算成功后才枚举真实全局名和编译。 + let mut budget = AstBudget::default(); + for ast in plan.roots() { + budget.visit_ast_root(ast)?; + } + if ast_nodes_used.saturating_add(budget.nodes()) > MAX_AST_NODES { + bail!("console session exceeds 10000 AST nodes; reset the session to continue"); + } + // 查询所属会话的借用环境身份;缺少初始化是调用契约错误,不能偷偷建立新环境。 + let globals = self + .globals + .ok_or_else(|| anyhow::anyhow!("runtime globals not initialized"))?; + // 只复制字符串名称;不把托管 Value 或对象根藏在编译准备结果中。 + let names = self + .vm + .dict_items(globals)? + .iter() + .filter_map(|(key, _)| { + if let Value::Text(name) = key { + Some(name.clone()) + } else { + None + } + }) + .collect(); + // 先完整编译所有片段,成功后把原文/AST/模板一起交还,不改变历史或业务绑定。 + let compiled = compile_plan(&source, &plan, names)?; + Ok(PreparedInput { + source, + plan, + compiled, + ast_nodes: budget.nodes(), + }) + } + + /// 消费已准备输入,在当前真实 globals 上执行并保留最后值到 _;仅返回纯文本给宿主。 + /// 宿主应先记录已接受输入,执行后再安排 UI 刷新;错误不表示此前语句已经撤销。 + pub fn execute_input(&mut self, input: PreparedInput) -> Result { + // 继续操作相同真实字典,不从历史原文回放或创建替代业务对象。 + let globals = self + .globals + .ok_or_else(|| anyhow::anyhow!("runtime globals not initialized"))?; + // 多根均分本次硬预算,不让后续片段每个都获得完整一百万条指令。 + let limits = ExecutionLimits { + max_instructions: LIMITS.max_instructions / input.compiled.len().max(1), + ..LIMITS + }; + // 依次覆盖为最后一个片段的可显示值;本局部只保存字符串,不延长任意返回对象寿命。 + let mut rendered_value = "nil".to_owned(); + for (ast, template) in input.plan.roots().iter().zip(&input.compiled) { + // 代码根只跨一次 execute,先暂存 Result 再 release(code),失败也有清理。 + let code = template.load(&mut self.vm)?; + // VM 执行真实 globals,不把本轮 AST 当快照去覆盖旧业务状态。 + let executed = self + .vm + .execute_with_limits(code, globals, limits) + .map_err(|error| runtime_error(&self.vm, error)); + self.vm.release(code)?; + // execute 返回拥有根,后面 repr/全局 _ 更新是否成功都必须释放这份根。 + let value = executed?; + // 绑定/赋值语句展示其新变量实际值,普通表达式展示返回值;不是仅显示该语句执行的 Unit。 + let display = if let AstRoot::Interactive(input) = ast { + match &input.statements[0].kind { + StmtKind::Binding(binding) => self + .vm + .dict_get(globals, &Value::Text(binding.name.text.clone()))? + .unwrap_or_else(|| value.clone()), + StmtKind::Assignment(assignment) => self + .vm + .dict_get(globals, &Value::Text(assignment.name.text.clone()))? + .unwrap_or_else(|| value.clone()), + _ => value.clone(), + } + } else { + value.clone() + }; + // 先算 repr 并把实际最后值写入全局 _,保留未命名 UI 对象;随后释放 execute 返回根,错误也逐项传播。 + let repr = value_repr(&self.vm, &display); + // _ 的字典强边独立保留最后值,避免匿名 Block 在 Console 显示后马上丢失身份。 + let retained = self.vm.dict_set(globals, Value::Text("_".into()), display); + self.vm.release_value(value)?; + retained?; + rendered_value = repr?; + } + Ok(rendered_value) + } +} + +/// execute_input 在保存全局 _ 前调用,把真实返回值/新绑定值转成显示字符串;返回根仍由调用者释放。 +fn value_repr(vm: &Vm, value: &Value) -> Result { + Ok(match value { + Value::Nil => "nil".into(), + Value::Bool(v) => v.to_string(), + Value::Text(v) => format!("{v:?}"), + Value::Number(v) => v.to_string(), + Value::Object(v) => vm.repr(*v)?, + }) +} diff --git a/src/runtime/io_tasks.rs b/vendor/nexus/src/io_tasks.rs similarity index 99% rename from src/runtime/io_tasks.rs rename to vendor/nexus/src/io_tasks.rs index 512daad..8c8db9f 100644 --- a/src/runtime/io_tasks.rs +++ b/vendor/nexus/src/io_tasks.rs @@ -2,7 +2,7 @@ //! Lease 由托管任务拥有,释放会撤销交付资格并取消可取消的后台工作;已经完成的结果还要由 VM worker 检查归属后才能交付。 //! 并发、队列、读取字节数、超时和 URL 协议均有边界,避免 provider 绕过运行时资源限制。 //! -//! runtime::tasks 为 readText/fetchText 创建 Task 时调用 Provider::submit,并把返回 Lease 放进 Task payload。 +//! Nexus tasks 为 readText/fetchText 创建 Task 时调用 Provider::submit,并把返回 Lease 放进 Task payload。 //! Scheduler 轮询 Provider::take_ready 后在 owning VM 中核验弱身份、owner/key 与取消状态,再调用源回调。 //! 所有 Provider 共用一个全进程有界线程池;每个运行时仍有自己的结果邮箱与租约额度,不互读 Task 堆。 use endor_core::{VmError, WeakObjectRef}; diff --git a/vendor/nexus/src/lib.rs b/vendor/nexus/src/lib.rs new file mode 100644 index 0000000..84a2bb3 --- /dev/null +++ b/vendor/nexus/src/lib.rs @@ -0,0 +1,30 @@ +//! GUI 进程内的通用 Endor 运行时库,依赖 Aster,不依赖 Tessera 的模型、窗口或渲染器。 +//! 宿主向 VmSession 注册能力;源码组织、编译、根清理和驱动字节码由本库实现。 +//! 本地抽取仍在进行;持久输入准备/执行已进入本库,输入历史、UI 发布及 worker 组合仍由 Tessera 承接。 + +/// 编译前结构预算;多段脚本共享同一个访问器累计计数。 +pub mod budget; +/// 持久输入的完整准备与同 VM 执行,返回纯文本并保留真实全局身份。 +pub mod console; +/// 纯数据后台读取及租约取消,不在线程池中操作 VM。 +pub mod io_tasks; +/// 无 UI 名称假设的源码计划编译与隔离表达式执行。 +pub mod program; +mod session; +/// 原文分段、AST 根及跨度平移;具体语法由 Aster 定义。 +pub mod source; +/// 通用定时、I/O、协作任务调度;宿主通过 TaskHost 提供对象生命周期规则。 +pub mod tasks; +/// VM 内调用序列与循环驱动,函数名义身份交由宿主注册接口处理。 +pub mod vm_sequence; + +pub use program::evaluate; +pub use session::{HostRegistration, VmSession, runtime_error}; + +/// 默认源执行硬预算,脚本调用方按片段数分摊,不为每段重置全部额度。 +pub const DEFAULT_LIMITS: endor_core::ExecutionLimits = endor_core::ExecutionLimits { + max_frames: 128, + max_instructions: 1_000_000, +}; +/// 原始输入字节上限,不以 Unicode 字符数或 AST 节点数替代。 +pub const MAX_SOURCE_BYTES: usize = 1_048_576; diff --git a/vendor/nexus/src/program.rs b/vendor/nexus/src/program.rs new file mode 100644 index 0000000..03c379d --- /dev/null +++ b/vendor/nexus/src/program.rs @@ -0,0 +1,236 @@ +//! 无 UI 假设的源码编译与隔离表达式执行;宿主显式提供可见全局名,库不安装窗口能力。 +use crate::{ + DEFAULT_LIMITS as LIMITS, MAX_SOURCE_BYTES, VmSession, budget::AstBudget, runtime_error, + source::SourcePlan, +}; +use anyhow::{Result, bail}; +use endor_core::{ExecutionLimits, Value}; +use frontend::{ + EndorReader, SourceUnit, + ast::{AstRoot, DeclKind, Stmt, StmtKind, visitor::Visitor}, +}; +use std::collections::BTreeSet; + +/// 完整程序的不可拆分准备结果,不携带已加载代码或任何 VM 根。 +/// 宿主在建立候选 VM 前准备它,并借用原文/AST 生成自己的浏览投影。 +pub struct PreparedProgram { + // 原始文本和来源,编译元数据与宿主投影使用同一份快照。 + source: SourceUnit, + // 区分完整模块与脚本片段,决定执行预算分配以及宿主是否调用入口函数。 + plan: SourcePlan, + // 每片模板对应相同位置的 AST 根,不允许宿主单独替换其中一侧。 + compiled: Vec, + // 整份源码的结构计数,宿主后续 Console 输入在此基础上累计。 + ast_nodes: usize, +} +impl PreparedProgram { + /// 显式宿主全局名只用于静态编译;所有语法和代码生成仍由 Aster 完成。 + pub fn compile(source: SourceUnit, globals: BTreeSet) -> Result { + // 在解析或分配模板前限制原始 UTF-8 字节,避免执行预算无法约束的前端开销。 + if source.text().len() > MAX_SOURCE_BYTES { + bail!("source exceeds the 1 MiB limit"); + } + // 完整模块保持一个根,顶层脚本保留源序片段;原文和跨度仍属于同一快照。 + let plan = crate::source::parse(&source)?; + // 所有片段累计结构预算,失败时还没有目标 VM 或部分业务写入。 + let mut budget = AstBudget::default(); + for ast in plan.roots() { + budget.visit_ast_root(ast)?; + } + // 所有根成功编译才返回准备结果;宿主此时尚未创建/改写候选 VM。 + let compiled = compile_plan(&source, &plan, globals)?; + Ok(Self { + source, + plan, + compiled, + ast_nodes: budget.nodes(), + }) + } + /// 宿主展示原文/诊断时借用,不改行尾或字节跨度。 + pub fn source(&self) -> &SourceUnit { + &self.source + } + /// 宿主自行决定模块入口/页面策略,本库不调用约定名称 main。 + pub fn plan(&self) -> &SourcePlan { + &self.plan + } + /// 后续持久输入的累计预算起点;不包括宿主 UI 投影节点。 + pub fn ast_nodes(&self) -> usize { + self.ast_nodes + } +} + +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +/// 装载代码根的生命周期,保留原一次性候选与持久执行两条路径的清理策略。 +pub enum CodeRetention { + /// 代码根加入会话根表,close 逆序释放;即使执行失败也由会话清理。 + Session, + /// 代码仅跨当前片段执行,错误也先释放它再传播。 + Execution, +} +impl VmSession { + /// 在现有全局环境执行完整定义/脚本,不自动调用 main、打开窗口或解释最后返回值。 + pub fn execute_program( + &mut self, + program: &PreparedProgram, + retention: CodeRetention, + ) -> Result<()> { + // 使用所属会话已拥有的字典;这是借用身份,执行函数不新增第二份全局根。 + let globals = self + .globals + .ok_or_else(|| anyhow::anyhow!("runtime globals not initialized"))?; + // 模块一个单元使用完整预算;脚本将同一硬预算均分给全部片段。 + let limits = match program.plan() { + SourcePlan::Module(_) => LIMITS, + SourcePlan::Script(_) => ExecutionLimits { + max_instructions: LIMITS.max_instructions / program.compiled.len().max(1), + ..LIMITS + }, + }; + // 严格按片段源序装载执行,前段失败即停止;不自动执行宿主约定的入口。 + for template in &program.compiled { + // load 返回目标堆中的代码拥有根,由下方选定的生命周期策略归还。 + let code = template.load(&mut self.vm)?; + if retention == CodeRetention::Session { + // 先登记拥有根再执行,部分执行失败时根仍可被 close 找到。 + self.roots.push(code); + } + // 暂存成功/错误,让 Execution 策略在传播错误前也能归还代码根。 + let executed = self + .vm + .execute_with_limits(code, globals, limits) + .map_err(|error| runtime_error(&self.vm, error)); + if retention == CodeRetention::Execution { + // 暂存 Result 使失败执行也经过代码根归还,保持持久加载路径的顺序。 + self.vm.release(code)?; + } + // 顶层返回值不作为隐式展示根;宿主稍后自行处理约定入口的返回结果。 + self.vm.release_value(executed?)?; + } + Ok(()) + } +} + +/// PreparedProgram::compile、VmSession::prepare_input 和独立编译测试调用,按源序编译全部根,支持模块与声明前向引用。 +pub fn compile_plan( + source: &SourceUnit, + plan: &SourcePlan, + mut globals: BTreeSet, +) -> Result> { + // 先收集全部函数/类声明名以支持前向引用;普通绑定仍按源码执行次序逐段加入已知全局名。 + for root in plan.roots() { + if let AstRoot::Interactive(input) = root { + // 完整模块的声明可见性由 Aster 自己处理;只有拆成多个交互根时宿主需预收集声明名。 + for statement in &input.statements { + if let StmtKind::Declaration(decl) = &statement.kind { + // 只预声明函数/类,不提前把任意赋值名当作已存在业务值。 + let name = match &decl.kind { + DeclKind::Function(function) => &function.name, + DeclKind::Class(class) => &class.name, + }; + globals.insert(name.text.clone()); + } + } + } + } + // 每个根保留一个模板,执行顺序必须与原根切片一一对应,不能按名字排序。 + let mut compiled = Vec::with_capacity(plan.roots().len()); + /// 本函数在每段成功编译后调用,递归收集后续段可能引用的绑定名,不执行或预测条件真值。 + fn assigned(statement: &Stmt, globals: &mut BTreeSet) { + match &statement.kind { + StmtKind::Binding(b) => { + // 绑定给后续片段的静态名称解析提供名字;字典中的真实值仍在执行时建立。 + globals.insert(b.name.text.clone()); + } + StmtKind::Assignment(a) => { + // 顶层赋值也可能引入名字,按 Aster 交互语义让后续段可以编译引用。 + globals.insert(a.name.text.clone()); + } + StmtKind::If(b) => { + // 两个分支都收集“可能声明”名字,不在编译阶段决定哪条路径会执行。 + for s in &b.body.statements { + assigned(s, globals); + } + if let Some(other) = &b.otherwise { + // else 中的潜在绑定也要让后续片段可编译引用,但这里不预先在 globals 字典创建实际值。 + for s in &other.statements { + assigned(s, globals); + } + } + } + StmtKind::While(b) => { + // 循环体可能写入全局;是否真正执行一次由 VM 决定,宿主不展开循环。 + for s in &b.body.statements { + assigned(s, globals); + } + } + // 表达式、return、成员赋值等不引入新的普通全局名;函数内部作用域由语言编译器处理。 + _ => {} + } + } + for root in plan.roots() { + // 每段得到当前已知全局集合快照,先编译再把本段绑定加入下一段上下文。 + let options = compiler::CompileOptions { + globals: globals.iter().cloned().collect(), + }; + compiled.push( + compiler::compile_ast(root, source, &options) + .map_err(|error| source.annotate(error))?, + ); + // 每段编译成功才把绑定/赋值名字加入下一段编译上下文,语法与代码生成都继续委托 Aster。 + if let AstRoot::Interactive(input) = root { + for statement in &input.statements { + assigned(statement, &mut globals); + } + } + } + Ok(compiled) +} + +/// api::worker 的 evaluate 请求调用,在一次性无 UI 全局的隔离 VM 求单表达式,返回可显示字符串。 +pub fn evaluate(source: &str) -> Result { + if source.len() > MAX_SOURCE_BYTES { + bail!("expression exceeds the 1 MiB limit"); + } + // 独立来源名明确区别于持久 Console transcript,不读取其历史或对象堆。 + let source = EndorReader::from_text("console expression", source); + // 隔离 evaluate 只接受一个表达式,默认编译选项不安装 ui 桥接,也不读已发布程序的 globals。 + let ast = frontend::parse_source_ast(&source, frontend::ParseMode::Expression)?; + AstBudget::default().visit_ast_root(&ast)?; + // 默认全局只有语言内置,不为 evaluate 暗中安装 ui 或活程序用户全局。 + let compiled = compiler::compile_ast(&ast, &source, &compiler::CompileOptions::default()) + .map_err(|error| source.annotate(error))?; + // 独立候选统一持有执行根,表达式失败也由 close 释放整个域。 + let mut candidate = VmSession::new()?; + // 暂存执行/格式化错误,保证外层 close 不因这里的 ? 被跳过。 + let result = (|| { + // 表达式全局环境为空的新字典,不能用运行时 namespace 文档代替真实 globals。 + let globals = candidate.vm.new_dict()?; + candidate.globals = Some(globals); + candidate.roots.push(globals); + // 模板加载到此 VM 后才有真实代码对象,拥有根记入 Candidate。 + let code = compiled.load(&mut candidate.vm)?; + candidate.roots.push(code); + // 一次有界执行产生拥有返回值,字符串化后显式释放。 + let value = candidate + .vm + .execute_with_limits(code, globals, LIMITS) + .map_err(|error| runtime_error(&candidate.vm, error))?; + // 只把标量或对象 repr 字符串交回 API,真实 Value 随一次性 VM 清理,不跨线程交付托管引用。 + let rendered = match &value { + Value::Nil => "nil".to_owned(), + Value::Bool(v) => v.to_string(), + Value::Text(v) => format!("{v:?}"), + Value::Number(v) => v.to_string(), + Value::Object(v) => candidate.vm.repr(*v)?, + }; + candidate.vm.release_value(value)?; + Ok(rendered) + })(); + // 先尝试关闭候选,再合并执行和清理结果,不能只因表达式已有字符串结果就跳过清理。 + let cleanup = candidate.close(); + match (result, cleanup) { + (Ok(value), Ok(())) => Ok(value), + (Err(e), _) | (_, Err(e)) => Err(e), + } +} diff --git a/vendor/nexus/src/session.rs b/vendor/nexus/src/session.rs new file mode 100644 index 0000000..74faceb --- /dev/null +++ b/vendor/nexus/src/session.rs @@ -0,0 +1,157 @@ +//! owning VM 与外部根的生命周期;只负责语言运行域,不包含视觉发布或窗口关闭策略。 +use anyhow::{Result, bail}; +use endor_core::{ExecutionLimits, ObjectRef, Value, Vm, VmError}; + +/// 宿主向 Nexus 会话安装领域能力,返回的适配状态仍由宿主持有。 +/// register 内分配且需长期保活的根必须登记 roots;失败由会话 close/Drop 收尾。 +pub trait HostRegistration { + /// 宿主自己的能力状态,Nexus 不解释其中窗口、布局或业务协议。 + type Installed; + /// owning 线程调用,globals 借用;注册到字典的对象由实际内部强边保活。 + fn register( + &self, + vm: &mut Vm, + roots: &mut Vec, + globals: ObjectRef, + ) -> Result; +} + +/// 拥有 VM、全局字典与宿主保留根;关闭时按顺序释放,失败也必须收尾。 +pub struct VmSession { + // 实际解释器/托管堆,仅执行 worker 线程操作,不放入共享 NamespaceState。 + pub(crate) vm: Vm, + // 宿主安装期间保留的拥有根,close 逆序 pop;ObjectRef Rust 数值本身没有自动 release 行为。 + pub(crate) roots: Vec, + // 主全局字典也在 roots 中,先清字典断业务根,再统一释放根,避免闭包环残留。 + pub(crate) globals: Option, +} + +impl VmSession { + /// 创建独立 VM,先不保留任何宿主根或全局字典;后续安装失败也由该候选负责清理。 + pub fn new() -> Result { + Ok(Self { + vm: Vm::new()?, + roots: Vec::new(), + globals: None, + }) + } + + /// 宿主读取所属 VM;借用不会转移堆或根的拥有权。 + pub fn vm(&self) -> &Vm { + &self.vm + } + + /// 宿主在 owning 线程推进领域调用/续体;不得替换 VM 或绕过返回值的 release 契约。 + pub fn vm_mut(&mut self) -> &mut Vm { + &mut self.vm + } + + /// 借用主环境身份,清理由会话负责;宿主不能覆盖或取走全局拥有根。 + pub fn globals(&self) -> Option { + self.globals + } + + /// 把调用方已经拥有的一份根转交会话;不会额外 retain,也不能传入只有借用权的句柄。 + pub fn keep_root(&mut self, root: ObjectRef) { + self.roots.push(root); + } + + /// 为受信任宿主的安装/回收提供短时共同借用,不转移 VM 或根表的拥有权。 + /// 宿主移除根时必须同步归还对应拥有引用;不得替换 VM、保存这些可变引用或隐式复制根。 + pub fn with_host(&mut self, host: impl FnOnce(&mut Vm, &mut Vec) -> R) -> R { + host(&mut self.vm, &mut self.roots) + } + + /// 宿主建立会话主环境,登记一份拥有根;重复调用拒绝,避免覆盖未清理的环境。 + pub fn create_globals(&mut self) -> Result { + // 环境身份只能在同一会话初始化一次,业务重绑定通过字典操作进行。 + if self.globals.is_some() { + bail!("runtime globals already initialized"); + } + // 分配成功后同时保存清理入口和拥有根,安装宿主失败时 Drop 仍可收尾。 + let globals = self.vm.new_dict()?; + self.globals = Some(globals); + self.roots.push(globals); + Ok(globals) + } + + /// Tessera/其他宿主注册其领域能力;Nexus 只调用接口,不引用宿主具体类型。 + pub fn register_host(&mut self, host: &H) -> Result { + // 必须先有真实主环境;不在库中猜测 ui、窗口、页面等宿主名字。 + let globals = self + .globals + .ok_or_else(|| anyhow::anyhow!("runtime globals not initialized"))?; + host.register(&mut self.vm, &mut self.roots, globals) + } + + /// 调用后把返回值借给宿主处理;处理成功或返回错误,都先归还 VM 返回的拥有根。 + /// handler 如需保留对象必须建立真实托管边或显式 retain;不能把借用 ObjectRef 当拥有结果带出。 + pub fn with_call_result( + &mut self, + callee: ObjectRef, + args: &[Value], + limits: ExecutionLimits, + handler: impl FnOnce(&mut Vm, &Value) -> Result, + ) -> Result { + // VM 成功返回时 value 拥有一份根;先在这里保存,宿主处理不得接管或跳过其归还责任。 + let value = self + .vm + .call_with_limits(callee, args, limits) + .map_err(|error| runtime_error(&self.vm, error))?; + // 先保存宿主处理结果,避免其中的 ? 跳过返回根释放;清理失败优先传播。 + let handled = handler(&mut self.vm, &value); + self.vm.release_value(value)?; + handled + } + + /// compile/evaluate 显式调用,VmSession::drop 兜底调用;按拥有顺序拆根并验证堆没有遗留对象。 + pub fn close(&mut self) -> Result<()> { + // 清全局字典先断业务对象可达根,再逆序释放宿主分配根;最后执行循环回收并验证对象计数归零。 + if let Some(globals) = self.globals.take() { + // take 使重复 close 不重复清同一身份;先断用户全局再释放类型/函数等宿主根。 + self.vm.dict_clear(globals)?; + } + // pop 逐项移出确保再次 close 不重复释放已成功处理的根;错误仍交显式关闭调用方报告。 + while let Some(root) = self.roots.pop() { + self.vm.release(root)?; + } + self.vm.collect_cycles(); + if self.vm.object_count() != 0 { + // 源程序返回了纯数据也不掩盖资源泄漏,显式 close 会把这个错误报告给调用者。 + bail!("candidate VM retained objects after cleanup"); + } + Ok(()) + } +} + +impl Drop for VmSession { + /// 析构调用 VmSession.close 释放候选根和 VM,覆盖提前返回/异常展开;析构不能向调用者报告清理错误。 + fn drop(&mut self) { + // 显式 close 可以报告引用计数/清理错误;Drop 则保证提前返回和异常展开仍经过最终清理边界。 + let _ = self.close(); + } +} + +/// 本模块和 bridge/tasks 的 VM 错误映射调用,立即取 last_traceback 拼成纯文本,避免后续调用覆盖故障栈。 +pub fn runtime_error(vm: &Vm, error: VmError) -> anyhow::Error { + // 错误发生后立即读取 VM traceback,保留函数、源文件与指令偏移;无栈信息时直接保留原 VmError。 + let locations = vm + .last_traceback() + .iter() + .map(|frame| { + // 每帧保留来源文件、函数名和指令位置,不把托管异常对象直接跨线程交付。 + format!( + "{}:{} in {} (instruction {})", + frame.filename, frame.first_line, frame.function, frame.instruction_offset + ) + }) + .collect::>() + .join("\n"); + if locations.is_empty() { + // 无 VM 栈时保留原始 VmError,不能凭当前源码猜一个错误行号。 + error.into() + } else { + // 含栈则附加每帧可读位置,Console/API 不需读取 VM 就能展示错误。 + anyhow::anyhow!("{error}\n{locations}") + } +} diff --git a/src/runtime/endor_script.rs b/vendor/nexus/src/source.rs similarity index 91% rename from src/runtime/endor_script.rs rename to vendor/nexus/src/source.rs index 246a1a6..c74546e 100644 --- a/src/runtime/endor_script.rs +++ b/vendor/nexus/src/source.rs @@ -1,7 +1,7 @@ //! 区分完整 Module 与顶层 Script,并保留输入源码位置。 //! 解析包装或片段拼接产生的 span 偏移要递归修正,保证诊断和 Sources 视图仍指向用户原始行列。 //! -//! runtime::endor_host 的一次性 compile 和持久会话加载调用 parse,再按 roots 进行 AST 预算检查与编译。 +//! Nexus PreparedProgram 与 VmSession::prepare_input 调用 parse,再按 roots 进行 AST 预算检查与编译。 //! 语句、词法和 AST 定义属于 Aster;这里只把完整源码组织成 Module 或连续 Interactive 输入。 //! 片段先用局部字节位置解析,shift_* 递归加回起点,编译错误和 Sources 浏览才能仍对应原文件。 use anyhow::Result; @@ -19,7 +19,7 @@ pub enum SourcePlan { } impl SourcePlan { - /// endor_host 的 AST 预算访问和 compile_plan 调用,借用统一根切片,不克隆 AST 或重新解析。 + /// PreparedProgram/prepare_input 的 AST 预算访问和 compile_plan 调用,借用统一根切片,不克隆 AST 或重新解析。 pub fn roots(&self) -> &[AstRoot] { match self { // 单模块以单元素切片适配,让调用方不必维护两套遍历分支。 @@ -30,9 +30,9 @@ impl SourcePlan { } } -/// endor_host 执行入口调用,优先接受完整 Module,失败则按顶层换行候选边界拼出 Aster 可解析的交互输入。 +/// PreparedProgram/prepare_input 的源码准备入口调用,优先接受完整 Module,失败则按顶层换行候选边界拼出 Aster 可解析的交互输入。 /// 模块解析失败本身不立即作为最终错误:普通顶层脚本本就需要走后面的 Interactive 解析路径。 -/// 这里只产出 AST 计划,不执行已接受的片段;endor_host 先完成所有根的预算检查和编译,再进入源代码执行。 +/// 这里只产出 AST 计划,不执行已接受的片段;Nexus 先完成所有根的预算检查和编译,再进入源代码执行。 pub fn parse(source: &SourceUnit) -> Result { // 完整模块优先;只有模块解析失败才退回连续交互输入模式,宿主不自行实现 Endor 语法。 if let Ok(module) = frontend::parse_source_ast(source, ParseMode::Module) { @@ -265,3 +265,18 @@ fn shift_expression(expression: &mut Expr, offset: usize) { } } } + +/// architecture/execute_mode 调用,建立字节偏移→行号的搜索索引,兼容 CRLF、LF 和孤立 CR。 +pub fn line_starts(source: &str) -> Vec { + // Span 使用 UTF-8 字节单位,所以不用 chars().enumerate() 的字符索引匹配它。 + let bytes = source.as_bytes(); + // 按字节扫描行终止符,CRLF 仅在 LF 记一次,孤立 CR 也换行;空文本仍保留第1行起点0。 + let mut starts = vec![0]; + for (offset, byte) in bytes.iter().enumerate() { + if *byte == b'\n' || (*byte == b'\r' && bytes.get(offset + 1) != Some(&b'\n')) { + // 记录换行符之后的下一行首,CRLF 只在 LF 分支记录一次,空末行也有可定位起点。 + starts.push(offset + 1); + } + } + starts +} diff --git a/vendor/nexus/src/tasks.rs b/vendor/nexus/src/tasks.rs new file mode 100644 index 0000000..829a098 --- /dev/null +++ b/vendor/nexus/src/tasks.rs @@ -0,0 +1,1259 @@ +//! owner/key 管理的异步任务与协作式源函数调度。弱索引用于查找,回调、等待对象和协程帧是托管图中的真实边。 +//! 任务可能处于等待 I/O、定时器、可执行协程或等待另一任务的状态;取消 owner/key 不能让晚到结果再次执行。 +//! 调度使用有界量子和公平推进;await 挂起后保留操作数与帧,不重放此前副作用。失败和依赖环有明确处理路径。 +//! +//! ui_bridge::bootstrap 调用 install,注册 ui.after/sleep/readText/fetchText/spawn 并取得每 VM 的 Scheduler。 +//! 源 API 经 After 创建 Task;UiBridge/endor_host 的轮询调用 Scheduler::poll,才在所属 VM 交付结果或推进协程。 +//! 页面/窗口关闭调用 cancel_owner,运行时退出调用 quiesce;只取消身份和执行边,不允许旧 I/O 结果复活它们。 +//! 通用调度由 Nexus 负责;scope/eligible 的展示规则由 TaskHost 提供,Tessera 适配器仍掌握 UI payload。 +//! +//! 一次交付需要三项同时成立:Task 仍处于可推进状态、owner 仍有宿主资格、owner/key 字典仍指向这个精确 Task。 +//! eligible 只检查宿主资格,current 只检查同键身份,不能互相替代;Task.status/active 的查询也使用同一划分。 +//! poll 先把邮箱纯数据转入 Task,再按工作预算轮转;advance_coroutine 保存 await/软挂起状态,finish 才清理执行边。 +//! Completed/Failed 的 token 可由源变量继续持有和查询;finish 撤销仍匹配的 owner/key 边,prune 在轮末移除终态弱索引。 +use std::{ + sync::{ + Arc, Mutex, + atomic::{AtomicBool, Ordering}, + }, + time::{Duration, Instant}, +}; + +use anyhow::{Result, bail}; +use endor_core::{ + ContextNativeFunction, NativeCallable, NativeContext, NativeResult, ObjectPayload, ObjectRef, + ObjectStore, Value, Vm, VmError, WeakObjectRef, +}; + +/// 宿主提供 owner 的作用域、交付资格及 Task 名义类型,Nexus 不检查具体 UI payload。 +/// 实现必须通过 Aster 写屏障建立 owner→scope 强边;策略本身不得藏有未 trace 的托管句柄。 +/// context 是借用的宿主注册域,由 install 创建的原生 callable captures 保活;使用 Scheduler 时宿主域须仍存活。 +pub trait TaskHost: std::fmt::Debug + Send + Sync { + /// 查询拥有字典,不分配;无作用域返回 None,畸形作用域应传播错误。 + fn scope(&self, store: &ObjectStore, owner: ObjectRef) -> Result, VmError>; + /// 首次提交时保存字典;必须让 owner 的托管图真实拥有 scope。 + fn install_scope( + &self, + cx: &mut NativeContext<'_>, + owner: ObjectRef, + scope: ObjectRef, + ) -> Result<(), VmError>; + /// 创建、查询、交付前核对宿主生命周期,不代替 Nexus 的同 key 身份检查。 + fn eligible( + &self, + store: &ObjectStore, + owner: ObjectRef, + context: ObjectRef, + ) -> Result; + /// 返回宿主已注册的 Task 类型借用身份;创建 API 与实例方法须使用同一类型。 + fn task_type(&self, store: &ObjectStore, context: ObjectRef) -> Result; +} + +// 单 VM 弱调度索引的活任务预算;已完成任务可被源变量持有,但不继续占调度槽。 +const MAX_TASKS: usize = 1024; +// 单 owner 作用域字典的项数上限;同 key 替换不新增一项,允许在满额度时进行。 +const MAX_OWNER_TASKS: usize = 64; +// 一轮 poll 最多完成/推进/取消的工作数,避免任务队列独占 VM worker。 +const MAX_READY: usize = 64; + +// 调度器只保存弱任务身份,不因排队把任务、回调或 owner 隐式保活。 +type Index = Arc>>; + +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +/// 任务对源代码可见的生命周期状态,完成/取消/失败各有不同 await 语义。 +enum State { + // 等截止时间、I/O 或首次推进;不表示后台操作尚未开始。 + Pending, + // 普通回调正在执行,或协作任务已有保存的协程,仍可能处于 await 等待。 + Running, + // 正常终态,允许 await/result 读取保存的结果或 Nil。 + Completed, + // 失去 owner/key 资格或主动取消的终态,await 应报告 AwaitCancelled。 + Cancelled, + // provider/回调/协程失败,error 保存诊断而非可当作成功值交付的文字。 + Failed, +} +impl State { + /// Task.status 方法调用,返回稳定的小写 API 状态字符串,不用于控制调度分支。 + fn name(self) -> &'static str { + match self { + Self::Pending => "pending", + Self::Running => "running", + Self::Completed => "completed", + Self::Cancelled => "cancelled", + Self::Failed => "failed", + } + } +} + +#[derive(Debug, Clone)] +/// 托管异步对象,保存 owner/key、结果与真正拥有的回调/协程/等待引用。 +struct Task { + // owner 通过 scope 字典强持有 Task,Task 的 owner 字段反向使用弱边;callback/协程仍可能形成由 GC 处理的真实引用环。 + owner: WeakObjectRef, + // owner 内唯一键,作用域字典决定它是否仍是当前任务;不是跨运行时的全局 ID。 + key: String, + // 单调时钟截止点;ready 与到期是两个独立条件,I/O 完成不受系统日期调整影响。 + due: Instant, + // 定时/I/O 的零参回调或 spawn 的初始函数,由 trace 声明真实强边。 + callback: Option, + // 真实执行状态;只读 status 可能因失去资格投影为 cancelled,而不立刻改写此字段。 + state: State, + // 定时/协作任务创建即 ready,但仍等 due;I/O 任务等 provider 结果写回后才 ready。 + ready: bool, + // I/O 成功纯文本,普通回调执行期间也可通过 Task.result 查询;非托管字符串不需 trace。 + text: Option>, + // provider/执行失败的有界预览,Completed 的成功值不能与此混用。 + error: Option>, + // 仅任务 payload 持有 I/O 租约;取消/终态清除此边即可撤销后台交付并归还额度。 + lease: Option>, + // 仅 spawn 为 true:使用可恢复 Coroutine 和软量子,其余回调一次有界调用完成。 + cooperative: bool, + // spawn 首次推进创建的托管协程帧,后续 resume 保留此前副作用与累计硬预算。 + coroutine: Option, + // 协程 await 的对象是真实托管强边;等待期间由它保活被等待值,不以弱调度索引代替。 + waiting: Option, + // 协程最终返回的任意语言值;对象结果也经 trace 保活,取消时清掉。 + result: Option, +} +impl ObjectPayload for Task { + /// 提供受检查的 Any 下转型入口,让宿主按具体 payload 类型读取数据。 + fn as_any(&self) -> &dyn std::any::Any { + self + } + /// 返回运行时诊断/类型检查使用的稳定 payload 名称。 + fn kind_name(&self) -> &'static str { + "tessera-task" + } + /// 声明此 payload 的赋值遵循引用身份语义,避免把内部宿主状态当作可复制值。 + fn reference_assignment_only(&self) -> bool { + true + } + /// Aster 的 await 执行和 Scheduler 的等待检查调用,查询状态而不递归推进任务或 VM。 + fn poll_await(&self) -> Result { + match self.state { + // I/O 已收到 ready 文本但尚未真正处理到终态时,await 仍不能抢先越过回调。 + State::Pending | State::Running => Ok(endor_core::AwaitPoll::Pending), + // 协作任务优先返回保存的任意 Value,I/O 返回 text,普通定时器默认为 Nil。 + State::Completed => Ok(endor_core::AwaitPoll::Ready( + self.result.clone().unwrap_or_else(|| { + // 协作返回值优先,否则 I/O 文本转语言字符串,纯计时器/sleep 无值则返回 Nil。 + self.text + .as_ref() + .map(|text| Value::Text(text.to_string())) + .unwrap_or(Value::Nil) + }), + )), + State::Cancelled => Err(VmError::AwaitCancelled), + State::Failed => Err(VmError::AwaitFailed( + self.error.as_deref().unwrap_or("task failed").into(), + )), + } + } + /// 枚举本对象真正拥有的托管强引用,供 Aster 引用追踪和循环回收使用。 + fn trace(&self, visit: &mut dyn FnMut(ObjectRef)) { + // Aster GC 只追踪真实拥有边,owner/调度索引的弱身份均不得在这里访问。 + if let Some(callback) = self.callback { + visit(callback); + } + if let Some(coroutine) = self.coroutine { + // spawn 的保存帧是真实拥有边,包含已执行到的位置和局部值;不能靠弱索引让挂起帧碰巧存活。 + visit(coroutine); + } + if let Some(waiting) = self.waiting { + // await 的目标在等待期间必须可达,取消或 finish 会清此边;它与 coroutine 自身的身份不同。 + visit(waiting); + } + if let Some(Value::Object(result)) = self.result { + // 成功协程可返回任意对象,Task.result 要在外层创建根释放后继续拥有它;标量结果无托管边可追踪。 + visit(result); + } + } +} +/// API 解码和 Task 方法检查共用错误构造器,调用位置与源栈由外层 VM 诊断补充。 +fn invalid(message: &'static str) -> VmError { + VmError::InvalidArgument(message) +} +/// After/Method/作用域遍历解码对象值时调用,只复制句柄,不建立隐藏托管强边。 +fn object(value: &Value) -> Result { + match value { + Value::Object(object) => Ok(*object), + _ => Err(invalid("task owner and callback must be managed objects")), + } +} +/// After 替换、Task 方法、Scheduler 和 finish 调用,验证 owner/key 字典仍精确指向本任务,防止旧代际交付。 +fn current( + host: &dyn TaskHost, + store: &ObjectStore, + owner: ObjectRef, + reference: ObjectRef, + task: &Task, +) -> Result { + // key 指向的对象必须恰是当前 Task,替换后旧 Task 即使还被外部持有,也不能接收结果或执行回调。 + Ok(match host.scope(store, owner)? { + Some(scope) => { + // 外部仍持有旧 Task token 也不能绕过同键替换,必须精确比对 Value::Object 身份。 + store.dict_get(scope, &Value::Text(task.key.clone()))? == Some(Value::Object(reference)) + } + None => false, + }) +} + +/// window/页面关闭与 Mount 退役边界调用,取消 owner 全部任务;同一输入 close 后再 open 也不能复活旧任务。 +pub fn cancel_owner( + host: &dyn TaskHost, + cx: &mut NativeContext<'_>, + owner: ObjectRef, +) -> Result<(), VmError> { + // 无作用域表示从未拥有任务,关闭仍正常成功,不为取消动作反而分配一个新字典。 + let Some(scope) = host.scope(cx.store(), owner)? else { + return Ok(()); + }; + // 克隆条目后逐个变更字典;取消 pending/running 的执行边,再删除所有 owner/key 拥有边。 + for (key, value) in cx.store().dict_items(scope)?.to_vec() { + // 复制字典项使删除不会使迭代借用失效;每个值必须是当前 VM 的 Task。 + let reference = object(&value)?; + // 取消修改副本并经写屏障提交,释放 callback/coroutine/waiting 的真实托管强边。 + let mut task = cx.store().payload::(reference, "Task")?.clone(); + if matches!(task.state, State::Pending | State::Running) { + // 终态内容不重新改成 Cancelled,但所有 owner/key 字典边最后都会解除。 + task.state = State::Cancelled; + task.callback = None; + task.lease = None; + task.coroutine = None; + task.waiting = None; + task.text = None; + task.result = None; + cx.replace_payload(reference, task)?; + } + cx.dict_delete(scope, &key)?; + } + Ok(()) +} + +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +/// 当前宿主 API 的操作分类,分派代码负责参数校验与状态更新。 +enum Operation { + Timer, + Sleep, + ReadText, + FetchText, + Spawn, +} +#[derive(Debug)] +/// 创建定时/I/O/协作任务时的原生调用适配器。 +struct After { + // 区分计时、无回调 sleep、后台读取与协作 spawn,决定参数形状和初始 ready 状态。 + operation: Operation, + // 源 API 和轮询 Scheduler 共用同一个 Provider mailbox,I/O 线程不接触此 VM。 + provider: crate::io_tasks::Provider, + // install 按具体 API 构造的完整数量/类型/效果契约,进入 invoke 前由 VM 检查。 + signature: endor_core::CallSignature, + // 弱调度索引,不是 Task 的拥有者;真正拥有边在 owner 的作用域字典。 + index: Index, + // spawn 创建后置位,让 worker 知道有可推进协程,prune 在轮末重新计算。 + runnable: Arc, + // shutdown/quiesce 置位的单向门闩,清理回调不得再提交新任务。 + quiescing: Arc, + // 主资源域用于 Task 类型和跨窗口 owner 登记校验,不把 Task 固定到某个 current 页。 + context: ObjectRef, + // 宿主策略不自行拥有托管对象;context 的强边仍由原生函数 captures 声明。 + host: Arc, +} +impl NativeCallable for After { + /// 给出参数与返回值的托管类型契约;实际操作在 invoke 中执行。 + fn signature(&self) -> Option { + Some(self.signature.clone()) + } + /// 直接使用创建时准备的 after/sleep/readText/fetchText/spawn 签名数量,和具体 API 一致。 + fn arity(&self) -> Option { + Some(self.signature.arity) + } + + /// VM 执行 ui.after/sleep/readText/fetchText/spawn 时调用,验证全部输入再建立新 owner/key 身份,最后取消旧项。 + fn invoke(&self, cx: &mut NativeContext<'_>, args: &[Value]) -> Result { + let host = self.host.as_ref(); + // 退出域先拒绝新任务;只读渲染也禁止异步提交,即使某构造操作只分配新的任务对象。 + if self.quiescing.load(Ordering::Acquire) { + // 退出门闩优先于任何分配/外部 I/O,卸载回调不能重建任务延长资源域寿命。 + return Err(invalid("runtime is exiting; new tasks are forbidden")); + } + if cx.store().is_read_only() { + // 提交任务会改作用域/调度资格,即使只分配新 Task 也不是合法的纯测量/绘制操作。 + return Err(invalid( + "asynchronous work is forbidden during read-only rendering", + )); + } + // 统一解码不同 API 参数:spawn 用零延时与回调,sleep 无回调,I/O 第三个位置是路径/URL。 + // spawn 没有延时参数,借一个局部零值复用后面的毫秒校验,不扩展源 API 参数表。 + let zero = Value::Number(0_i64.into()); + // 统一得到 owner/key/输入/可选回调四部分;此处只借源实参,不在尚未验证时分配 Task。 + let (owner, key, delay, callback) = match args { + [owner, key, callback] if self.operation == Operation::Spawn => { + // spawn 的第三实参是零参源函数,不能误作 delay 或路径解析。 + (owner, key, &zero, Some(callback)) + } + // sleep 无回调,只通过 await/Task 结果状态通知完成。 + [owner, key, delay] if self.operation == Operation::Sleep => (owner, key, delay, None), + // 四参形状服务 after 和带回调 I/O;第三位稍后依据 operation 解释成毫秒或路径。 + [owner, key, delay, callback] => (owner, key, delay, Some(callback)), + [owner, key, path] + if matches!(self.operation, Operation::ReadText | Operation::FetchText) => + { + // 三参 I/O 返回可 await Task,不要求为了接收文本而人为提供一个空回调。 + (owner, key, path, None) + } + _ => { + // 元数据检查外仍防御直接调用/不匹配形状,不让后面按错误的位置读取输入。 + return Err(invalid( + "asynchronous request requires owner, key, delay/path and optional I/O callback", + )); + } + }; + // owner 必须是真正托管对象,随后 eligible 再检查其展示生命周期。 + let owner = object(owner)?; + // Some(错误值) 传播类型错误,None 仅表示合法无回调 API,二者不可混同。 + let callback = callback.map(object).transpose()?; + // 所有回调都按零显式参数执行,必须是 Function 且参数元数据确认接受零参,不能等执行时再碰运气。 + if let Some(callback) = callback { + // 是否带 receiver 已由 VM 绑定函数体现,数量校验针对调用者仍需传的未绑定实参。 + if !cx.store().object(callback)?.payload().is_function() { + return Err(invalid("task callback must be a Function")); + } + if !cx + .store() + .call_arity(callback)? + .ok_or(invalid("task callback requires positional metadata"))? + .accepts(0) + { + return Err(invalid("task callback requires zero unbound parameters")); + } + } + // key 是相同 owner 内的替换身份,不允许用任意对象 repr 当作不稳定字典键。 + let Value::Text(key) = key else { + return Err(invalid("task key must be text")); + }; + // key 是 owner 内替换/取消身份,限制 UTF-8 字节长度与控制字符,禁止空 key。 + if key.is_empty() || key.len() > 128 || key.chars().any(char::is_control) { + return Err(invalid("invalid task key")); + } + // I/O 得到零计时延迟和后台 Request,计时/协作则得到毫秒数且没有外部请求。 + let (milliseconds, request) = + if matches!(self.operation, Operation::ReadText | Operation::FetchText) { + // 原局部名 delay 此时借用的是路径/URL 字符串,按 operation 先分流再判断实际类型。 + let Value::Text(path) = delay else { + return Err(invalid("I/O input must be a String")); + }; + // 只创建纯数据请求,provider 提交发生在 Task 已分配并有可取消租约的位置。 + let request = match self.operation { + Operation::ReadText => { + // 路径允许平台路径语义但拒绝空、过长或 NUL;文件类型/字节预算由 worker 再查。 + if path.is_empty() || path.len() > 4096 || path.contains('\0') { + return Err(invalid("invalid text path")); + } + crate::io_tasks::Request::ReadText(path.clone()) + } + Operation::FetchText => { + // 在创建后台工作前拒绝不支持 URL,worker 仍再次校验以维护独立边界。 + if !crate::io_tasks::valid_url(path) { + return Err(invalid( + "expected HTTP(S) URL without credentials or control characters", + )); + } + crate::io_tasks::Request::FetchText(path.clone()) + } + Operation::Timer | Operation::Sleep | Operation::Spawn => unreachable!(), + }; + (0, Some(request)) + } else { + // 只有计时/sleep/spawn 进入这里,spawn 由上面借用零 Number,因此也受同一整数约束。 + let Value::Number(delay) = delay else { + return Err(invalid( + "task delay must be an integer number of milliseconds", + )); + }; + // 定时延迟要求整数毫秒,范围为零到一天;spawn 复用零延迟路径,禁止小数/负数。 + let milliseconds = delay + .as_i64() + .filter(|delay| (0..=86_400_000).contains(delay)) + .ok_or(invalid( + "task delay must be 0..86400000 integer milliseconds", + ))?; + (milliseconds, None) + }; + if !host.eligible(cx.store(), owner, self.context)? { + // 不允许关闭/卸载对象创建新工作,即使源代码仍通过变量持有它的 ObjectRef。 + return Err(invalid("task owner is closed or detached")); + } + // 在分配新任务前找同 key 旧身份,额度检查允许替换但不允许借其他 key 继续增加总量。 + let existing_scope = host.scope(cx.store(), owner)?; + // 读取可选旧 Task,不删除旧项;新任务的参数/预算/分配失败时应保留旧身份。 + let previous = existing_scope + .map(|scope| cx.store().dict_get(scope, &Value::Text(key.clone()))) + .transpose()? + .flatten() + .map(|value| object(&value)) + .transpose()?; + // 短锁覆盖调度索引剪枝及最终换表,过程不运行源回调,避免看到半次替换索引。 + let mut index = self + .index + .lock() + .map_err(|_| invalid("task index poisoned"))?; + // 提交时压缩弱索引,只保留还存活且 pending/running 的任务;终态不占调度名额。 + let mut live = Vec::new(); + for weak in index.iter().copied() { + if let Some(task) = cx.upgrade(weak)? + && matches!( + cx.store().payload::(task, "Task")?.state, + State::Pending | State::Running + ) + { + // NativeContext 临时升级的根在本次调用结束释放,live 保存的仍只有弱身份。 + live.push(weak); + } + } + if live.len() >= MAX_TASKS && previous.is_none() { + // 同 key 替换不是扩容;新 key 在总量上限时必须失败,不能通过长期保存 Task token 绕过。 + return Err(VmError::ExecutionLimit("1024 pending tasks per runtime")); + } + if let Some(scope) = existing_scope + && cx.store().dict_items(scope)?.len() >= MAX_OWNER_TASKS + && previous.is_none() + { + // owner 局部额度独立于全运行时额度,同 key 仍可原位更新已有槽。 + return Err(VmError::ExecutionLimit("64 pending tasks per owner")); + } + // 先分配并设置截止点/状态,再安装 I/O 租约和 owner 字典边;弱 owner 不承担保活作用。 + let task = cx.allocate(Task { + owner: cx.store().downgrade(owner)?, + key: key.clone(), + due: Instant::now() + .checked_add(Duration::from_millis(milliseconds as u64)) + .ok_or(invalid("task deadline overflow"))?, + callback, + state: State::Pending, + ready: matches!( + self.operation, + Operation::Timer | Operation::Sleep | Operation::Spawn + ), + text: None, + error: None, + lease: None, + cooperative: self.operation == Operation::Spawn, + coroutine: None, + waiting: None, + result: None, + })?; + cx.attach_type(task, host.task_type(cx.store(), self.context)?)?; + if let Some(request) = request { + // 只有旧任务仍待完成且真的持有 I/O 租约才使用 provider 临时替换额度,不给普通任务扩大 I/O 上限。 + let replacing = previous + .map(|previous| { + // 只有实际未完成 I/O 能归还一个旧租约,终态/纯定时器不能借来放宽 provider 上限。 + cx.store().payload::(previous, "Task").map(|task| { + matches!(task.state, State::Pending | State::Running) + && task.lease.is_some() + }) + }) + .transpose()? + .unwrap_or(false); + // 非阻塞提交拿到交付资格;后台即使很快完成,VM 交付仍等后续 poll 核验 owner/key。 + let lease = self + .provider + .submit(cx.store().downgrade(task)?, request, replacing)?; + // 把租约写进 Task payload 才成为其生命周期资源,后台 Job 自己不持有 Lease。 + let mut value = cx.store().payload::(task, "Task")?.clone(); + value.lease = Some(lease); + cx.replace_payload(task, value)?; + } + + // 首次提交才安装字典;以后同 owner 复用 scope,key 替换始终在同一拥有表中发生。 + let task_scope = if let Some(scope) = existing_scope { + // 已有作用域保持原字典身份;替换不使其他 key 的 Task 所有权发生变化。 + scope + } else { + // 第一个任务才分配字典并建立 owner→scope 强边,之后 dict_set 建立 scope→Task 强边。 + let scope = cx.new_dict()?; + host.install_scope(cx, owner, scope)?; + scope + }; + // 先保存新旧身份所需弱键,下面登记成功才取消旧 Task;此处不是向 GUI 发布画面。 + let previous_weak = previous.map(|old| cx.store().downgrade(old)).transpose()?; + // 替换字典边前临时升级旧任务,避免 dict_set 删除最后拥有边后,清理旧 payload 时对象已被回收。 + if let Some(weak) = previous_weak { + cx.upgrade(weak)?; + } + cx.dict_set(task_scope, Value::Text(key.clone()), Value::Object(task))?; + // 新 key 身份登记成功后再将旧任务取消,切断回调/协程/等待/结果与 I/O 租约,晚到结果不得复活。 + if let Some(previous) = previous { + // 前面临时升级旧身份保护它跨过字典替换,即使用户没有保存旧 Task token 也能安全清理。 + if cx.store().object(previous).is_ok() { + // 只取消仍活跃项,已完成/失败的旧 token 保留自己的终态结果供已持有者检查。 + let mut old = cx.store().payload::(previous, "Task")?.clone(); + if matches!(old.state, State::Pending | State::Running) { + old.state = State::Cancelled; + old.callback = None; + old.lease = None; + old.coroutine = None; + old.waiting = None; + old.text = None; + old.result = None; + cx.replace_payload(previous, old)?; + } + } + } + // 新 Task 的真正根已经在作用域字典中,调度器只需要弱索引,不附加第二条隐藏拥有边。 + let weak = cx.store().downgrade(task)?; + // 弱索引也移除被替换身份;spawn 额外设置 runnable 唤醒标志,使外层知道存在可推进协程。 + live.retain(|old| Some(*old) != previous_weak); + live.push(weak); + *index = live; + if self.operation == Operation::Spawn { + // cooperative 工作首次即可执行,唤醒标志让 worker 不误以为只有未来计时器而进入长等待。 + self.runnable.store(true, Ordering::Release); + } + Ok(NativeResult::Return(Value::Object(task))) + } +} + +#[derive(Debug, Clone, Copy)] +/// 该原生能力的查询/操作分类,方法包装用它选择具体实现。 +enum Query { + Cancel, + Status, + Active, + Result, + Error, +} +#[derive(Debug)] +/// install 安装到 Task 类型的原生方法包装;VM 绑定 receiver 后调用,不为每个 Task 单独创建闭包。 +struct Method { + // 包含隐式 Task receiver 的签名,查询只读,cancel 修改任务与 owner/key 字典。 + signature: endor_core::CallSignature, + // 五个 API 共用 receiver/资格检查后,各按不同状态可读性规则返回结果。 + query: Query, + // eligible 的跨窗口注册表检查使用所属 VM 主资源域,不能以 current 窗口替代。 + context: ObjectRef, + // 宿主策略不自行拥有托管对象;context 的强边仍由原生函数 captures 声明。 + host: Arc, +} +impl NativeCallable for Method { + /// 给出参数与返回值的托管类型契约;实际操作在 invoke 中执行。 + fn signature(&self) -> Option { + Some(self.signature.clone()) + } + /// Task 方法无显式参数;底层调用包含唯一一个隐式 Task 接收者。 + fn arity(&self) -> Option { + Some(endor_core::CallArity::exact(1)) + } + + /// VM 执行 task.status/active/result/error/cancel 时调用,重新核验活任务资格,查询不因失效偷偷改 payload。 + fn invoke(&self, cx: &mut NativeContext<'_>, args: &[Value]) -> Result { + let host = self.host.as_ref(); + // 方法无显式参数,实际 args 唯一一项是隐式 Task 接收者。 + let [value] = args else { + return Err(invalid("Task methods accept no arguments")); + }; + // 解码 receiver 后验证真实 Task payload,普通对象无法靠同名方法字段伪造任务。 + let reference = object(value)?; + // 状态副本用于 cancel 的写屏障提交;只读查询保留原 Task 不变。 + let mut task = cx.store().payload::(reference, "Task")?.clone(); + // pending 这里同时涵盖 Running 协程,不等同于严格的 State::Pending 枚举值。 + let pending = matches!(task.state, State::Pending | State::Running); + // 只有活任务才需验证 owner;终态结果不因 owner 后续销毁而突然不可读。 + let owner = if pending { + cx.upgrade(task.owner)? + } else { + None + }; + // active 同时要求展示资格和当前 key 精确身份,单看 Task.state 会漏掉尚未轮询清理的旧项。 + let active = if let Some(owner) = owner { + host.eligible(cx.store(), owner, self.context)? + && current(host, cx.store(), owner, reference, &task)? + } else { + false + }; + // 各方法返回类型由 install 签名对应;result 的可用性不同于 active,不能共享一个布尔快路。 + let value = match self.query { + // pending/running 但已失去 owner/key 资格时,对源报告 cancelled;只读查询不因此改写 payload。 + Query::Status => Value::Text( + if pending && !active { + State::Cancelled.name() + } else { + task.state.name() + } + .into(), + ), + Query::Active => Value::Bool(active), + // I/O 回调执行期间可读取已保存 text;协作任务必须真正 Completed 才能读最终 result,错误任务不返回成功值。 + Query::Result => { + if !matches!(task.state, State::Running | State::Completed) + || task.error.is_some() + || (task.cooperative && task.state != State::Completed) + { + // 协程未完成不能返回半成品;I/O 错误也不能把 text/Nil 当成功返回。 + return Err(invalid( + "task result is not available; inspect status and error", + )); + } + task.result.clone().unwrap_or_else(|| { + task.text + .as_ref() + .map(|text| Value::Text(text.to_string())) + .unwrap_or(Value::Nil) + }) + } + Query::Error => Value::Text( + // 只有 Failed 返回保存诊断;取消/运行中返回空错误文本,空文本本身不能作为任务已经成功的判断依据。 + if task.state == State::Failed { + task.error.as_deref().unwrap_or_default() + } else { + "" + } + .into(), + ), + Query::Cancel => { + if cx.store().is_read_only() { + // 即使任务已失效也不允许在只读渲染里执行具有取消语义的方法。 + return Err(invalid( + "task cancellation is forbidden during read-only rendering", + )); + } + if pending { + // pending 同时覆盖 Running;即使 active 已因 owner/key 失效而为 false,也清执行边,但最终返回值仍报告未取消有效任务。 + task.state = State::Cancelled; + task.callback = None; + // 取消立即放弃 I/O 租约与执行边,下面也清掉 text/result;不保留可交付的成功结果。 + task.lease = None; + task.coroutine = None; + task.waiting = None; + task.text = None; + task.result = None; + cx.replace_payload(reference, task.clone())?; + if let Some(owner) = owner + && current(host, cx.store(), owner, reference, &task)? + && let Some(scope) = host.scope(cx.store(), owner)? + { + // 必须仍是当前 key 的同一 Task 才删 owner 边,旧 token.cancel 不能删掉替换后的新任务。 + cx.dict_delete(scope, &Value::Text(task.key))?; + } + } + // 返回本次是否取消了仍有效的待执行任务;重复 cancel 或已失去资格的任务返回 false。 + Value::Bool(pending && active) + } + }; + Ok(NativeResult::Return(value)) + } +} + +/// bootstrap 返回给 UiBridge 的每 VM 调度能力,endor_host 轮询/退出时使用,原生字段不持有 Task 强根。 +pub struct Scheduler { + // 弱项顺序也是轮转顺序,实际推进过的任务在 poll 尾部移到末尾。 + index: Index, + // worker 等待策略读取此标志;只表示可能存在可运行协程,不保证下次一定完成一个任务。 + runnable: Arc, + // 退出后不可重新打开,新任务 API 与本调度器共享门闩。 + quiescing: Arc, + // 跨窗口 owner 生命周期核验的主注册域,不持 GUI 窗口指针。 + context: ObjectRef, + // 后台只提交 Completion 到邮箱,本调度器才有权在 VM 中写入 Task 与执行回调。 + provider: crate::io_tasks::Provider, + // 与创建 API 及 Task 方法使用同一宿主策略。 + host: Arc, +} +impl Scheduler { + /// UiBridge::shutdown 调用,先关新任务入口再取消所有活任务,允许退出钩子执行但不能重建工作。 + pub fn quiesce(&self, vm: &mut Vm) -> Result { + // 先设置不可逆的退出门闩再取消全部任务,防止清理回调间隙继续接收新工作。 + self.quiescing.store(true, Ordering::Release); + self.cancel_all(vm) + } + /// UiBridge/endor_host 的等待策略查询,不扫描 VM 堆,仅读取上次创建/prune 得到的可运行标志。 + pub fn has_cooperative_work(&self) -> bool { + self.runnable.load(Ordering::Acquire) + } + /// UiBridge::poll_tasks 由 endor_host 调用,在 owning VM 内交付邮箱、推进至多 limit 项工作并更新公平索引。 + /// 不在空闲轮询中扫描整堆;不可达 owner/回调环由外层变更边界的 collect_cycles 清理。 + pub fn poll(&self, vm: &mut Vm, limit: usize) -> Result { + let host = self.host.as_ref(); + // limit 是本轮工作预算而非毫秒超时,零或超过 MAX_READY 都不能进入调度。 + anyhow::ensure!((1..=MAX_READY).contains(&limit), "invalid task poll limit"); + // provider 只产纯数据,VM worker 此处重新核对任务 pending、租约仍在、owner 有效且 key 仍当前。 + for (weak, completion) in self.provider.take_ready()? { + if let Some(reference) = vm.upgrade(weak)? { + // 保存邮箱交付 Result,外层先释放 upgrade 得到的 Task 根,再传播任意中途错误。 + let result = (|| -> Result<()> { + // 任务可能在后台运行时已被源代码取消/替换,不能直接把 Completion 写进旧副本。 + let mut task = vm.payload::(reference, "Task")?.clone(); + if task.state != State::Pending || task.lease.is_none() { + // 已终态或放弃租约的晚到结果直接忽略,不设置 ready 把旧任务重新变为可执行。 + return Ok(()); + } + // 临时拥有 owner 跨过资格检查,不能在完成邮箱里保存一个长期 owner 根。 + let owner = vm.upgrade(task.owner)?; + // 即使 eligible/current 报错,也先走下面 owner 根释放路径。 + let active = (|| -> Result { + Ok(if let Some(owner) = owner { + host.eligible(vm.object_store(), owner, self.context)? + && current(host, vm.object_store(), owner, reference, &task)? + } else { + false + }) + })(); + if let Some(owner) = owner { + // 邮箱阶段仅临时升级 owner 以检查资格,无论 active 检查成功或失败都先释放这个临时根再传播结果。 + vm.release(owner)?; + } + if !active? { + // 身份/生命周期已失效,留给后续有界扫描清理,不交付回调或保存可观察成功文本。 + return Ok(()); + } + // 收到后台结果只设置 ready/text/error,实际终态与回调交付由下面的有界调度扫描决定。 + task.ready = true; + match completion { + // provider 的纯文本结果在 VM 线程转换为 Task 字段,后台不直接改对象版本。 + Ok(text) => task.text = Some(text.into()), + Err(error) => task.error = Some(error.into()), + } + vm.replace_payload(reference, task)?; + Ok(()) + })(); + vm.release(reference)?; + result?; + } + } + // 复制本轮弱索引后释放锁,用户回调可在 poll 期间提交任务,不应因重入同一索引锁死锁。 + let snapshot = self + .index + .lock() + .map_err(|_| anyhow::anyhow!("task index poisoned"))? + .clone(); + // 本轮使用同一 now 判断到期,避免长回调执行后在同轮无限吸收后来才到期的定时器。 + let now = Instant::now(); + // 取消无效任务也消耗工作预算,避免大量死亡 owner 使一次轮询无限延长。 + let mut work = 0; + // 记录本轮实际执行的弱身份,扫描结束后移到队尾形成 round-robin,不边迭代边改原表。 + let mut advanced = Vec::new(); + for weak in snapshot { + if work >= limit { + // 未扫描的任务保留原索引,下一次 poll 继续有机会运行,而非丢弃余下项。 + break; + } + // Task 已不可达时不复活它,失效弱项由 prune 最后清理。 + let Some(reference) = vm.upgrade(weak)? else { + continue; + }; + // 一项扫描的任何 VM 错误都先回到 Task 根释放,再让外层按运行时故障规则处理。 + let result = (|| -> Result<()> { + // 每轮重读当前 payload,不能沿用 mailbox 阶段或上轮协程恢复前的状态副本。 + let mut task = vm.payload::(reference, "Task")?.clone(); + if !matches!(task.state, State::Pending | State::Running) { + // 已终态仍可被用户变量持有,但不再消耗执行量子,也不能重复执行 callback。 + return Ok(()); + } + // owner 弱边可能已死亡,按取消处理而不是把当前运行时当作替代 owner。 + let owner = vm.upgrade(task.owner)?; + // 内层结果暂存,使任何回调/完成错误都不会跳过 owner 根释放。 + let result = (|| -> Result<()> { + // owner 展示资格和同 key 当前身份都必须满足,保留旧 Task token 不能继续取得执行权。 + let active = if let Some(owner) = owner { + host.eligible(vm.object_store(), owner, self.context)? + && current(host, vm.object_store(), owner, reference, &task)? + } else { + false + }; + // owner 回收、页面关闭或 key 被替换都使任务取消;取消也计一次 work,避免清理无限占用一轮。 + if !active { + work += 1; + return finish(host, vm, reference, State::Cancelled); + } + // 被等待对象未就绪则不消费量子;被取消会取消等待者,失败等其他结果交回协程 await 语义处理。 + if let Some(waiting) = task.waiting { + // 仅查询 AwaitPoll,不递归执行被等待对象,公平调度仍由外层轮询负责。 + match vm.object(waiting)?.payload().poll_await() { + Ok(endor_core::AwaitPoll::Pending) => return Ok(()), + Err(VmError::AwaitCancelled) => { + // 被等待任务取消会取消等待者;失败则留给恢复后的 await 按语言语义抛出。 + work += 1; + return finish(host, vm, reference, State::Cancelled); + } + _ => {} + } + } + if task.due > now || !task.ready { + // 时间到了不代表 I/O 已就绪,I/O 就绪也不能越过计时截止;两条件均需满足。 + return Ok(()); + } + work += 1; + // 记录实际推进的任务,轮末移到索引尾部,保证一回调空闲预算下仍能轮转多个协程。 + advanced.push(weak); + // spawn 使用可恢复协程而非普通 call;其余 I/O/定时器回调作为一次完整有界调用执行。 + if task.cooperative { + // 只推进一次软量子,完成/await/仍可运行分别由 advance_coroutine 处理。 + return advance_coroutine(host, vm, reference); + } + if task.error.is_some() { + // provider 失败不调用成功回调,用 Failed 终态让 await/error 观察原始文本诊断。 + return finish(host, vm, reference, State::Failed); + } + // sleep 或无回调 I/O 直接完成,结果已保存在 Task,不需为了 await 虚构空函数。 + let Some(callback) = task.callback else { + return finish(host, vm, reference, State::Completed); + }; + // provider 已完成,回调开始前归还 I/O 名额;text 暂留给回调中的 Task.result 查询。 + task.lease = None; + task.coroutine = None; + task.waiting = None; + // 先发布 Running 状态再进入用户代码,回调可查询任务或取消/替换自身。 + let mut running = task.clone(); + running.state = State::Running; + vm.replace_payload(reference, running)?; + // 普通回调必须一次有界完成,不是 spawn 的可恢复协程;预算不因别的任务回调重入而累加到无限。 + let result = vm + .call_with_limits( + callback, + &[], + endor_core::ExecutionLimits { + max_frames: 128, + max_instructions: 100_000, + }, + ) + .map_err(|error| crate::runtime_error(vm, error)); + match result { + Ok(value) => { + // 普通异步回调契约要求 Unit;先释放实际返回值,再把不符合契约的回调标失败并向外报告。 + let unit = matches!(value, Value::Nil); + vm.release_value(value)?; + if !unit { + // 已释放非 Unit 返回根后再标记失败并报告,不能因契约错误泄漏任意对象返回值。 + fail_callback( + host, + vm, + reference, + "asynchronous callback must return Unit", + )?; + bail!("asynchronous callback must return Unit"); + } + finish(host, vm, reference, State::Completed) + } + Err(error) => { + // 存有界诊断并清执行资源,同时把实际错误交给 endor_host 的故障处理。 + fail_callback(host, vm, reference, &format!("{error:#}"))?; + Err(error) + } + } + })(); + if let Some(owner) = owner { + // 调度回调或协程推进可能失败;先释放本项的 owner 临时根,外层再释放 Task 根,最后才传播错误。 + vm.release(owner)?; + } + result + })(); + vm.release(reference)?; + result?; + } + // 实际推进项移到末尾,空闲 limit=1 时一个长协程不能每轮都抢在其他可执行任务前。 + if !advanced.is_empty() { + // 回调可能新建任务,所以重新取得当前索引再移动已推进项,不能拿旧 snapshot 覆盖新登记。 + let mut index = self + .index + .lock() + .map_err(|_| anyhow::anyhow!("task index poisoned"))?; + index.retain(|weak| !advanced.contains(weak)); + index.extend(advanced); + } + // 轮末移除终态/死亡任务并重算 runnable,等待外部 I/O 的任务不应导致忙轮询协程。 + self.prune(vm)?; + Ok(work) + } + /// UiBridge 取消和 Scheduler::quiesce 调用,逐项 finish 并清空弱索引,不执行用户取消回调。 + pub fn cancel_all(&self, vm: &mut Vm) -> Result { + let host = self.host.as_ref(); + // 不在锁内调用 finish;它会变更 owner 作用域,但索引不需在整个 VM 清理过程中借用。 + let snapshot = self + .index + .lock() + .map_err(|_| anyhow::anyhow!("task index poisoned"))? + .clone(); + for weak in snapshot { + if let Some(task) = vm.upgrade(weak)? { + // 升级是拥有根,先保存 finish 错误再 release,避免失败时遗留额外 Task 引用。 + let result = finish(host, vm, task, State::Cancelled); + vm.release(task)?; + result?; + } + } + // VM 清理完成后再锁索引,取原项数供诊断并一次性清表。 + let mut index = self + .index + .lock() + .map_err(|_| anyhow::anyhow!("task index poisoned"))?; + // cancel_all 返回清空前索引项数,包含升级失败的弱项,不能等同于实际执行过的回调数。 + let count = index.len(); + index.clear(); + self.runnable.store(false, Ordering::Release); + Ok(count) + } + /// poll 的轮末收尾调用,移除死亡/终态弱项并计算“是否有可运行协程”,防止等待 I/O 时忙循环。 + fn prune(&self, vm: &mut Vm) -> Result<()> { + // 本函数不执行用户函数,短暂持锁扫描弱项及查询 AwaitPoll,不需把整个 VM 堆遍历一遍。 + let mut index = self + .index + .lock() + .map_err(|_| anyhow::anyhow!("task index poisoned"))?; + // live 保留待处理状态任务,终态由源变量自己持有,不因调度索引延长寿命。 + let mut live = Vec::new(); + // 累加是否有任意协程不用等待外部事件即可推进,不把普通未来计时器视为 runnable。 + let mut runnable = false; + for weak in index.iter().copied() { + if let Some(task) = vm.upgrade(weak)? { + // 先保存 payload 查询 Result,让升级临时根在返回错误之前也能被 release。 + let pending = vm.payload::(task, "Task").map(|task| { + // 此局部 pending 是状态布尔,与外层承载查询结果的 Result 区分。 + let pending = matches!(task.state, State::Pending | State::Running); + // 可运行标记仅针对协作任务:无等待对象可立即推进,有等待对象则看其 poll_await 是否不再 Pending。 + runnable |= pending && task.cooperative && task.waiting.is_none(); + pending + }); + if pending.as_ref().is_ok_and(|pending| *pending) { + // 只对成功读出的活任务继续看 waiting,失败则留给释放后的 pending? 传播。 + let value = vm.payload::(task, "Task")?; + if value.cooperative + && let Some(waiting) = value.waiting + { + // 等待值已完成/失败/取消都可以恢复处理;只有明确 Pending 才继续休眠。 + runnable |= !matches!( + vm.object(waiting)?.payload().poll_await(), + Ok(endor_core::AwaitPoll::Pending) + ); + } + } + vm.release(task)?; + if pending? { + // 查询成功且仍为 Pending/Running 才留下弱索引;终态 token 可以继续存在,但不再占下一轮调度槽。 + live.push(weak); + } + } + } + *index = live; + self.runnable.store(runnable, Ordering::Release); + Ok(()) + } +} +/// advance_coroutine 准备保存 await 依赖前调用,沿 Task.waiting 判断自等/互等,非 Task 值由其自身 await 协议处理。 +fn cyclic_wait(vm: &Vm, source: ObjectRef, mut target: ObjectRef) -> Result { + // seen 记录目标身份,既识别回到 source,也识别原本已有的封闭依赖环。 + let mut seen = std::collections::HashSet::new(); + loop { + // 等待链到达 source 或重复已有目标都表示环;不是 Task 或没有 waiting 边时链终止,不判环。 + if target == source || !seen.insert(target) { + return Ok(true); + } + // 非本模块 Task 的 awaitable 没有可遍历 waiting 边,不能臆测其内部依赖结构。 + let Some(task) = vm.object(target)?.payload().as_any().downcast_ref::() else { + return Ok(false); + }; + // 一个尚未等待其他对象的任务是链尾,当前这次新增等待不会自行形成环。 + let Some(waiting) = task.waiting else { + return Ok(false); + }; + target = waiting; + } +} + +/// Scheduler::poll 只为 cooperative Task 调用,首次创建协程后每轮恢复 256 指令软量子,保留累计硬预算。 +fn advance_coroutine(host: &dyn TaskHost, vm: &mut Vm, reference: ObjectRef) -> Result<()> { + // 保存初始执行边用于第一次准备,运行源代码后必须重读状态,不能让旧副本覆盖自取消结果。 + let mut task = vm.payload::(reference, "Task")?.clone(); + // 首次推进把 callback 转成托管 Coroutine,后续复用同一帧与预算,不重放已发生的源副作用。 + let coroutine = if let Some(coroutine) = task.coroutine { + // 已有协程直接继续原帧,不从 callback 起点回放写属性/I/O 等副作用。 + coroutine + } else { + // 只有第一次推进才取 callback,成功保存协程后会清 callback 强边避免重复准备。 + let callback = task + .callback + .ok_or_else(|| anyhow::anyhow!("spawn callback missing"))?; + // 协程自身保存硬预算,软量子每轮刷新也不会让总指令限制重新从零计算。 + let prepared = vm + .new_coroutine( + callback, + &[], + endor_core::ExecutionLimits { + max_frames: 128, + max_instructions: 100_000, + }, + ) + .map_err(|error| crate::runtime_error(vm, error)); + // 准备可能因回调/类型/预算错误失败,统一标记任务失败并保留源诊断。 + let coroutine = match prepared { + Ok(coroutine) => coroutine, + Err(error) => { + fail_callback(host, vm, reference, &format!("{error:#}"))?; + return Err(error); + } + }; + // 准备 coroutine 期间原生代码也可能取消/替换任务,必须重读当前状态,不能把旧 task 副本覆盖回去。 + // 看真实当前 payload 的状态,而不是此函数入口保存的 task.state。 + let current = vm.payload::(reference, "Task")?.state; + if !matches!(current, State::Pending | State::Running) { + // 已失去执行资格,刚准备出的协程返回根仍需释放,不能写回 Task 复活它。 + vm.release(coroutine)?; + return Ok(()); + } + task.state = State::Running; + task.callback = None; + task.coroutine = Some(coroutine); + // 先由 payload 建立协程拥有边,再释放创建根;安装失败也尝试释放局部根。 + // 先暂存安装结果,让创建根不管写屏障成功/失败都经过下面 release。 + let installed = vm.replace_payload(reference, task); + vm.release(coroutine)?; + installed?; + coroutine + }; + // 续体结果先保存,运行函数可能主动取消/替换 Task,交付前还要核验真实状态。 + let result = vm + // 每次最多执行 256 指令软量子,达到量子时仅挂起;总 100000 指令上限仍由协程本身累计。 + .resume_coroutine(coroutine, 256) + .map_err(|error| crate::runtime_error(vm, error)); + // 源代码运行期间可取消自身,取消/替换优先于本轮完成;完成值即使不交付也必须释放其拥有根。 + let active = matches!( + vm.payload::(reference, "Task")?.state, + State::Pending | State::Running + ); + // Waiting 保存依赖,Pending 等下一软量子,Complete 保存任意返回值;三条成功路径都先尊重本片执行期间发生的取消。 + match result { + Ok(endor_core::CoroutineProgress::Waiting { awaitable, .. }) => { + if !active { + // 等待来自已取消旧执行时不再登记 Task.waiting,让取消/替换优先。 + return Ok(()); + } + // 登记等待强边前检查依赖环,拒绝永不满足的互相 await,并把当前任务转失败。 + if cyclic_wait(vm, reference, awaitable)? { + fail_callback(host, vm, reference, "cyclic task await")?; + bail!("cyclic task await"); + } + // 保存强等待边,让被等待值在协程挂起期间真实可达,而不是靠弱调度表保活。 + let mut task = vm.payload::(reference, "Task")?.clone(); + task.waiting = Some(awaitable); + vm.replace_payload(reference, task)?; + Ok(()) + } + // 软量子挂起不代表等待外部值,清 waiting 后下一轮仍视作可运行。 + Ok(endor_core::CoroutineProgress::Pending { .. }) => { + if active { + // 本片量子用尽但并未 await,清旧 waiting 让 prune 把它判为下一轮可运行。 + let mut task = vm.payload::(reference, "Task")?.clone(); + task.waiting = None; + vm.replace_payload(reference, task)?; + } + Ok(()) + } + Ok(endor_core::CoroutineProgress::Complete { value, .. }) => { + if !active { + // 完成值来自 VM 返回拥有根;即使不再交付也不能直接 drop Rust Value 而不 release。 + vm.release_value(value)?; + return Ok(()); + } + // 重新读可能被源函数更新过的字段,仅附加本次成功结果,避免入口旧副本覆盖新状态。 + let mut task = vm.payload::(reference, "Task")?.clone(); + // 结果先写入受 trace 管理的 payload,再释放 VM 返回值根,最后 finish 清执行边但保留成功结果。 + task.result = Some(value.clone()); + task.waiting = None; + // 结果对象先由 Task.trace 保活;局部返回根随后释放,即使存储失败也不跳过释放。 + let stored = vm.replace_payload(reference, task); + vm.release_value(value)?; + stored?; + finish(host, vm, reference, State::Completed) + } + Err(error) => { + if active { + // 已终态任务不再改成 Failed,保持自取消/替换结果;实际执行错误仍返回上层。 + fail_callback(host, vm, reference, &format!("{error:#}"))?; + } + Err(error) + } + } +} + +/// Scheduler::poll/advance_coroutine 的回调错误分支调用,保存有界诊断,再经 finish 统一清理执行资源。 +fn fail_callback( + host: &dyn TaskHost, + vm: &mut Vm, + reference: ObjectRef, + message: &str, +) -> Result<()> { + // 只更新 error 字段,不自行复制 Task 结果或重新分配一份故障任务对象。 + let mut task = vm.payload::(reference, "Task")?.clone(); + // 错误预览按字符限长,保证 UTF-8 完整;记录后统一走终态清理而非保留失败协程。 + task.error = Some(message.chars().take(1024).collect::().into()); + vm.replace_payload(reference, task)?; + finish(host, vm, reference, State::Failed) +} + +/// poll、cancel_all、协程收尾和 fail_callback 共用的终态转换,清执行边并只撤销仍匹配的 owner/key 拥有关系。 +fn finish(host: &dyn TaskHost, vm: &mut Vm, reference: ObjectRef, state: State) -> Result<()> { + // 先核对当前真实状态,已完成/失败/取消不再被另一个迟到的收尾覆盖。 + let mut task = vm.payload::(reference, "Task")?.clone(); + if !matches!(task.state, State::Pending | State::Running) { + return Ok(()); + } + // finish 只允许从 pending/running 转终态,重复调用不改变既有 Completed/Cancelled/Failed 的语义。 + task.state = state; + task.callback = None; + task.lease = None; + task.coroutine = None; + task.waiting = None; + if state == State::Cancelled { + // 取消不保存成功结果;Completed/Failed 的诊断/结果由保留 Task token 的源代码继续观察。 + task.text = None; + task.result = None; + } + vm.replace_payload(reference, task.clone())?; + if let Some(owner) = vm.upgrade(task.owner)? { + // owner 可能已经回收,无 owner 时无需删表;升级成功则先保留清理结果再 release。 + let result = (|| -> Result<()> { + // 只有 key 仍指向本任务才删 owner 边,避免旧任务结束时误删同 key 新任务。 + if current(host, vm.object_store(), owner, reference, &task)? + && let Some(scope) = host.scope(vm.object_store(), owner)? + { + vm.dict_delete(scope, &Value::Text(task.key))?; + } + Ok(()) + })(); + vm.release(owner)?; + result?; + } + Ok(()) +} + +/// ui_bridge::bootstrap 在 Task 类型建立后调用,注册五种创建 API 和 Task 实例方法,返回同域 Scheduler。 +pub fn install( + vm: &mut Vm, + roots: &mut Vec, + api: ObjectRef, + context: ObjectRef, + host: Arc, +) -> Result { + // 每个运行时一份弱索引、可运行/退出标记和 provider mailbox,UI API 与 Scheduler 共享这些原生状态。 + let index = Arc::new(Mutex::new(Vec::new())); + // 初始化没有可推进协程,spawn 及轮末 prune 才会更新这个唤醒提示。 + let runnable = Arc::new(AtomicBool::new(false)); + // 运行时退出单向门闩共享给所有 After callable,不能只在 Scheduler 自己保留一个无效本地副本。 + let quiescing = Arc::new(AtomicBool::new(false)); + // 所有 API 返回同一 Task 名义类型,不能为 after/sleep 各建一个不兼容 Task 类。 + let definition = host.task_type(vm.object_store(), context)?; + // 每运行时独立完成邮箱/租约额度,工作线程池由 Provider 内部全进程共用。 + let provider = crate::io_tasks::Provider::default(); + for (name, operation) in [ + ("after", Operation::Timer), + ("sleep", Operation::Sleep), + ("readText", Operation::ReadText), + ("fetchText", Operation::FetchText), + ("spawn", Operation::Spawn), + ] { + // I/O 第三参数为字符串并声明 External;其余初始模板用毫秒 Number/Mutating。 + let external = matches!(operation, Operation::ReadText | Operation::FetchText); + // After 共享索引/门闩/Provider,只有 operation 与签名不同,仍保留各源 API 独立名字。 + let function = vm.allocate(ContextNativeFunction::new( + name, + After { + operation, + provider: provider.clone(), + signature: { + // 基础四参模板为 owner、key、delay/path、callback,随后针对无回调/零延时 API 收窄。 + let mut signature = endor_core::CallSignature::exact( + vec![ + endor_core::AnnotationType::Any, + endor_core::AnnotationType::String, + if external { + // readText/fetchText 使用路径/URL,不能让 API 签名把它误认作计时延迟。 + endor_core::AnnotationType::String + } else { + // Timer/Sleep 使用整数毫秒,整数性与范围由 After::invoke 再查。 + endor_core::AnnotationType::Number + }, + endor_core::AnnotationType::Function, + ], + endor_core::AnnotationType::Nominal(definition), + if external { + // I/O 签名声明 External;与下面纯计时/协作的 Mutating 不同,二者都不能在只读渲染中提交。 + endor_core::CallEffect::External + } else { + endor_core::CallEffect::Mutating + }, + ); + // I/O 可带可选回调;spawn 去掉延时参数,sleep 去掉回调参数,保留各自正确 arity。 + if external { + // I/O 允许不传回调并直接 await 返回 Task,但 owner/key/path 三参始终必填。 + signature.arity = endor_core::CallArity::range(3, 4); + } + if operation == Operation::Spawn { + // 第三位改为源函数,去掉延时注解而非只把 required 数量改成 3。 + signature.parameters.remove(2); + signature.arity = endor_core::CallArity::exact(3); + } + if operation == Operation::Sleep { + // sleep 无回调,不能把三参 API 的注解末尾遗留成任意函数尾参。 + signature.parameters.pop(); + signature.arity = endor_core::CallArity::exact(3); + } + signature + }, + index: index.clone(), + runnable: runnable.clone(), + quiescing: quiescing.clone(), + context, + host: host.clone(), + }, + vec![context], + ))?; + roots.push(function); + vm.set_attr(api, name, Value::Object(function))?; + } + // Task 类型安装 cancel/status/active/result/error:只有 cancel 声明 Mutating,其余只读查询。 + for (name, query) in [ + ("cancel", Query::Cancel), + ("status", Query::Status), + ("active", Query::Active), + ("result", Query::Result), + ("error", Query::Error), + ] { + // 方法存在 Task 类型表上,receiver 由 VM 绑定;返回值契约按 query 区分。 + let method = vm.allocate(ContextNativeFunction::new( + name, + Method { + query, + context, + host: host.clone(), + signature: endor_core::CallSignature::exact( + vec![endor_core::AnnotationType::Nominal(definition)], + match query { + // status/error 返回文本,result 保留任意源值,cancel/active 则返回布尔。 + Query::Status | Query::Error => endor_core::AnnotationType::String, + Query::Result => endor_core::AnnotationType::Any, + _ => endor_core::AnnotationType::Bool, + }, + if matches!(query, Query::Cancel) { + // 查询和取消的效果不同,不能让 cancel 在只读布局里改变任务资格。 + endor_core::CallEffect::Mutating + } else { + endor_core::CallEffect::ReadOnly + }, + ), + }, + vec![context], + ))?; + roots.push(method); + vm.define_method(definition, name, method)?; + } + // 返回与全部 After callable 相同的共享状态,UiBridge 后续通过它轮询/退出本 VM 的任务。 + Ok(Scheduler { + index, + runnable, + quiescing, + context, + provider, + host, + }) +} diff --git a/vendor/nexus/src/vm_sequence.rs b/vendor/nexus/src/vm_sequence.rs new file mode 100644 index 0000000..5b31d98 --- /dev/null +++ b/vendor/nexus/src/vm_sequence.rs @@ -0,0 +1,249 @@ +//! 构造共享 VM 调用序列与同帧循环驱动的字节码。 +//! 用托管函数串联步骤,避免为每个布局节点反复创建独立解释器调用;重复驱动会保留同一个执行帧和预算域。 +//! +//! mount::synchronize 与 event_dispatch::dispatch 用 build 串起生命周期/事件回调。 +//! source_layout/source_paint 用 repeat_call 循环推进出现位置,并用 collect_and_continue 收集单次源调用结果。 +//! 本模块只生成驱动字节码和托管函数,不在 Rust 中自行解释语句,也不替调用方重置 VM 预算。 +//! 原生调用返回 Invoke 后,VM 在既有帧循环中执行驱动,因此可挂起工作仍有明确的 owning VM。 +//! build 串联的是普通调用序列,任一步报错便中断后续步骤;末项不是 finally,错误时临时根/检查点仍须由所属工作收尾路径释放。 +use endor_core::{ + CodeLayout, EndorCode, EndorCodeObject, Instruction, NativeContext, ObjectRef, Opcode, Value, + VmError, +}; + +/// 驱动生成后由宿主附着领域 Function 身份;回调在原分配顺序中的最后一步执行。 +pub trait FunctionHost { + /// owning VM 调用;function 是 NativeContext 临时根,不能在这里移交或重复释放。 + fn attach_function( + &self, + cx: &mut NativeContext<'_>, + function: ObjectRef, + ) -> Result<(), VmError>; + /// 字节码错误回溯的宿主来源标签,不访问磁盘或参与名称解析。 + fn source_name(&self) -> &'static str { + "" + } +} + +/// 将零参数调用列表编成一个托管驱动,按输入顺序执行,返回最后一次调用的值。 +/// 空列表返回 Nil。所有调用都在调用者的 VM 预算内运行,避免宿主逐个调用时重置预算。 +/// name 用于诊断位置;host 负责来源标签及生成函数的领域名义身份。 +/// 调用者是 Mount 生命周期同步和事件路由;返回值是驱动函数身份,不是已经执行完的最后结果。 +pub fn build( + cx: &mut NativeContext<'_>, + calls: Vec, + name: &'static str, + host: &impl FunctionHost, +) -> Result { + // 每个函数放入常量池。LoadConst/PushNull/Call 组成零参数调用, + // 中间结果由 PopTop 丢弃;最后结果留在栈顶交给 ReturnValue。 + // 每个中间调用至多四条指令,额外空间覆盖空序列和 ReturnValue;只是预留容量,不是指令预算。 + let mut instructions = Vec::with_capacity(calls.len() * 4 + 2); + // 常量池强持有每个 callable,驱动存活期间不依赖调用方的 Rust Vec 保活。 + let mut constants: Vec = calls.into_iter().map(Value::Object).collect(); + for index in 0..constants.len() { + // LoadConst 放函数,PushNull 建立 VM Call 所需前缀,Call 0 执行无显式实参的回调。 + instructions.push(Instruction::new(Opcode::LoadConst, index as u32)); + instructions.push(Instruction::simple(Opcode::PushNull)); + instructions.push(Instruction::new(Opcode::Call, 0)); + if index + 1 != constants.len() { + // 只丢中间结果,避免把最后一个结果也弹掉而让 ReturnValue 面对空栈。 + instructions.push(Instruction::simple(Opcode::PopTop)); + } + } + // 没有调用时也必须给 ReturnValue 提供合法栈顶,不能返回一个空栈。 + if constants.is_empty() { + constants.push(Value::Nil); + instructions.push(Instruction::new(Opcode::LoadConst, 0)); + } + instructions.push(Instruction::simple(Opcode::ReturnValue)); + // 编码阶段校验字节码布局,诊断位置使用宿主 name 而不是伪造用户源码行列。 + let code = EndorCode::from_instructions(&instructions, constants, CodeLayout::default())? + .with_location(name, host.source_name(), 1); + // NativeContext 暂持代码根,输出函数会通过托管边继续拥有代码与常量。 + let code = cx.allocate(EndorCodeObject::new(code))?; + // 驱动只读取常量,无需共享用户字典,空私有 globals 不污染 REPL 或主模块。 + let globals = cx.new_dict()?; + // 函数作为本次原生调用的输出被提升,其余临时拥有根由 NativeContext 退出时释放。 + let driver = cx.new_function(name, code, globals)?; + host.attach_function(cx, driver)?; + Ok(driver) +} + +/// source_layout/source_paint 安装一轮出现遍历时调用,生成固定大小的重复驱动,不按节点数展开字节码。 +/// callback 每次返回 Bool,false 退出;同帧回跳让所有出现和委托源函数共用当前 VM 的执行预算。 +pub fn repeat_call( + cx: &mut NativeContext<'_>, + callback: ObjectRef, + name: &'static str, + host: &impl FunctionHost, +) -> Result { + // 内部 Advance 回调约定返回 Bool;repeat_while 生成的是 VM 真值条件跳转,不额外验证返回值必须是 Bool。 + // 退出后显式返回 Nil,回调的继续条件不会泄露为驱动返回值。 + let mut instructions = vec![ + Instruction::new(Opcode::LoadConst, 0), + Instruction::simple(Opcode::PushNull), + Instruction::new(Opcode::Call, 0), + ]; + repeat_while(&mut instructions)?; + // 条件已由 PopJumpIfFalse 消费;退出时重新装 Nil,不能把最后条件冒充业务返回值。 + instructions.extend([ + Instruction::new(Opcode::LoadConst, 1), + Instruction::simple(Opcode::ReturnValue), + ]); + driver( + cx, + instructions, + vec![Value::Object(callback), Value::Nil], + name, + host, + ) +} + +/// source_layout/source_paint 的推进回调调用,为当前出现生成“调用源方法→collector 收结果→返回 true”的助手。 +/// 每次只捕获当前源函数/实参,不预先为全部节点建立助手帧;外层重复驱动再决定下一次出现。 +pub fn collect_and_continue( + cx: &mut NativeContext<'_>, + collector: ObjectRef, + function: ObjectRef, + arguments: Vec, + name: &'static str, + host: &impl FunctionHost, +) -> Result { + // 常量布局固定为 collector、function、各实参、true。 + // function 或 collector 失败时不会装入最终 true,外层循环也不会自动跳过失败节点;本助手不捕获或重试源错误。 + // 先把 collector 的调用前缀压栈,再执行 function,使其返回值直接成为 collector 的唯一实参。 + // count 同时确定 Call 的显式参数数和 true 常量的池位置,不能把 collector 的一参计入它。 + let count = arguments.len(); + // 先保存两个 callable,再追加业务实参;这份强边关系使源调用挂起期间输入仍可达。 + let mut constants = vec![Value::Object(collector), Value::Object(function)]; + constants.extend(arguments); + constants.push(Value::Bool(true)); + // 先压 collector 的调用前缀,再压 function 的调用前缀;内部返回值自然成为外部单一实参。 + let mut instructions = vec![ + Instruction::new(Opcode::LoadConst, 0), + Instruction::simple(Opcode::PushNull), + Instruction::new(Opcode::LoadConst, 1), + Instruction::simple(Opcode::PushNull), + ]; + for index in 0..count { + // 参数常量从 2 开始,0/1 已被 collector/function 占用,保持源方法原始实参顺序。 + instructions.push(Instruction::new(Opcode::LoadConst, index as u32 + 2)); + } + // 收集器返回值不参与外层调度;丢弃后返回 true,通知重复驱动继续取下一项。 + instructions.extend([ + Instruction::new(Opcode::Call, count as u32), + Instruction::new(Opcode::Call, 1), + Instruction::simple(Opcode::PopTop), + Instruction::new(Opcode::LoadConst, count as u32 + 2), + Instruction::simple(Opcode::ReturnValue), + ]); + driver(cx, instructions, constants, name, host) +} + +/// repeat_call/collect_and_continue 的共同分配助手,把已组装指令与常量变成有宿主 Function 类型的 callable。 +fn driver( + cx: &mut NativeContext<'_>, + instructions: Vec, + constants: Vec, + name: &'static str, + host: &impl FunctionHost, +) -> Result { + // 编码常量池与指令后带上宿主诊断位置;字节码有效性由 Aster 的代码构造接口检查。 + let code = EndorCode::from_instructions(&instructions, constants, CodeLayout::default())? + .with_location(name, host.source_name(), 1); + // NativeContext 跟踪临时代码根;函数的 trace 边持有代码,不能只靠 Rust ObjectRef 数值保活。 + let code = cx.allocate(EndorCodeObject::new(code))?; + // 生成驱动不查用户名字,私有 globals 隔离它的空命名环境。 + let globals = cx.new_dict()?; + // 返回函数根由原生输出机制提升,代码和 globals 的临时根在域结束后可安全清理。 + let function = cx.new_function(name, code, globals)?; + host.attach_function(cx, function)?; + Ok(function) +} + +/// repeat_call 和本模块测试调用,在现有指令尾部追加消费 Bool 条件的分支与回跳。 +/// true 回到本驱动偏移零,false 跳过回跳指令;不新建调用帧,因此不会用递归栈模拟循环。 +pub fn repeat_while(instructions: &mut Vec) -> Result<(), VmError> { + // 跳转单位是编码后的双字节 code unit,不是 Instruction 数量。 + // 大操作数会生成 EXTENDED_ARG,因此必须编码后计算实际长度。 + let body = Instruction::encode_all(instructions)?.len() / 2; + // 先用最短零操作数估计回跳宽度,下面迭代直到最终操作数与编码宽度自洽。 + let mut back = Instruction::new(Opcode::JumpBackward, 0); + // 回跳距离包含自身宽度;而距离变大又可能扩大自身编码宽度。 + // 迭代到宽度/距离一致后,false 跳过回跳指令,true 回到整个驱动的起点。 + loop { + // units 是当前回跳指令实际占用的 code unit,可能因 EXTENDED_ARG 大于一。 + let units = Instruction::encode_all(&[back])?.len() / 2; + // 距离覆盖原 body、一个条件分支和回跳自身;目标为开头,不是仅回到上一个 Call。 + let distance = u32::try_from(body + 1 + units) + .map_err(|_| VmError::ExecutionLimit("layout bytecode"))?; + if back.argument == distance { + // 已收敛时 false 跳过 units 个单元,true 落到 JumpBackward 回到开头。 + instructions.push(Instruction::new(Opcode::PopJumpIfFalse, units as u32)); + instructions.push(back); + return Ok(()); + } + // 更新操作数后再次编码量宽度;不能只计算一次,跨 255 等边界可能新增 EXTENDED_ARG。 + back.argument = distance; + } +} + +#[cfg(test)] +mod tests { + use super::*; + use endor_core::{ExecutionLimits, Vm}; + #[test] + /// Rust 测试框架调用,构造大于单字节跳距的循环,分别验证退出、指令预算及无泄漏清理。 + fn repeated_bytecode_handles_extended_operands_and_keeps_one_frame() { + // 300 个 Nop 强制跨越单字节跳转距离:false 应正常退出;true 应耗尽指令预算, + // 而非耗尽帧预算,从而验证循环确实复用同一个执行帧。 + for condition in [false, true] { + // Nop 扩大 body 编码长度,与实际布局节点数量无关,直接覆盖回跳扩展操作数的边界。 + let mut instructions = vec![Instruction::simple(Opcode::Nop); 300]; + instructions.push(Instruction::new(Opcode::LoadConst, 0)); + repeat_while(&mut instructions).unwrap(); + instructions.extend([ + Instruction::new(Opcode::LoadConst, 1), + Instruction::simple(Opcode::ReturnValue), + ]); + // 条件从常量池读取,false 分支跳过回跳后装入 Nil 并正常返回。 + let code = EndorCode::from_instructions( + &instructions, + vec![Value::Bool(condition), Value::Nil], + CodeLayout::default(), + ) + .unwrap(); + // 每种条件独立 VM,统计回收时不受另一轮遗留对象影响。 + let mut vm = Vm::new().unwrap(); + // 将纯代码值注册到 VM,执行结束后显式释放此拥有根。 + let code = vm.new_code(code).unwrap(); + // 空全局字典满足执行接口,不引入额外用户对象。 + let globals = vm.new_dict().unwrap(); + // 故意只允许一帧:如果实现递归重复而非同帧跳转,会得到错误的帧数耗尽。 + let result = vm.execute_with_limits( + code, + globals, + ExecutionLimits { + max_frames: 1, + max_instructions: 1000, + }, + ); + if condition { + // true 永不自然退出,应耗尽 instructions 而非 frames,证明循环复用了同一帧。 + assert!(matches!( + result, + Err(VmError::ExecutionLimit("instructions")) + )); + } else { + // false 只走一次 body 然后返回 Nil,证明分支跳过长度包含完整扩展回跳指令。 + assert_eq!(result.unwrap(), Value::Nil); + } + vm.release(code).unwrap(); + vm.release(globals).unwrap(); + // 释放代码与全局字典后执行循环回收,确认生成的常量/函数没有遗留托管对象。 + vm.collect_cycles(); + assert_eq!(vm.object_count(), 0); + } + } +} diff --git a/vendor/nexus/tests/console.rs b/vendor/nexus/tests/console.rs new file mode 100644 index 0000000..926d432 --- /dev/null +++ b/vendor/nexus/tests/console.rs @@ -0,0 +1,128 @@ +//! 无 UI 的持久输入回归,覆盖实际全局身份、准备阶段无副作用、失败边界和返回对象拥有关系。 +//! 测试通过真实 VM 和借用/拥有根观察结果,不依赖 GUI 或历史回放。 +use endor_core::Value; +use endorphin_nexus_runtime::{VmSession, budget::MAX_AST_NODES}; +use frontend::EndorReader; + +/// 新建只有真实全局字典的运行时,不安装任何 GUI 能力或重放历史输入。 +fn session() -> VmSession { + let mut runtime = VmSession::new().unwrap(); + runtime.create_globals().unwrap(); + runtime +} + +/// 独立来源标记用于检查运行错误仍指向当前输入,而非累计浏览 transcript。 +fn execute(runtime: &mut VmSession, name: &str, text: &str) -> String { + let input = runtime + .prepare_input(EndorReader::from_text(name, text), 0) + .unwrap(); + runtime.execute_input(input).unwrap() +} + +/// 读取借用字典值,只用于观察;不会给对象额外建立拥有根。 +fn global(runtime: &VmSession, name: &str) -> Option { + runtime + .vm() + .dict_get(runtime.globals().unwrap(), &Value::Text(name.into())) + .unwrap() +} + +#[test] +/// 新输入使用原全局字典;准备成功也不执行,代码模板释放后函数仍可从全局被调用。 +fn persistent_inputs_preserve_bindings_and_function_identity() { + let mut runtime = session(); + let input = runtime + .prepare_input(EndorReader::from_text("first", "counter = 1"), 0) + .unwrap(); + assert!(input.ast_nodes() > 0); + assert_eq!(input.source().text(), "counter = 1"); + assert_eq!(input.plan().roots().len(), 1); + assert_eq!(global(&runtime, "counter"), None); + assert_eq!(runtime.execute_input(input).unwrap(), "1"); + assert_eq!( + execute(&mut runtime, "second", "counter = counter + 1"), + "2" + ); + assert_eq!( + global(&runtime, "counter"), + Some(Value::Number(2_i64.into())) + ); + execute( + &mut runtime, + "definition", + "function identity(value: Number): Number { return value }", + ); + // 表达式结果是函数对象;_ 必须建立真实强边,不能只保留 repr 或 Rust 句柄。 + let display = execute(&mut runtime, "function value", "identity"); + assert!(!display.is_empty()); + assert_eq!(global(&runtime, "_"), global(&runtime, "identity")); + assert_eq!(execute(&mut runtime, "call", "identity(counter)"), "2"); + runtime.close().unwrap(); + assert_eq!(runtime.vm().object_count(), 0); +} + +#[test] +/// 全部片段编译成功前不执行;执行期失败保留前段写入,错误仍携带独立输入来源。 +fn compile_failure_is_preflight_but_runtime_failure_keeps_prior_writes() { + let mut runtime = session(); + execute(&mut runtime, "initial", "counter = 1"); + assert!( + runtime + .prepare_input( + EndorReader::from_text("compile failure", "counter = 8\nnotDeclared"), + 0 + ) + .is_err() + ); + assert_eq!( + global(&runtime, "counter"), + Some(Value::Number(1_i64.into())) + ); + let input = runtime + .prepare_input( + EndorReader::from_text("headless execution failure", "counter = 9\n1 / 0"), + 0, + ) + .unwrap(); + let error = runtime.execute_input(input).unwrap_err().to_string(); + assert!(error.contains("division by zero")); + assert!(error.contains("headless execution failure")); + assert_eq!( + global(&runtime, "counter"), + Some(Value::Number(9_i64.into())) + ); + // 失败输入并未导致历史重放,后续输入继续操作同一当前全局值。 + assert_eq!(execute(&mut runtime, "after failure", "counter + 1"), "10"); + runtime.close().unwrap(); + assert_eq!(runtime.vm().object_count(), 0); +} + +#[test] +/// 累计节点和输入字节预算在准备阶段失败,既不更新 _ 也不写业务变量。 +fn source_and_cumulative_ast_limits_do_not_execute_partial_inputs() { + let mut runtime = session(); + execute(&mut runtime, "initial", "counter = 3"); + for used in [MAX_AST_NODES, usize::MAX] { + assert!( + runtime + .prepare_input( + EndorReader::from_text("over AST budget", "counter = 8"), + used + ) + .is_err() + ); + } + let large = " ".repeat(endorphin_nexus_runtime::MAX_SOURCE_BYTES + 1); + let error = runtime + .prepare_input(EndorReader::from_text("over source budget", large), 0) + .err() + .unwrap(); + assert!(error.to_string().contains("input exceeds 1 MiB")); + assert_eq!( + global(&runtime, "counter"), + Some(Value::Number(3_i64.into())) + ); + assert_eq!(global(&runtime, "_"), Some(Value::Number(3_i64.into()))); + runtime.close().unwrap(); + assert_eq!(runtime.vm().object_count(), 0); +} diff --git a/vendor/nexus/tests/history.rs b/vendor/nexus/tests/history.rs new file mode 100644 index 0000000..0a982d0 --- /dev/null +++ b/vendor/nexus/tests/history.rs @@ -0,0 +1,117 @@ +//! Console 历史与累计预算的无 UI 契约回归;需在获授权构建环境编译执行。 +use endor_core::Value; +use endorphin_nexus_runtime::{ + MAX_SOURCE_BYTES, VmSession, budget::MAX_AST_NODES, console::ConsoleHistory, + program::PreparedProgram, +}; +use frontend::EndorReader; + +/// 创建真实环境但不安装 UI;历史本身没有管理对象或回放职责。 +fn session() -> VmSession { + let mut runtime = VmSession::new().unwrap(); + runtime.create_globals().unwrap(); + runtime +} + +#[test] +/// 解析/编译失败不接受输入;运行错误发生在接受之后,历史和前段写入都保留。 +fn only_accepted_inputs_enter_history_and_execution_errors_remain_recorded() { + let mut runtime = session(); + let mut history = ConsoleHistory::default(); + assert!( + history + .prepare(&runtime, 7, "value = 1\nunknownName") + .is_err() + ); + assert_eq!(history.inputs(), 0); + assert_eq!(history.ast_nodes(), 0); + assert_eq!(history.source(), ""); + let input = history.prepare(&runtime, 7, "value = 9\n1 / 0").unwrap(); + assert_eq!( + format!("{}", input.source().origin()), + "console session 7 input 1" + ); + let cost = input.ast_nodes(); + let accepted = history.accept(input).unwrap(); + assert_eq!(accepted.number(), 1); + assert_eq!(accepted.line_offset(), 1); + assert!(accepted.execute(&mut runtime).is_err()); + assert_eq!(history.inputs(), 1); + assert_eq!(history.ast_nodes(), cost); + assert_eq!(history.source(), "// Console input 1\nvalue = 9\n1 / 0\n"); + assert_eq!( + runtime + .vm() + .dict_get(runtime.globals().unwrap(), &Value::Text("value".into())) + .unwrap(), + Some(Value::Number(9_i64.into())) + ); + runtime.close().unwrap(); +} + +#[test] +/// 输入次数与 AST 总量分别限制,失败准备不增加计数或追加分隔注释。 +fn input_count_and_cumulative_ast_budgets_are_shared_by_headless_hosts() { + let mut runtime = session(); + let mut history = ConsoleHistory::default(); + // 简单表达式不触发 AST/字节上限,因此第 257 次明确检验次数门槛。 + for number in 1..=256 { + let input = history.prepare(&runtime, 1, "1").unwrap(); + let accepted = history.accept(input).unwrap(); + assert_eq!(accepted.number(), number); + } + let before = history.source().to_owned(); + assert!(history.prepare(&runtime, 1, "1").is_err()); + assert_eq!(history.inputs(), 256); + assert_eq!(history.source(), before); + // 每个输入有多个浅层语句,避开单输入深度限制,实际检验跨输入累计结构量。 + let mut history = ConsoleHistory::default(); + let text = "value = 1\n".repeat(50); + let cost = history.prepare(&runtime, 2, &text).unwrap().ast_nodes(); + let allowed = MAX_AST_NODES / cost; + assert!(allowed < 256); + for _ in 0..allowed { + let input = history.prepare(&runtime, 2, &text).unwrap(); + history.accept(input).unwrap(); + } + let before = history.source().to_owned(); + let error = history.prepare(&runtime, 2, &text).err().unwrap(); + assert!(error.to_string().contains("10000 AST nodes")); + assert_eq!(history.inputs(), allowed); + assert_eq!(history.ast_nodes(), cost * allowed); + assert_eq!(history.source(), before); + runtime.close().unwrap(); +} + +#[test] +/// 完整源码、Unicode 与 CRLF/CR 原文保持;输入偏移按共享字节行首规则计算,累计字节预算含程序文本。 +fn program_history_preserves_source_and_enforces_the_combined_byte_budget() { + let mut runtime = session(); + let raw = "base = 1\r\nlabel = \"中\"\r"; + let program = + PreparedProgram::compile(EndorReader::from_text("program", raw), Default::default()) + .unwrap(); + let mut history = ConsoleHistory::from_program(&program); + assert_eq!(history.inputs(), 0); + assert_eq!(history.ast_nodes(), program.ast_nodes()); + assert_eq!(history.source(), raw); + let input = history.prepare(&runtime, 8, "\"新\"\r\n").unwrap(); + let accepted = history.accept(input).unwrap(); + assert_eq!(accepted.line_offset(), 3); + assert_eq!( + history.source(), + format!("{raw}\n// Console input 1\n\"新\"\r\n") + ); + assert_eq!(accepted.execute(&mut runtime).unwrap(), "\"新\""); + // 近上限的有效程序只包含长注释和一个表达式;新输入要计算既有文本和固定分隔余量。 + let raw = format!("//{}\n1", "x".repeat(MAX_SOURCE_BYTES - 20)); + let program = PreparedProgram::compile( + EndorReader::from_text("large program", raw), + Default::default(), + ) + .unwrap(); + let history = ConsoleHistory::from_program(&program); + assert!(history.prepare(&runtime, 9, "1").is_err()); + assert_eq!(history.inputs(), 0); + runtime.close().unwrap(); +} diff --git a/vendor/nexus/tests/host_registration.rs b/vendor/nexus/tests/host_registration.rs new file mode 100644 index 0000000..7696a50 --- /dev/null +++ b/vendor/nexus/tests/host_registration.rs @@ -0,0 +1,170 @@ +//! 不依赖 Tessera 的 Nexus 宿主契约回归;需在获授权的构建环境编译/执行。 +//! 验证宿主注册、半完成安装清理、脚本跨片名称和原文位置,而不是复制私有实现断言。 +use anyhow::{Result, bail}; +use endor_core::{ObjectPayload, ObjectRef, Value, Vm}; +use endorphin_nexus_runtime as nexus; +use frontend::{ + EndorReader, + ast::{Spanned, visitor::Visitor}, +}; +use nexus::{HostRegistration, VmSession, budget::AstBudget, program::compile_plan}; +use std::{ + any::Any, + sync::{ + Arc, + atomic::{AtomicUsize, Ordering}, + }, +}; + +#[derive(Debug)] +/// 由假宿主分配的资源,析构计数在 VM 外可观察,不携带 UI 类型或托管出边。 +struct Capability(Arc); +impl Drop for Capability { + /// 最后强边移除时真正释放资源;根归还与 Rust 句柄复制不应增加此计数。 + fn drop(&mut self) { + self.0.fetch_add(1, Ordering::SeqCst); + } +} +impl ObjectPayload for Capability { + /// Aster 载荷下转型入口,独立于宿主的名义类型注册。 + fn as_any(&self) -> &dyn Any { + self + } + /// 为错误/诊断提供类别,不让测试依赖 Tessera 的类型名。 + fn kind_name(&self) -> &'static str { + "test-capability" + } +} + +/// 只依赖 Nexus/Aster 的假宿主;可在分配并登记根后故意失败,观察安装失败的收尾。 +struct Host { + drops: Arc, + fail: bool, +} +impl HostRegistration for Host { + type Installed = ObjectRef; + /// Nexus 调用注册接口,宿主向实际 globals 安装能力,返回借用身份供测试检查。 + fn register( + &self, + vm: &mut Vm, + roots: &mut Vec, + globals: ObjectRef, + ) -> Result { + // 先登记拥有根,后续字典安装或故意失败都不能丢掉清理责任。 + let capability = vm.allocate(Capability(self.drops.clone()))?; + roots.push(capability); + // 错误发生在能力根创建之后,检验会话能清理半完成注册。 + if self.fail { + bail!("host registration failed"); + } + vm.dict_set( + globals, + Value::Text("capability".into()), + Value::Object(capability), + )?; + Ok(capability) + } +} + +#[test] +/// 宿主通过接口注册后,全局真实持有同一能力;close 释放根和字典边,重复 close 无副作用。 +fn host_registration_uses_the_owned_vm_and_cleans_its_resources() { + // 计数器不在 VM 内,资源销毁后仍可用于观察。 + let drops = Arc::new(AtomicUsize::new(0)); + // 空会话不暗中安装 ui 或任何宿主对象。 + let mut runtime = VmSession::new().unwrap(); + assert_eq!(runtime.vm().object_count(), 0); + // 主环境拥有根由 Nexus 会话登记,宿主只收到借用句柄。 + let globals = runtime.create_globals().unwrap(); + // Installed 身份借用会话根,不能再把它当成独立拥有结果释放。 + let capability = runtime + .register_host(&Host { + drops: drops.clone(), + fail: false, + }) + .unwrap(); + assert_eq!( + runtime + .vm() + .dict_get(globals, &Value::Text("capability".into())) + .unwrap(), + Some(Value::Object(capability)) + ); + assert_eq!(runtime.vm().ref_count(capability).unwrap(), 2); + runtime.close().unwrap(); + runtime.close().unwrap(); + assert_eq!(runtime.vm().object_count(), 0); + assert_eq!(drops.load(Ordering::SeqCst), 1); +} + +#[test] +/// 缺环境时不进入宿主;重复环境初始化不分配;宿主部分失败留下的根仍由会话 close 清理。 +fn failed_registration_and_repeated_initialization_preserve_cleanup() { + // 假宿主每次实际分配一个可计数资源。 + let drops = Arc::new(AtomicUsize::new(0)); + // 没有 globals 的会话应在调用宿主之前拒绝注册。 + let mut runtime = VmSession::new().unwrap(); + assert!( + runtime + .register_host(&Host { + drops: drops.clone(), + fail: false + }) + .is_err() + ); + assert_eq!(runtime.vm().object_count(), 0); + runtime.create_globals().unwrap(); + assert!(runtime.create_globals().is_err()); + assert_eq!(runtime.vm().object_count(), 1); + assert!( + runtime + .register_host(&Host { + drops: drops.clone(), + fail: true + }) + .is_err() + ); + runtime.close().unwrap(); + assert_eq!(runtime.vm().object_count(), 0); + assert_eq!(drops.load(Ordering::SeqCst), 1); +} + +#[test] +/// 脚本根保留原文跨度并按源序编译,后段读取前段建立的真实全局,不需要 UI 注册。 +fn script_compilation_preserves_spans_and_shared_globals_without_ui() { + // 两个顶层交互片段,第二片段依赖前面的赋值名称。 + let source = EndorReader::from_text("headless", "value = 2\nvalue + 3"); + // Nexus 组织输入,词法/语法与 AST 节点继续由 Aster 提供。 + let plan = nexus::source::parse(&source).unwrap(); + assert_eq!(plan.roots().len(), 2); + assert!(plan.roots()[1].span().start >= "value = 2\n".len()); + // 所有片段共享预算访问器,退出子树不重置累计节点数。 + let mut budget = AstBudget::default(); + for root in plan.roots() { + budget.visit_ast_root(root).unwrap(); + } + assert!(budget.nodes() > 0); + // 空宿主名称集仍允许后续片段引用前段赋值,实际值由 VM 执行建立。 + let templates = compile_plan(&source, &plan, Default::default()).unwrap(); + // 一份 owning VM 和 globals 贯穿各片段,执行后归还每次返回的根。 + let mut runtime = VmSession::new().unwrap(); + let globals = runtime.create_globals().unwrap(); + for (index, template) in templates.iter().enumerate() { + // 加载的代码根交给运行时清理,既不跨 VM 复用也不留下测试外根。 + let code = template.load(runtime.vm_mut()).unwrap(); + runtime.keep_root(code); + // 第一段赋值为 Nil,第二段求值应得到精确整数五。 + let value = runtime + .vm_mut() + .execute_with_limits(code, globals, nexus::DEFAULT_LIMITS) + .unwrap(); + if index == 1 { + assert_eq!(value, Value::Number(5_i64.into())); + } + runtime.vm_mut().release_value(value).unwrap(); + } + runtime.close().unwrap(); + assert_eq!(runtime.vm().object_count(), 0); + assert!(nexus::evaluate("ui").is_err()); + assert_eq!(nexus::evaluate("0.1 + 0.2 == 0.3").unwrap(), "true"); +} diff --git a/vendor/nexus/tests/program.rs b/vendor/nexus/tests/program.rs new file mode 100644 index 0000000..fc11ff2 --- /dev/null +++ b/vendor/nexus/tests/program.rs @@ -0,0 +1,193 @@ +//! 完整程序装载与宿主返回值处理的无 UI 回归;需在获授权环境编译、执行。 +//! 使用可观察原生回调/析构检查入口策略和拥有根,避免依赖 Tessera 的页面实现。 +use anyhow::{Result, bail}; +use endor_core::{ + CallArity, ContextNativeFunction, NativeCallable, NativeContext, NativeResult, ObjectPayload, + ObjectRef, Value, VmError, +}; +use endorphin_nexus_runtime::{ + DEFAULT_LIMITS, VmSession, + program::{CodeRetention, PreparedProgram}, +}; +use frontend::EndorReader; +use std::{ + any::Any, + sync::{ + Arc, + atomic::{AtomicUsize, Ordering}, + }, +}; + +#[derive(Debug)] +/// main 显式调用才递增,装载定义或检查源码不应触发该宿主能力。 +struct Mark(Arc); +impl NativeCallable for Mark { + /// 宿主能力使用确定零参契约。 + fn arity(&self) -> Option { + Some(CallArity::exact(0)) + } + /// 返回纯数值给源 main,计数留在 VM 外观察。 + fn invoke( + &self, + _cx: &mut NativeContext<'_>, + _args: &[Value], + ) -> Result { + self.0.fetch_add(1, Ordering::SeqCst); + Ok(NativeResult::Return(Value::Number(7_i64.into()))) + } +} + +/// 解码读取的借用对象身份,不建立或释放根。 +fn object(value: Value) -> ObjectRef { + let Value::Object(value) = value else { + panic!("expected object") + }; + value +} + +#[test] +/// 两种代码根策略都只执行模块定义;main 何时调用由宿主决定,装载的函数在代码根释放后仍有效。 +fn module_loading_preserves_function_identity_without_calling_main() { + let program = PreparedProgram::compile( + EndorReader::from_text( + "headless module", + "function main(): Number { return mark() }", + ), + ["mark".to_owned()].into_iter().collect(), + ) + .unwrap(); + assert!(program.ast_nodes() > 0); + for retention in [CodeRetention::Execution, CodeRetention::Session] { + let calls = Arc::new(AtomicUsize::new(0)); + let mut runtime = VmSession::new().unwrap(); + let globals = runtime.create_globals().unwrap(); + let mark = runtime + .vm_mut() + .allocate(ContextNativeFunction::new( + "mark", + Mark(calls.clone()), + vec![], + )) + .unwrap(); + runtime.keep_root(mark); + runtime + .vm_mut() + .dict_set(globals, Value::Text("mark".into()), Value::Object(mark)) + .unwrap(); + runtime.execute_program(&program, retention).unwrap(); + assert_eq!(calls.load(Ordering::SeqCst), 0); + let main = object( + runtime + .vm() + .dict_get(globals, &Value::Text("main".into())) + .unwrap() + .unwrap(), + ); + let value = runtime + .with_call_result(main, &[], DEFAULT_LIMITS, |_vm, value| { + Ok(value.clone()) // 此处返回标量,不把借用的托管对象带出。 + }) + .unwrap(); + assert_eq!(value, Value::Number(7_i64.into())); + assert_eq!(calls.load(Ordering::SeqCst), 1); + runtime.close().unwrap(); + assert_eq!(runtime.vm().object_count(), 0); + } +} + +#[test] +/// 脚本中途出错不回滚前段写入,两种代码根清理路径都必须能关闭至空堆。 +fn script_failure_keeps_completed_writes_and_releases_both_code_policies() { + let program = PreparedProgram::compile( + EndorReader::from_text( + "headless program failure", + "total = 1\ntotal = total + 1\n1 / 0", + ), + Default::default(), + ) + .unwrap(); + for retention in [CodeRetention::Execution, CodeRetention::Session] { + let mut runtime = VmSession::new().unwrap(); + let globals = runtime.create_globals().unwrap(); + let error = runtime + .execute_program(&program, retention) + .unwrap_err() + .to_string(); + assert!(error.contains("headless program failure")); + assert_eq!( + runtime + .vm() + .dict_get(globals, &Value::Text("total".into())) + .unwrap(), + Some(Value::Number(2_i64.into())) + ); + runtime.close().unwrap(); + assert_eq!(runtime.vm().object_count(), 0); + } +} + +#[derive(Debug)] +/// 每个真正返回的新对象拥有独立析构事件,验证宿主处理失败后的根也被归还。 +struct Returned(Arc); +impl ObjectPayload for Returned { + /// 支持 Aster 载荷识别,不引入额外托管出边。 + fn as_any(&self) -> &dyn Any { + self + } + /// 测试诊断类别,与 UI 名义类型无关。 + fn kind_name(&self) -> &'static str { + "returned-test-object" + } +} +impl Drop for Returned { + /// 真实拥有根归零时计数;仅 drop Rust Value 不会触发此回调。 + fn drop(&mut self) { + self.0.fetch_add(1, Ordering::SeqCst); + } +} +#[derive(Debug)] +/// 模拟 main 返回新对象,返回前没有其他拥有边。 +struct Allocate(Arc); +impl NativeCallable for Allocate { + /// 与宿主调用的空实参数量一致。 + fn arity(&self) -> Option { + Some(CallArity::exact(0)) + } + /// NativeContext 把分配根提升为返回根,Nexus 的处理接口负责后续归还。 + fn invoke(&self, cx: &mut NativeContext<'_>, _args: &[Value]) -> Result { + let result = cx.allocate(Returned(self.0.clone()))?; + Ok(NativeResult::Return(Value::Object(result))) + } +} + +#[test] +/// 成功/错误宿主处理都可在返回对象存活期间访问它,处理结束后立即释放唯一返回根。 +fn host_result_errors_release_the_returned_object() { + let drops = Arc::new(AtomicUsize::new(0)); + let mut runtime = VmSession::new().unwrap(); + let callee = runtime + .vm_mut() + .allocate(ContextNativeFunction::new( + "allocate", + Allocate(drops.clone()), + vec![], + )) + .unwrap(); + runtime.keep_root(callee); + let baseline = runtime.vm().object_count(); + for fail in [false, true] { + let result: Result<()> = + runtime.with_call_result(callee, &[], DEFAULT_LIMITS, |vm, value| { + assert!(vm.object(object(value.clone())).is_ok()); + if fail { + bail!("host presentation failed"); + } + Ok(()) + }); + assert_eq!(result.is_err(), fail); + assert_eq!(runtime.vm().object_count(), baseline); + } + assert_eq!(drops.load(Ordering::SeqCst), 2); + runtime.close().unwrap(); + assert_eq!(runtime.vm().object_count(), 0); +} diff --git a/vendor/nexus/tests/tasks.rs b/vendor/nexus/tests/tasks.rs new file mode 100644 index 0000000..c030eed --- /dev/null +++ b/vendor/nexus/tests/tasks.rs @@ -0,0 +1,243 @@ +//! 无 UI 的任务宿主回归:同键替换、资格变化和退出门闩必须由真实 VM/API 路径体现。 +//! 测试不启动 GUI、文件读取或网络请求,宿主资格由普通对象属性提供。 +use endor_core::{ + CallArity, ContextNativeFunction, NativeCallable, NativeContext, NativeResult, ObjectRef, + ObjectStore, TypeConstructor, Value, Vm, VmError, +}; +use endorphin_nexus_runtime::{ + VmSession, + tasks::{self, Scheduler, TaskHost}, +}; +use std::sync::{ + Arc, + atomic::{AtomicUsize, Ordering}, +}; + +#[derive(Debug)] +/// 普通对象宿主只用属性保存作用域和资格,不知道 Block、Mount、Window 或 desktop。 +struct PlainHost; +impl TaskHost for PlainHost { + /// 未提交过任务时返回 None;已有作用域必须是字典。 + fn scope(&self, store: &ObjectStore, owner: ObjectRef) -> Result, VmError> { + match store.get_attr(owner, "taskScope") { + Ok(Value::Object(scope)) => { + store.dict_items(scope)?; + Ok(Some(scope)) + } + Err(VmError::AttributeNotFound(_)) => Ok(None), + Ok(_) => Err(VmError::InvalidArgument("invalid test scope")), + Err(error) => Err(error), + } + } + /// 由写屏障建立真实拥有边,测试结束时可交给 VM 正常回收。 + fn install_scope( + &self, + cx: &mut NativeContext<'_>, + owner: ObjectRef, + scope: ObjectRef, + ) -> Result<(), VmError> { + cx.set_attr(owner, "taskScope", Value::Object(scope)) + } + /// 外部修改普通布尔字段即可撤销交付资格,不借用 Tessera 的任何模型。 + fn eligible( + &self, + store: &ObjectStore, + owner: ObjectRef, + _context: ObjectRef, + ) -> Result { + Ok(store.get_attr(owner, "eligible")? == Value::Bool(true)) + } + /// 所有任务共享宿主注册的精确类型身份。 + fn task_type(&self, store: &ObjectStore, context: ObjectRef) -> Result { + object(store.get_attr(context, "Task")?) + } +} + +#[derive(Debug)] +/// VM 外的计数器观察真正回调次数,零参/Unit 契约与 after 要求一致。 +struct Count(Arc); +impl NativeCallable for Count { + /// 明确接受零个参数,不能依赖旧原生函数缺少元数据的兼容路径。 + fn arity(&self) -> Option { + Some(CallArity::exact(0)) + } + /// 每次真正执行递增一次,取消和状态查询不得触发它。 + fn invoke( + &self, + _cx: &mut NativeContext<'_>, + _args: &[Value], + ) -> Result { + self.0.fetch_add(1, Ordering::SeqCst); + Ok(NativeResult::Return(Value::Nil)) + } +} + +/// 解码借用或拥有的对象值;此函数不改变根计数,调用方按来源管理拥有权。 +fn object(value: Value) -> Result { + match value { + Value::Object(value) => Ok(value), + _ => Err(VmError::InvalidArgument("expected test object")), + } +} + +/// 所有创建根交给 VmSession;api/context/owner 是会话根的借用身份。 +fn setup() -> ( + VmSession, + Scheduler, + ObjectRef, + ObjectRef, + ObjectRef, + Arc, +) { + let mut runtime = VmSession::new().unwrap(); + let types = runtime.vm_mut().bootstrap_types().unwrap(); + runtime.keep_root(types.object); + runtime.keep_root(types.type_type); + let definition = runtime + .vm_mut() + .new_type("Task", types.object, TypeConstructor::Abstract) + .unwrap(); + runtime.keep_root(definition); + let context = runtime.vm_mut().new_object().unwrap(); + runtime.keep_root(context); + runtime + .vm_mut() + .set_attr(context, "Task", Value::Object(definition)) + .unwrap(); + let api = runtime.vm_mut().new_object().unwrap(); + runtime.keep_root(api); + let owner = runtime.vm_mut().new_object().unwrap(); + runtime.keep_root(owner); + runtime + .vm_mut() + .set_attr(owner, "eligible", Value::Bool(true)) + .unwrap(); + let calls = Arc::new(AtomicUsize::new(0)); + let callback = runtime + .vm_mut() + .allocate(ContextNativeFunction::new( + "count", + Count(calls.clone()), + vec![], + )) + .unwrap(); + runtime.keep_root(callback); + let scheduler = runtime + .with_host(|vm, roots| tasks::install(vm, roots, api, context, Arc::new(PlainHost))) + .unwrap(); + (runtime, scheduler, api, owner, callback, calls) +} + +/// 通过安装的公开 API 创建零延时任务;返回根交给会话,避免旧 token 因替换而提前回收。 +fn after( + runtime: &mut VmSession, + api: ObjectRef, + owner: ObjectRef, + callback: ObjectRef, + key: &str, +) -> ObjectRef { + let function = object(runtime.vm().get_attr(api, "after").unwrap()).unwrap(); + let task = object( + runtime + .vm_mut() + .call( + function, + &[ + Value::Object(owner), + Value::Text(key.into()), + Value::Number(0_i64.into()), + Value::Object(callback), + ], + ) + .unwrap(), + ) + .unwrap(); + runtime.keep_root(task); + task +} + +/// 经真实类型方法绑定读取状态,不直接检查 Nexus 的私有 Task 载荷。 +fn query(vm: &mut Vm, task: ObjectRef, name: &str) -> Value { + let bound = object(vm.bind_attr(task, name).unwrap()).unwrap(); + let result = vm.call(bound, &[]); + vm.release(bound).unwrap(); + result.unwrap() +} + +#[test] +/// 替换旧 token 后只有新任务执行一次;终态 token 可继续查询,拥有字典已经清空。 +fn same_key_replacement_only_delivers_the_new_identity() { + let (mut runtime, scheduler, api, owner, callback, calls) = setup(); + let old = after(&mut runtime, api, owner, callback, "same"); + let new = after(&mut runtime, api, owner, callback, "same"); + assert_eq!( + query(runtime.vm_mut(), old, "status"), + Value::Text("cancelled".into()) + ); + // 取消被替换的旧 token 不得删除新任务的 owner/key 身份。 + assert_eq!(query(runtime.vm_mut(), old, "cancel"), Value::Bool(false)); + assert_eq!(query(runtime.vm_mut(), new, "active"), Value::Bool(true)); + assert_eq!(scheduler.poll(runtime.vm_mut(), 64).unwrap(), 1); + assert_eq!(calls.load(Ordering::SeqCst), 1); + assert_eq!( + query(runtime.vm_mut(), new, "status"), + Value::Text("completed".into()) + ); + assert_eq!(query(runtime.vm_mut(), new, "result"), Value::Nil); + assert_eq!(scheduler.poll(runtime.vm_mut(), 64).unwrap(), 0); + let scope = PlainHost + .scope(runtime.vm().object_store(), owner) + .unwrap() + .unwrap(); + assert!( + runtime + .vm() + .object_store() + .dict_items(scope) + .unwrap() + .is_empty() + ); + scheduler.quiesce(runtime.vm_mut()).unwrap(); + runtime.close().unwrap(); + assert_eq!(runtime.vm().object_count(), 0); +} + +#[test] +/// 交付前撤销资格阻止回调,轮询执行取消;退出门闩在重新取得资格后仍拒绝提交。 +fn host_lifecycle_and_shutdown_prevent_late_delivery() { + let (mut runtime, scheduler, api, owner, callback, calls) = setup(); + let task = after(&mut runtime, api, owner, callback, "late"); + runtime + .vm_mut() + .set_attr(owner, "eligible", Value::Bool(false)) + .unwrap(); + assert_eq!(query(runtime.vm_mut(), task, "active"), Value::Bool(false)); + assert_eq!(scheduler.poll(runtime.vm_mut(), 64).unwrap(), 1); + assert_eq!( + query(runtime.vm_mut(), task, "status"), + Value::Text("cancelled".into()) + ); + assert_eq!(calls.load(Ordering::SeqCst), 0); + scheduler.quiesce(runtime.vm_mut()).unwrap(); + runtime + .vm_mut() + .set_attr(owner, "eligible", Value::Bool(true)) + .unwrap(); + let function = object(runtime.vm().get_attr(api, "after").unwrap()).unwrap(); + assert!( + runtime + .vm_mut() + .call( + function, + &[ + Value::Object(owner), + Value::Text("forbidden".into()), + Value::Number(0_i64.into()), + Value::Object(callback), + ] + ) + .is_err() + ); + runtime.close().unwrap(); + assert_eq!(runtime.vm().object_count(), 0); +} -- 2.52.0