arXiv:2608.25512 PL 理论 × 生产源码 DeepSeek Harness vendor/cordis

时空可组合性,
从形式化到 2693 行

《A Programming Paradigm for Spatiotemporal Composability》与 dsh 内置 Cordis 源码的逐条对照:81 条编号结果、10 个算法、92 页证明,以及 11 处论文没写进定理的工程真相、一份逐条对账。

论文 Yifan Shi · Wei Zhang · Tianyi Cui 单位 北京大学 · DeepSeek-AI 实现 @deepseek-ai/cordis 4.0.2 日期 2026-09-19
本文不是摘要复述。它做三件事:把论文的 81 条形式化结果讲成人能读懂的链条;把每条理论断言落到 dsh 源码的文件:行号上;并且标出论文没有覆盖、但生产代码必须自己兜住的那部分——那部分恰好写在 vendor/README.md 的「Local modifications」日志里。
92 页
论文正文 79 页 + 参考文献 9 页(127 条)
81 条
46 定义 · 18 定理 · 16 引理 · 1 推论(单序列编号 1–81)
2,693 行
Cordis 核心库,9 个源文件
6,505 行
vendored 全栈(核心+loader+hmr+…)
297k 行
建在它上面的 dsh(1,595 个 .ts)

00 / TL;DR一分钟结论

这篇论文想解决的事,一句话:软件构件在运行时装卸时,怎么保证「拆干净」和「依赖不乱」。它把编程语言理论里的 效应(effect) 和 余效应(coeffect) 从编译期搬到了运行时,分别对应「回滚」和「依赖解析」,然后用一个统一的 context 把两者缝起来,证明在若干前提下,一个组件的局部保证能升格成整个系统的保证。

论文真正的主张

1. 每个效果自带一个逆,运行时拿着它,于是卸载 = 应用逆(Section 3.1)。
2. 依赖是一份声明,每次上下文变化都拿声明去分类成「激活/去激活/无关」(Section 3.2)。
3. 两者汇进一个自相似的上下文类型 Γ∞,所有交互只能从它过(Section 3.3)。
4. 给「不同组件的效果互不干扰」一个可证的判据:交换性(Section 3.4)。
5. 9 条规则的操作语义 + 元理论:恢复精确、依赖有序、无死锁、合流(Section 4)。
6. TypeScript 实现 Cordis + 声明式装载器 + HMR,Koishi 4000 插件验证(Section 5)。

源码里真正吃重的部分

有意思的是,理论最漂亮的部分(Γ∞、≃ 观测等价、拓扑群论式的独立性)在代码里没有对应实体——它们以「不变式」的形式存在,而实现是把它们压缩成几个具体的机制:
ctx.effect() 的 disposer 栈 · Fiber._refresh() 算出来的 epoch 摘要字符串 · _store / store 的「草稿/已提交」双缓冲 · fiber.inertia 这一个 Promise 字段 · ctx.provide() 在撤销时 await 依赖者。
加起来不到 300 行,承载了论文第 4 章全部结论。

本文最想让你记住的一句

这篇论文的理论保证全部建立在两个「无人校验」的前提上:效应作者声明的逆真的能回滚(𝔈Γ* 的 witness),服务提供者声明的操作真能交换(Definition 46 的 commutativity witness)。运行时一行都不检查。论文自己在 §5.1.1 承认了这一点——所以严格地说,Cordis 提供的不是「保证」,而是一套让保证可被陈述、可被局部化的语法。这不是缺点,是设计选择;但任何把它当成「装上就自动安全」的读法都是误读。

如果你只想知道代码值不值得学

值得,而且值得抄的是这三样:① 用「逆」而不是「destroy 钩子」来表达释放,让释放和创建在同一个语法位置;② 用「provider 身份摘要」而不是「值比较」来判断依赖是否需要重启(一次字符串比较替代深层 diff);③ 撤销时的「先停止供出、再等依赖者撤完、最后才真的拆自己」三步序。剩下的形式化是解释这三样为什么正确。

01 / 档案论文档案与血统

先把「这是什么论文」钉死。它不是 DeepSeek Harness 的技术报告(DSH 没有官方技术报告,文档即仓库),而是它依赖的框架 Cordis 的理论基础。作者三人中,Tianyi Cui 即 dsh 仓库贡献第一的 tianyicui;这也是为什么 dsh 会把 Cordis 源码 vendor 进仓库,并在 README.md 里直接引用这篇论文。

论文元数据
标题A Programming Paradigm for Spatiotemporal Composability · 时空可组合性的编程范式
作者Yifan Shi1,2 · Wei Zhang1 · Tianyi Cui2
单位1 北京大学  ·  2 DeepSeek-AI
arXiv2608.25512
篇幅92 页(正文 §1–§8 为第 4–82 页;参考文献 127 条,第 83–92 页)
形式化密度46 个 Definition · 18 个 Theorem · 16 个 Lemma · 1 个 Corollary(共用一条编号序列,共 81 条)· 10 个 Algorithm · 2 张表 · 1 张图
结构§1 引言 → §2 预备(效应/余效应)→ §3 运行时机制 → §4 演算与元理论 → §5 实现与案例 → §6 讨论 → §7 相关工作 → §8 结论
对应实现@deepseek-ai/cordis 4.0.2(dsh 仓库 vendor/cordis/;上游为 github.com/cordiverse/cordis packages/core,vendor 清单记录于 commit 56b3d4f7)
案例系统Koishi(聊天机器人框架,4000+ 社区插件)。论文脚注 4 明确:Koishi 目前跑的是 Cordis v3,本文讲的是 v4,两者共享核心组合模型,v4 重做了效应/余效应语义与装载器。

血统:一条被论文串起来的三代谱系

2019–2023 · Koishi聊天机器人框架。用「插件即一切」重写了 Cordis 的第一版,攒下 4000+ 社区插件,证明开放式生态里真的会形成依赖拓扑。
→
Cordis v3Koishi 生产在跑的一版。效应/余效应语义粗糙,装载器是另一套设计。论文里明确把它排除在形式化之外。
→
Cordis v4(本文)重做效果与余效应语义,引入 Γ∞ 统一上下文、反应式余效应分类、惰性(inertial)状态机;装载器支持声明式协调。
→
DeepSeek Harness把 v4 源码 vendor 进仓库而非走 npm:重命名到 @deepseek-ai/* 作用域、打上 12 条本地补丁、作为每个 package 的 peerDependency。整个产品(模型适配、工具注册、会话日志、agent 主循环)都是它的插件。
为什么要「源码 vendor 而不是依赖 npm」

vendor 清单开头写得很直白:“so that the harness fully owns its framework layer (auditable, patchable, pinned)”——可审计、可打补丁、可钉版本。这三条都不是假设:本文第 06 节会看到,dsh 在 Cordis 生命周期里补了 7 处重入/竞态加固,在 loader 里补了事务化协调,在 HMR 里补了死锁与自触发抑制。理论上「已经证明」的系统,在生产里仍然需要打补丁——这是本文最有信息量的结论之一。

术语对齐表(本文通用)

论文用的是 PL 理论词汇,dsh 文档用的是工程词汇,两者常常同名不同义。全文按下表翻译,后文不再重复解释。

三套词表:论文理论 ↔ 论文实现 ↔ 真实源码
理论符号 / 论文用词论文 §5 的实现名dsh vendor 里的真实代码一句话
Γ, Γ∞ctxContext(Proxy 实例)第一等公民「上下文」:既是状态,又是效果/余效应的唯一通道
𝔈Γ, ℑΓcallbackctx.effect(() => …) 的返回值形状效果函数 / 效果迭代器:返回或 yield 出「逆」
effectΓ(e)ctx.effect(callback)Fiber.effect() fiber.ts:418把效果提升一层并自动记录逆、自动回收
Σ, Σiso, Σinter@@store / @@isolate / @@interceptctx[symbols.isolate] · ReflectService.store · ctx[Context.intercept]依赖表 / 隔离域表 / 拦截元数据表
get(k), set(k,v)ctx.get / ctx.setreflect.get / reflect.set读/写一个复用键;注意 set 本身是一个效果
⟨d,p,e,π,σ,τ,θ⟩fiberclass Fiber组件的一次实例化,带自己的生命周期状态
d : 𝔇Γfiber.injectfiber.inject (Dict)+runtime.inject声明的依赖集合(余效应规格)
p : 𝔓Γprovidectx.provide(name, value)声明自己会提供哪些键(装的时候不一定全装上)
θ(生命周期)fiber.stateFiberState.PENDING/LOADING/ACTIVE/FAILED/UNLOADING/DISPOSED装载中/就绪/运行/失败/卸载中/已移除
g(累加器)fiber.disposeFiber._disposables + effect() 的 wrapper逆的复合:卸载就是把 g 应用到状态上
ω(已提交视图)fiber.committedFiber.store(已发布快照)这个 fiber 装载时「认下来」的依赖解析结果
target(γ,n)fiber.targetFiber._runner.epoch(摘要字符串)「现在应该」解析成什么;与 ω 不等就触发转移
inertia / 𝖥𝗎𝗍𝗎𝗋𝖾fiber.inertiaFiber.inertia(Promise 句柄)正在进行的转移;惯性 = 一旦开始就跑完
O-Insert / O-Retirectx.use + 回调的逆ctx.plugin() / registry.plugin()插入一个 fiber / 退役它(注意:退役 ≠ 移除)
L-Leave / L-Unloadrefresh / unload_setEpoch 置 UNLOADING / _unload()先「停止供出」,后「执行撤销」——两步是顺序保证的来源
guard(¬relied)unload 里 await 依赖者reflect.provide() 的 disposer 里 await Promise.allSettled(fibers.map(f => f.await()))撤销前先把依赖我的人撤干净

表右列的行号均以 ~/project/dsh-official/vendor/cordis/src/ 为根,并在后文逐处复核。论文 §5 的 Table 2 给的是官方对应表;上表第三列是我按真实源码补的——它和论文那列并不总是一致,差异见 第 06 节。

02 / 问题动态可组合性:两个正交维度

传统组合是静态的:函数调用、模块导入、类继承,都在编译期定死。现代软件的插件系统、尤其是能自己改自己的 agent harness,要求运行时装卸构件。论文的价值在于:它没有笼统地说「动态组合很难」,而是把难点拆成两个正交的维度,并指出各自在静态世界里早就有对应物。

时间维度 · Temporal composability

组件被移除时,它对共享环境做过的修改必须完整且安全地回滚:每一次资源分配、事件注册、状态写入都要被跟踪,并在移除时有序回收。

静态对应物:词法作用域——RAII、bracket 模式。
动态难点:效果的生命周期不是词法有界的。一个插件可以在装载时注册一个回调,而这个回调在 3 天后才被触发。

空间维度 · Spatial composability

组件必须能声明、发现、解析彼此之间的依赖,并且当依赖出现、消失或换了身份时,生命周期要跟着动。

静态对应物:模块导入解析。
动态难点:依赖会在执行中出现和消失,而且「同一个键换了实现」和「键消失」是两种不同的事故,需要区分处理。

论文的实证靶子:VS Code

论文用 VS Code 扩展系统做了两组统计(数据取自 2026-06-09 的 Marketplace,按安装量 Top 100):

论文 §1.2.1 的实测数字
事实数字后果
Top 100 扩展中含可执行代码的比例87 / 100卸载它们必须重启整个扩展宿主;所有已加载扩展一起受影响
声明了非内置 extensionDependencies 的比例7 / 100插件之间的依赖几乎不存在——不是因为不需要,而是因为 API 形制不允许

论文对这两个数字的解释比数字本身更有意思:

  • 时间上,VS Code 有 deactivate 钩子,但它只是宿主进程终止时的优雅关闭回调,不能用于热卸载;更要命的是,释放与创建被拆到了两个函数里(activate 建、deactivate 拆),这违反「关注点局部性」,让「清理是否完整」变得无法验证。
  • 空间上,只有 7% 声明依赖,是因为扩展 API 暴露的是固定的宿主扩展点(commands / views / language features),扩展是「往宿主上挂」而不是「互相依赖」;而唯一的互操作通道 getExtension().exports 返回值类型是 any,没有结构化契约。

论文强调这不是 VS Code 的个性,而是插件系统的共性,只有程度差异。

为什么 OS / 容器这层「粗粒度替代品」不够

操作系统已经在进程粒度上给了时间可组合性,容器编排在服务粒度上给了空间可组合性。于是绝大多数软件选择「容忍」:模块出问题就重启进程,依赖就用编排器管。论文列了这笔账:

粗粒度替代的成本
代价根因
时间重启丢掉所有进程内累积状态(缓存、连接、半成品计算),重建要秒到分钟级;期间要保可用就得开冗余副本,用资源换「没法只恢复一个组件」这件事恢复粒度 = 进程
空间容器级编排表达不了同地址空间内组件之间的依赖;本来一次本地函数调用的事,被迫变成网络往返依赖粒度 = 服务
两种机制都工作在进程和容器的边界上,而现代系统越来越多地在更细的粒度上组合。这个粒度错配要求一种与组件本身同层级的、管理效果与依赖的抽象。论文 §1.2.3,意译

真正的动机:会自己改自己的 agent harness

第二个动机例子才是这篇论文和 dsh 的接缝。论文描述的「未来 harness」:能持续生成并部署对自身构件的修改,同时不停机地服务请求。它列了两条硬需求:

为什么 agent harness 是最强的动机

没有时间可组合性:每次自我修改都要全量重启,进程内状态全丢;在这个频率下不可用时间累积起来很可观,在途任务被反复打断;更糟的是,一次错误的自我修改可能弄坏「用来恢复的那个进程本身」。

没有空间可组合性:每个模块得自己探测并适配它所依赖模块的出现/消失/换人,只能靠 ad-hoc 手段;更糟的是,朴素的代码替换策略会静默弄坏依赖者,或者引入只在 reload 时才浮现的循环依赖。

而 dsh 把这段话做成了产品:它的 tool-cordis 插件给模型本身提供 cordis_define / cordis_run / cordis_stop / cordis_undefine / cordis_inspect_query 五个工具(packages/extensions/tool-cordis/src/index.ts)——模型在会话中就能定义、装载、停用、卸载自己的 Cordis 插件。论文的「未来工作」在 dsh 里已经是默认能力,这也让本文第 06 节的落差分析变得不只是学术趣味。

理论基础的两根柱子(§2 速通)

论文花了两页复述经典理论,只为拿两样东西。如果你熟悉这块可以跳过,但有两个细节值得注意。

效果 vs 余效应:一对对偶
效果 Effect余效应 Coeffect
判断形式Γ ⊢ t : TeffectΓcoeffect ⊢ t : T
修饰谁结果类型上下文
回答什么程序对世界做了什么世界对程序施加了什么约束
经典载体Monad(Moggi/Wadler) · 代数效应与 handler(Plotkin & Power / Pretnar)Comonad;graded modal types(Orchard 等,Granule 语言)
论文的抱怨这两套东西都是静态工具:效果在词法固定的作用域里被跟踪、靠编译期 handler 消解;余效应标注在执行前就被验证。而动态组合要求这些保证对运行期来去的组件成立——没有任何固定词法作用域能界定一个部署后才加载的插件,也没有任何编译期上下文能预知运行期配置里冒出来的依赖。

于是论文的整个方法论浓缩成一句话:不去给静态类型系统加更多标注,而是把效果和余效应的概念结构物化(reify)成运行时能直接操作的东西,让运行期动态建立这些系统本来在编译期提供的保证。

03 / 理论把「效果」从编译期搬到运行时

§3 是全篇的理论心脏。它做的一件事可以概括为:用一个「带着逆的状态变换」替换掉「一个有副作用的函数」,然后一步步把「逆」从输入侧挪到输出侧、从单个挪到序列、从一台机器挪到整个系统。下面按论文自己的推进顺序走,每一步给出直觉和为什么需要这一步。

读法建议

符号只在必要处出现。若你只关心「这套理论对写代码有什么用」,可以直接读每小节末尾的「工程读法」框,再跳到 第 04 节。如果你要读论文原文,下面的顺序与论文 §3.1.1 → §3.4.2 完全一致,可以逐节对照。

3.1 可回滚效应(Revertible Effects)

出发点。任何带副作用(impure)的函数 f : X ⇝ Y 都可以被「纯化」成 f : Γ × X → Γ × Y,其中 Γ 是上下文类型。固定输入 x 之后,γ ↦ pr₁(f(γ,x)) 就是这次调用的副作用——它与返回值无关。于是:副作用全体 = 变换幺半群 (Γ → Γ, ∘)。幺半群三条公理在这里都有直接读法:闭包 = 两个效果先后作用仍是效果;结合律 = 复合效果与括号无关;单位元 = idΓ。

要「能撤销」,就给每个变换 f 配一个 g,并称 g 是 f 的左逆。论文刻意强调这一点:撤销是单侧的——只要求 g ∘ f,永不要求 f ∘ g。这一步看似技术细节,其实是全部工程可行性的来源(你不需要「撤销一个撤销」有意义)。

Definition 1 · 扭合(Twisted composition)(4) (f₁, g₁) ∘ (f₂, g₂) ≔ (f₁ ∘ f₂, g₂ ∘ g₁) 正向按原序复合,逆按反序复合。这把 (Γ→Γ) × (Γ→Γ) 变成幺半群 𝔗Γ,论文称它为「变换幺半群与其反范畴的积」。
Definition 2 · 效果上下文(5) ∂Γ ≔ Γ × (Γ → Γ)   写成 (γ, φ) γ = 当前状态;φ = 累加器,即「到目前为止所有逆的复合」,也就是把上下文恢复回初态的那个函数。初态记 (γ₀, id)。论文还定义了塔:∂²Γ = ∂Γ × (∂Γ → ∂Γ),可以叠上去。
Definition 3 · track(6) trackΓ(f, g) = (γ, φ) ↦ (f(γ), φ ∘ g) 把 g 摞到累加器上。就这一步,「记录」被实现了。

接下来三个定理构成了「局部时间可组合性」的全部内容,顺序非常重要:

§3.1.1 的三个定理,各管一件事
结果陈述它挡住了什么 bug
Theorem 4 pr₁ ∘ track(f,g) = f ∘ pr₁ 「加了记录之后,行为的正向部分不变」——跟踪不能改变语义。否则任何插桩都会污染被测系统。
Theorem 5 track 是 𝔗Γ → (∂Γ→∂Γ) 的幺半群同态 「一次记一个」和「把一串一次性记完」等价——可以用单步推理代替全序列推理。这条是后文所有归纳证明的杠杆。
Theorem 7 若 g(f(γ)) = γ,则 recover(track(f,g)(γ,φ)) = recover(γ,φ) 「一个被正确撤销的效果,不会移动恢复的结果」——恢复是不变式,不是终态动作。论文把 φ(γ) = γ₀ 称为状态的可靠性不变式(soundness invariant)。
Definition 6 · recover(9) recoverΓ(γ, φ) = (φ(γ), idΓ) 把累加器作用到当前状态上,然后把累加器清回 id。注意「清回 id」的代价:recover 是全有全无的——它不能只撤其中一个效果而保留其他。

两个致命限制,逼出后面两级抽象

限制一:逆来得太早

trackΓ(f,g) 在看到任何状态之前就把 g 定死了。于是同一个 g 必须在效果能落到的每一个状态上都满足 g(f(γ))=γ。但撤销其实不需要这么强:只需要在它被应用的那一个状态上能逆。
这在参数位置上做不到——逆必须在应用点被返回,而不是在调用点被传入。

限制二:recover 全有全无

recoverΓ 一次把整个累加器抹掉,无法「只撤最近的这个,保留其他的」。而真实世界的卸载从来不是「把系统拆回零点」:agent 会话里卸载一个插件,必须先撤它的工具注册,同时保留会话日志、保留模型连接、保留别的插件的注册。

论文的对策非常对称:输入侧让效果除变换外额外返回一个逆(Γ → Γ × (Γ→Γ),即 Γ → ∂Γ);输出侧让 ∂Γ → ∂²Γ。两侧形状相同,于是可以用同一个类型族描述两层。

Definition 8 · 效果函数与「带见证的」效果函数(12) 𝔈Γ ≔ Γ → Γ × (Γ → Γ)
𝔈Γ* ≔ (e : 𝔈Γ) × ((γ : Γ) → (δ : Γ) → (g : Γ→Γ) → ((δ,g) = e(γ) → g(δ) = γ)) 这就是「逆在应用点返回」:e(γ) 给出新状态 δ 和属于这一次应用的逆 g。带见证版本额外携带一个证据,证明每次返回的逆都在它自己那一点上把效果撤回去了。γ 不同,逆可以不同。
论文的图上写得很直白:这个见证就是「逆把效果回滚」这件事在类型里的表示。
Definition 9 · 效果复合 ⋄(13) (f ⋄ g)(γ) = let (δ, s) = g(γ) in let (ε, t) = f(δ) in (ε, s ∘ t) 效果函数不再是 Γ 上的自同态,所以不能直接复合,要新定义一个:先跑 g,再跑 f,逆按相反顺序叠成 s ∘ t。(𝔈Γ, ⋄) 是幺半群,单位元 ηΓ(γ) = (γ, id)。Theorem 11 证明:见证在复合下存活,带见证的效果函数构成子幺半群。
Definition 12 · effect:把效果提升一层(14) effectΓ(e) (γ, φ) = let (δ, g) = e(γ) in     ((δ, φ ∘ g),  trackΓ(g, pr₁ ∘ e)) 逆本身也是一个效果:它把状态按 g 变换,而「撤销这个逆」的办法就是再做一次原效果(pr₁ ∘ e)。Theorem 13 证明 effect 保持 ⋄ 运算;Theorem 15 给出一个漂亮的边界结论:

g′(Δ) = (γ, φ ∘ g ∘ f) —— 状态精确恢复,但累加器只有在 g ∘ f = idΓ 时才完全复原。也就是说:effect 不把 𝔈Γ* 送进 𝔈∂Γ*,但「恢复目标」始终不动。这是全篇最诚实的一处:理论不假装完美,只承诺不变量。
Definition 17 · 效果迭代器(17) ℑΓ ≔ μℑ. Γ → Γ × (Γ→Γ) × Maybe(ℑ) 一次应用产出一个三元组:(新状态, 逆, 延续)。Nothing 表示序列结束,Just(i) 给出下一次迭代。
论文特别点出:这就是主流语言里 yield 暴露的那种「具象化的定界延续(delimited continuation)」,所以模型可以直接映射到语言已有的生成器上。事实也确实如此——dsh 里 ctx.effect(async function* () {…}) 就是它。
普通效果函数是退化情形:第一次迭代就 yield Nothing(式 19)。
Theorem 16:反序撤销为什么天然成立
Theorem 16e₁…eₙ 按序应用、反序撤销,则(1)每一次撤销都恢复到它自己那次应用的状态;(2)所有中间状态满足可靠性不变式。
证明要点反序撤销使得每个逆拿到的正是它自己那次应用产生的状态,于是 Definition 8 的见证条件恰好命中,不需要任何额外假设。
工程对应dsh Fiber.effect() 里收集 disposer、DisposableList.clear() 反转返回、effect() 内部用 task = task.then(...) 串行链——见 4.2 节。但那条链只覆盖单个 effect 内部,兄弟 effect 之间是并发的,这是第 06 节的一处落差。
工程读法 · 这一节对写插件的人意味着什么

一句话:不要写 onLoad / onUnload 两个函数。写成一个函数,里面每做一件事都把「怎么撤掉这件事」还回去。顺序不能靠调用者记,要靠运行时自动反序。

这就是 RAII/bracket 模式在动态场景的推广,但有一个关键区别要记住:论文明确说局部保证止步于「一个组件的效果自己」。一旦两个组件的效果交错在同一份状态上,Theorem 16 就不再直接适用——那需要 §3.4 的独立性。

3.2 反应式余效应(Reactive Coeffects)

出发点。把 IoC 容器形式化成一个「余效应上下文」,好处是它天然和上一节的效果机制咬合。论文用一句话点出这个协同:余效应操作本身就是效果,而效果是可回滚的。

Definition 19 · 余效应上下文(20) Σ ≔ (k : K) ⇀ 𝒱k   (K 上的依赖部分函数,键给类型族,保证每个键有自己的值类型) 记号:σ(k) 取值、σ[k ↦ v] 绑定、σ ∖ k 限制、k ∈ dom(σ) 成员测试。扩展与限制都带前置条件(不能重复提供、不能撤销不存在的东西),违反即报错且不产生转移。
Definition 20 · get / set(21) get(k)      = σ ↦ σ(k)            (要求 k ∈ dom(σ))
set(k, v) = σ ↦ (σ[k ↦ v],  λσ′. σ′ ∖ k)  (要求 k ∉ dom(σ)) 注意 set 的类型是 𝔈Σ*——它是一个效果函数,返回的逆是「把键删掉」。于是 §3.1 的整套机器(跟踪、恢复、复合)可以直接套在依赖注册上。这就是论文说的「协同」:提供服务和注册服务会自动获得回滚能力。

接下来是这一节的真正发明。经典 DI 是「取不到就崩」,论文要求把「声明」变成可判定的东西:

式 (22) · 满足谓词 σ ⊧ d  ≔  ∀k ∈ d. k ∈ dom(σ) d ⊆ K 是组件声明的依赖集合。可判定(因为 dom(σ) 有限)。
Definition 22 · 三分类 notify(24) notifyd(σ, σ′) =   · activating   若 σ ⊭ d 且 σ′ ⊧ d
  · deactivating 若 σ ⊧ d 且 σ′ ⊭ d
  · neutral      其他 激活转移触发组件的效果执行(按 §3.1 跟踪);去激活转移触发累加器的应用。
「每次上下文变化都被拿规格分类一次」——这就是整个反应式机制。注意 neutral 不是「忽略」:它也走一遍分类,只是结果不动状态。

隔离与拦截:同一个键,不同解析

论文先给了一个很关键的概念区分(Definition 23),它直接决定了代码的形状:

Definition 23 · 效果的两种「实现方式」
就地实现 in-place派生实现 derived
做什么改写输入状态,返回一个非平凡的逆输入原封不动,派生出一个新状态,逆恒为 id
恢复运行逆,把改动抹掉丢弃派生状态即恢复
纯函数世界里两者重合;命令式宿主可以按操作自行选择
为什么这个区分值钱

因为 隔离(isolation)和拦截(interception)被定义为派生实现:它们不改共享表,只派生一个新上下文。于是「无需跟踪、无需逆、无需前置条件」——recovery is implicit: discarding the child context suffices。

代码里,这条对应的是 Context.extend() 用 Object.create 造原型链子上下文,而 isolate/intercept 各造一层新的 symbol map(context.ts:96-140)。零成本抽象在这一处是真的成立——没有 dispose 注册,没有表写入,垃圾回收就是回滚。

Definition 24 · 带隔离的余效应上下文(25) Σiso ≔ (K ⇀ R) × ((r : R) ⇀ 𝒱r)   写成 (ρ, σ) ρ 是「隔离域表」:每个键映射到一个 realm 标识符。取值变成两层:k →ρ r →σ 值。不在 dom(ρ) 里的键解析到它自己(记 ρ(k) = k,R ⊇ K)。
Definition 25 给出三操作。注意 isolate(k, r) 的类型是 Σiso → Σiso 而非效果函数(派生实现),所以它「重新指派而不拒绝」已隔离的键。
论文的评语很到位:「隔离机制本质上实现了一个运行时的 ad-hoc 多态系统。」
Definition 26–27 · 带拦截的上下文(27)(28) Σinter ≔ ((k:K) → ℳk) × ((k:K) ⇀ (ℳk → 𝒱k))   写成 (ι, σ)
get(k, μ) = (ι,σ) ↦ σ(k)(μ ⊕k ι(k)) 每个键自带一个元数据幺半群 (ℳk, ⊕k, εk)。取用时把「组件声明的元数据 μ」和「上下文携带的元数据 ι(k)」合并,再喂给 provider 函数。
合并是右偏的:ι(k) 优先级更高,可以覆盖组件的声明——这让外层上下文能约束组件如何使用某个依赖,而不修改组件本身。论文在 §6.3 把这一点用成了访问控制机制。
工程读法 · 依赖声明不是「查表」,是「被分类的谓词」

写出 inject: ['tools', 'llm'] 意味着两件事:① 我不满足时不要启动(不要乐观访问然后崩);② 满足性变化时要通知我(激活或去激活)。论文把这两条称为局部空间可组合性的判据。

而它没有保证的两条,恰好是最容易出事故的两条,论文也明说了:「撤销一个绑定必须等它引起的去激活全部结束」、「激活运行期间它读到的绑定不能移动」——这两条落在其它组件身上,属于全局保证,由 §4.3.3 建立。代码里这就是 provide() disposer 里那个 await,见 4.4 节。

03.3上下文范式:一个类型装下两个维度

到这里,论文手里有一个「效果上下文」∂Γ(带累加器)和一个「余效应上下文」Σ(依赖表)。§3.3 把它们合成一个自相似的类型,并回答一个之前被绕开的问题:两个组件同时改同一片状态时,什么叫「互不干扰」?

Definition 28 · 上下文类型 Γ∞(29) Γ∞ ≔ μΓ.   Γ × (Γ → Γ) × Σ 三个投影:Γ 是递归的当前状态;Γ→Γ 是本层的累加器;Σ 是依赖表。
因为第一项就是 Γ 自身,这个类型是自相似的——效果映射 𝔈Γ∞ 到它自己,∂-塔被折进了一个类型里。

定义里藏着两个很重要的判断,论文用两段话展开:

  • Σ 的键空间没有约束,所以它能吞掉所有共享可变状态。论文原话:「因为 Σ 底下的类型族 𝒱 不受约束,系统需要跨组件共享的任何状态都可以编码成一个带合适值类型的依赖——Σ subsumes all shared mutable states, not just inter-component dependencies。」
  • 但「只有一个通道」只有在没有别的通道时才构成纪律。所以还必须规定组件拿着绑定值能干什么。于是键承载的不只是值类型,还有一组操作。
Definition 29 · 余效应带上了操作集(30) 键 k 处的余效应 = (𝒱k, 𝒜k)   其中每个操作 a ∈ 𝒜k 带参数类型 Xa、结果类型 Ba,并且只作用于那个值本身:
    a : Xa → 𝒱k ⇀ 𝒱k × (𝒱k → 𝒱k) × Ba 前两项构成一个值类型上的效果函数(Definition 8 意义上的),第三项是操作的结果。
这条类型把操作「限制」在了那一个键上:提升到 Σ 上的 aΣ 只读写 σ(k),其余键原封不动。论文一句话:「no side condition is needed to say so」——类型即限制,不需要额外规定。
Definition 30 · 上下文中介的迭代器(32) ℑ𝒜Σ(S, P) 是最小集合,含单位元 σ ↦ (σ, idΣ, Nothing),并且当各枚举的延续都是 Nothing 或成员时,还含:
  · σ ↦ let (δ,s,b) = aΣ(x)(σ) in (δ, s, cb)  // 操作阶段,k ∈ S
  · σ ↦ let (δ,s) = set(k,v)(σ) in (δ, s, c)  // 提供阶段,k ∈ P 「一个组件的装载是一个阶段序列,每个阶段可以依赖前面阶段的产出」——参数 x 可以依赖之前得到的结果 b,这就是 cb 索引的含义。
属于这个类的,才叫「一切交互都经由上下文」;不属于的,就是「读了别的东西」——论文举的例子很传神:一个从上下文不持有的计数器里取句柄的分配器。它一旦把计数器绑成一个键,就重新回到类里。

观测等价:为什么「恢复」不能按字面理解

这一节(§3.3.2)是全文哲学味最重、也最容易被跳过的部分,但它实际上是整篇论文的诚实性声明:

§3.1 的恢复保证断言的是状态相等,而这是一种理想化,因为物理状态根本不可能被原样恢复。比如 free 把一块内存还给分配器,并不会恢复 malloc 之前的堆布局;一个生成名也不会被那个丢弃它的逆恢复,因为下一次创建会拿到一个全新的名字。论文 §3.3.2,意译

解法是把所有等式按观测等价 ≃ 来读:两个状态相关,当且仅当没有任何观察者能区分它们。而「观察者被给了什么」决定了这个关系有多粗:

  • 上下文的观察者拿到的是它携带的余效应;
  • 一个值的观察者拿到的是它那个键的操作集 𝒜k。
Definition 31 · 测试与不可区分(33) 一个操作集 𝒜 上的测试是一个有限字:字母是各 a(x) 的正向映射与它 yield 出的逆,每个字母作用在前面的字母留下的值上;测试的结果是沿途正向映射给出的 outcome;前置条件不满足处测试未定义。
不可区分:v ≈𝒜 v′ ⇔ 每个测试在两边同定义或同未定义,且沿途 outcome 相等。
键上的等价 ≃k ≔ ≈𝒜k
Lemma 32 · 为什么这个定义「恰到好处」

(1) ≃k 是一个等价关系,且 𝒜k 的每个操作都尊重它(在相关值上同定义/同未定义,后继相关,outcome 相等);
(2) 任何被所有操作尊重的等价关系都包含于它——所以它是最粗的(the coarsest)那种关系。

第 (2) 条给了证明方法论:「要证明两个值相关,只需给出一个操作们尊重的、包含这对值的等价关系」。

然后把关系沿类型构造子扩展(Definition 34):函数按输入相关则输出相关、元组逐分量、Maybe 分情形、递归类型按共归纳取最大不动点。于是得到 ≃S(只比较 S 里的键)和整套带见证版本 𝔈ΓS / ℑΓS(Definition 36–37)。

Lemma 38 · 全部等式的重新解读 §3.1 里断言的每一条状态等式,把 = 换成 ≃ 后仍然成立;任何从 (γ₀, idΓ) 可达状态的累加器都尊重 ≃。证明用的性质不超出「传递性 + 尊重」。 更狠的一条在 Definition 33 后面:「没有键绑定的那部分状态因此被遗忘——而正是这个遗忘,才让 Theorem 7 有可能按 ≃ 来读。」堆布局、生成名,除非某个键绑定了它们,否则根本不在关系里。
反过来说:系统没有 reify 到某个键上的位置,就完全不在演算之内(Definition 56)——这正是 §6.1「System Boundary」的伏笔,也是 dsh 里「绕过 ctx 的效果无法回滚」的理论出处。
工程读法 · ≃ 是接口设计工具,不是数学装饰

Definition 31 把「两个值算不算一样」定义为「你的接口能不能区分它们」。这条推论的实用形态在第 §3.4.2 节里被明说了出来:「≃k 是由该键的操作生成的测试下的不可区分性,所以公布更少 outcome 的接口允许更少的测试、从而使关系更粗;把调用者不需要的 outcome 收起来,可以把一个键从分界的一侧抬到另一侧。」

换言之:你少返回一个 id,你的组件就更好组合。

3.4 独立性与交换性:把局部保证升格成全局保证

前两节的保证都是局部的:「读一个组件自己的效果与余效应」。一旦两个组件交错,就会出两种新情况:

  • 一个逆在后续效果还在的时候被执行(从运行中的系统里摘掉一个组件,等价于这个);
  • 一个序列交错了多个组件各自持有的逆,于是 A 的逆之间夹着 B 的应用。

两种情况下,逆都会遇到一个被外来效果移动过的状态。它还撤得掉自己那份吗?——这纯粹是交换性问题。「单个累加器解决不了这两种情况,因为 φ 是一个把所有逆按一个顺序、一次性全跑掉的复合。」

Definition 40 · 转换幺半群 𝔐(i)(38) reach(i) ≔ 含 i 且对延续封闭的最小集合
𝔐(i) ≔ ⟨{ pr₁ ∘ i′ | i′ ∈ reach(i) } ∪ { pr₂(i′(γ)) | i′ ∈ reach(i), γ ∈ Γ }⟩ 注意第二项:被 yield 出来的逆也进入生成元,而不是只有正向映射。这是本节比常见的「交换两个函数」严格的地方。
Definition 42 · 独立(39)(40) 迭代器 i, j 独立,当:
(1)  ∀f ∈ 𝔐(i), g ∈ 𝔐(j). f ∘ g = g ∘ f   // 每一对变换都交换
(2)  ∀i′ ∈ reach(i), g ∈ 𝔐(j), γ ∈ Γ. pr2,3(i′(g(γ))) = pr2,3(i′(γ))   // 谁也不扰动对方 yield 出的「逆」与「延续」 (1) 是交换性,(2) 是yield 稳定性——这一条经常被忽略,但它是「某人的改写不会让我的逆变成另一个逆」的保证。论文提醒:注意独立性 不是 复合交换性 e₁⋄e₂ = e₂⋄e₁,后者只比较两两复合的结果,前者要求任取一个的正向对另一个的逆都交换。
Theorem 43 · 全篇对工程最有用的一条

e₁…eₙ ∈ 𝔈Γ* 两两独立,从 γ₀ 按序应用、各自 yield 出 gi;则在序列到达的状态上,把这 n 个逆按任意置换顺序应用,都会回到 γ₀。

换句话说:只要独立性成立,清理顺序随便排,结果都对。它解释了为什么一个真实的插件系统可以在「并发清理 + 乱序清理」下仍然正确——不是靠小心,是靠这条性质。

这篇论文里我认为最容易被低估的一句,就在它的证明里:两次用到独立性,一次是把 gj「穿过」j 之后的那些正向映射,一次是保证「其它效果在别人的状态上 yield 的逆,和在自己那点 yield 的逆是同一个」。

最关键的简化:跨键自动独立

Theorem 45 · 不同键上的操作自动独立 设 a ∈ 𝒜k, a′ ∈ 𝒜k′,k ≠ k′。则 a 与 a′ 独立。 证明直接来自 Definition 29 的类型:aΣ 的每个生成元都形如 σ ↦ σ[k ↦ u(σ(k))]——只读只写一个键;两个不同的键,两张这样的映射当然交换,而且谁也动不了对方键上的值(于是 yield 出来的 outcome 也一样)。

于是负担全部落到同一个键上。论文没有把它当作使用者的负担,而是像效果函数携带「逆能回滚」的见证那样,让提供这个键的组件携带一份「这些操作互相交换」的证明:

Definition 46 · 带见证的余效应 「一个键 k 处的余效应带见证,当它除了 𝒱k 和 𝒜k 之外,还携带一份 k 可交换(Definition 44)的证明。」 两个见证是完全平行的:效果那个证明「yield 出的逆确实能回滚」,余效应这个证明「这些操作确实交换」;两者都在定义被写下的时候给出,而不是在被使用时检查。而且——因为 Theorem 45——这份义务落在提供键的组件身上,不落在消费它的组件身上。
§3.4.2 的四组例子:什么键可交换,什么不可
键的形状可交换?论文的理由
条目表
路由表 / 事件监听器列表
可交换 注册操作为它添加的条目取一个标识符,逆就是删掉那个条目。两次注册命名两个不同条目,无论顺序如何,表对所有测试的回答都一样,而且各自可被单独撤回。
「复制数据类型(replicated data types)正是为这个条件设计的,并因此给每次添加打上唯一标签;而一个只按裸元素命名的集合就没有这个性质。」
有序链
中间件栈
不可交换 插在别人前面的中间件看到的请求不一样;两个顺序都无法在不扰动对方的前提下被撤回。
分配器句柄 看接口 若句柄不被该键的任何操作比较,则没有测试能观察到它们,≃k 把两个堆按句柄重命名视为同一个,分配是可交换的(CompCert 就是这样关联源程序与目标程序的内存状态的)。
但若地址是一个被相等性比较的 outcome,那么再分配一次的 outcome 就能把两种顺序区分开——不可交换。
POSIX 的系统调用 同一分界线 mmap 可以返回任意未用地址、creat 可以分配任意未用 inode;而 open 被要求返回最低可用文件描述符——仅这一条要求,就让两次描述符分配不再交换。
呼应「可扩展交换性规则(scalable commutativity rule)」:把交换性读成「穿过一个接口的不可区分性」,而非内部状态的相等。
Theorem 47 · 上下文中介迭代器的独立性只取决于键(p.29) 设 i₁ ∈ ℑ𝒜Σ(S₁,P₁)、i₂ ∈ ℑ𝒜Σ(S₂,P₂),且 P₁ ∩ S₂ = P₂ ∩ S₁ = ⌀,并且两边操作都会出现的每个键都是可交换的(Definition 44)。则 i₁ 与 i₂ 独立。 前置条件的意思是「我不提供你声明的东西,你也不提供我声明的」——即没有「提供者/消费者」这种交错。剩下的都能靠「键局部性 + 该键的可交换性」解决。这条定理加上 Lemma 66 就是后面全局定理的引擎。
理论部分的收束:局部 → 全局

到这里,论文已经把两个局部保证各自建好了。它们升格为全局保证所需的唯一额外条件,是「独立 / 可交换」。剩下的事就是把这个条件翻译成一套操作语义,并证明它总成立——那就是 §4。

04 / 演算9 条规则,把局部保证升格为全局保证

§4 把前两节的东西组装成一台机器:先定义组件(一个三元组)和 fiber(组件的一次实例化,带自己的生命周期),再给出 9 条规则在两个状态之间移动,最后证明这台机器具备我们要的性质。

4.1 组件、fiber、注册表

Definition 48 · 组件(42) ℭΓ ≔ (d : 𝔇Γ) × (p : 𝔓Γ) × ℑΓd∪p 三件套:d = 我读什么(依赖声明);p = 我写什么(我可能提供哪些键);e = 我是怎么做/怎么撤的(一个按 d∪p 见证过的效果迭代器)。
注意 p 是「可以提供的键」而不是「实际提供的键」——装载时未必全装上,这一点后面被 Definition 76 的「total」补丁修上。
Definition 49 · fiber(43) ⟨d, p, e, π, σ, τ, θ⟩   其中
π : 𝔑 ∪ {root}   // 父 fiber
τ : {⊥, ⊤}   // 退休标记
θ : 𝖨𝗇𝖺𝖼𝗍𝗂𝗏𝖾 | 𝖱𝖾𝗅𝗈𝖺𝖽𝗂𝗇𝗀(i, g, ω) | 𝖠𝖼𝗍𝗂𝗏𝖾(g, ω) | 𝖴𝗇𝗅𝗈𝖺𝖽𝗂𝗇𝗀(g, ω) 生命周期状态里带了三个东西:i = 剩余的效果迭代器,g = 到目前为止的累加器,ω = 已提交视图(committed view)。ω 把每个声明的键映射到「提交那一刻提供它的 fiber 名字」。
论文说得很清楚:过渡在真实运行时里是跨时间的区间而不是一步,所以两个方向各有一个专属状态(𝖱𝖾𝗅𝗈𝖺𝖽𝗂𝗇𝗀 / 𝖴𝗇𝗅𝗈𝖺𝖽𝗂𝗇𝗀)。
式 (46) · 上下文是「推导」出来的,不是存起来的(46) σγ ≔ ⋃ { σm | m ∈ dom(Fγ), θm = 𝖠𝖼𝗍𝗂𝗏𝖾(−,−) } 只对活跃 fiber 取并,所以「已经不再供出」和「已经把逆跑完了」是两个可以分开的时刻——这是后面依赖有序性的全部来源。
并集良定义是因为:每个 fiber 的表只含自己 p 的键,而 O-Insert 保证不同 fiber 的 p 互不相交(单源原则)。于是每个键最多由一个 fiber 提供,记作 providerk(γ)。

论文在这里非常坦率地交代了一处形式化对现实的简化:单源原则(disjointness)是为了让证明简单,而 §3.2.3 的隔离机制本来允许「同一个键在不同 realm 由不同 fiber 提供」。解决办法是:形式化统一读作「一个共享 realm」,而一个真要多实现的系统有两条路——realm,或者 §6.2 的 broker。

这一句是理解 dsh 的关键

论文说:「在演算之内,这个不相交限制约束了一个组件能被实例化多少次:一个 p 非空的组件同时只有一个 fiber,所以下面那些多实例化说的都是不提供任何东西的组件——也就是只消费、或者实例化别人的组件,而这正是最常见的情况。」

dsh 的工具注册就是 §6.2 说的 broker 模式:ctx.tools 是唯一的键与唯一提供者,而几十个插件通过 ctx.tools.register(...) 把自己的工具注册进它——每个注册都是一个可撤销的效果。这正是论文预测的「用一个 broker 换掉多 provider」的工程解法。

4.2 九条规则

两个关系:O- 开头的是编排规则(编排器可以做的动作,γ ⇒ δ);L- 开头的是生命周期规则(系统自己在前提满足时走的步,γ ⟶ δ)。论文特意强调:生命周期规则都是反应式的——没有一条提到调度器,步是「任意序列」,所以对所有这些序列证明的定理,对运行期可能采取的任何调度策略都成立。

9 条规则一览(论文 Table 1 的读出)
规则前提(简)效果为什么必须是这样
O-Insert名字未用、父存在、组件合法、p 与所有已存在 fiber 的 p 不相交γ[n ↦ ⟨d,p,e,π,∅,⊥,𝘐𝘯𝘢𝘤𝘵𝘪𝘷𝘦⟩]插入的 fiber 一开始什么都不装(σ 空、状态 Inactive);最后一条前提就是单源原则
O-Retiren 存在τn ↦ ⊤无条件,因为「退休」只是一个请求;执行由生命周期规则负责。把退休与移除分开,是为了让「还活着的 fiber 必须先卸载」——否则直接移除会丢掉累加器,泄漏
O-Removeτ=⊤、θ=Inactive、σn=∅、无子 fiberγ ∖ n三条前提分别挡住:没卸干净就删、表里还有绑定时删、父亲先于子删
L-Beginθ=Inactive 且 ω=target(γ,n) ≠ ⊥→ 𝘙𝘦𝘭𝘰𝘢𝘥𝘪𝘯𝘨(en, id, ω)激活。前提就是「依赖齐了」
L-Iterθ=Reloading 且 target=ω 且迭代器给出 Just(i′)→ Reloading(i′, g∘h, ω)取一步迭代,把新 yield 出的逆 h 按 g∘h 叠上(Definition 18 的顺序)。target=ω 这一条就是「解析一致性」检查
L-Finish同上,但迭代器给出 Nothing→ 𝘈𝘤𝘵𝘪𝘷𝘦(g∘h, ω)装载完成,开始供出
L-Divertθ=Reloading 但 target ≠ ω→ 𝘜𝘯𝘭𝘰𝘢𝘥𝘪𝘯𝘨(g∘h, ω)(h 可来自「中止当前迭代」或「让当前迭代落地」)最精巧的一条。装载途中依赖变了,不能就地继续,也不能直接回到 Active(那会让依赖者短暂地激活在一个「正在离开」的组件上),只能改道去卸载。两个备选正对应同步宿主(可以中止)与异步宿主(只能等它落地)
L-Leaveθ=Active(g,ω) 且 target ≠ ω→ 𝘜𝘯𝘭𝘰𝘢𝘥𝘪𝘯𝘨(g, ω)只记录「决定停止供出」,不做任何撤销。因为 θ 变成 Unloading 之后这个 fiber 就从 σγ 里消失了 —— 依赖者立刻开始自己的拆除,而它的绑定还全在原地
L-Unloadθ=Unloading(g,ω) 且 ¬reliedn(γ) 且 g(γ)=δ→ δ[θ ↦ 𝘐𝘯𝘢𝘤𝘵𝘪𝘷𝘦]真正跑累加器。守卫 ¬relied 就是「等没人依赖我了」
Definition 53 · 目标视图与静默态(48)(49) targetn(γ) ≔  ⊥  若 τn ∨ ¬(γ ⊧ dn)  否则  (k ∈ dn) ↦ providerk(γ)
quiet(γ) ≔ ∀n. (θn=Inactive ⇒ targetn=⊥) ∧ (θn=Active(−,ωn) ⇒ targetn=ωn) ∧ (θn 是过渡态 ⇒ ⊥) 整个生命周期机器就是比较 ωn 与 targetn(γ) 来驱动的。
论文强调一个设计点:ω 记录的是提供者而不是值——「因为否则另一个提供相同值的 fiber 会被误判为相同」。这一句话在实现里变成了「拿 fiber 的 uid 做摘要」。

4.3 元理论:八个结果

这是论文的兑现部分。下面这张表是〈定理 → 它在现实世界里挡住的那类 bug〉,建议逐行读——因为每一行在 dsh 的 bug 历史里几乎都能找到对应物。

§4.3 主结果表(按论文顺序)
结果陈述现实含义
Lemma 60
≃-不变性
若 γ ≃ γ′,则任一规则在 (γ, n) 适用当且仅当在 (γ′, n) 适用,且到达的状态仍 ≃ 相关。 整个演算下降到商集上。观测等价不是事后补丁,而是规则自己看不见差别——这是 ≃ 能当「正确性标准」用的前提。
Lemma 61
等变性
名字做任意双射重命名,规则序列逐步对应。 「两个只在实例化时抽到的名字上不同的序列,应当被等同看待」。这就是 fiber.uid 每次抽取都是新鲜值的理论依据。
Lemma 62
残留条目
τ=⊤、θ=Inactive、σ=∅、无人以它为父的条目是「残留的」,它满足 γ ≃K γ∖n,且对任何作用于别的 fiber 的规则都不可见。 它为 Definition 52 的「逆只能 O-Retire 而不能 O-Remove」兜底:退役留下一个空壳,而这个壳对系统完全透明。对应代码里 fiber.uid = null 但对象可能还被引用。
Def 63 / Thm 64
保持性
良构注册表的四条不变式(父指针落在表内、p 两两不交、ω 在 d 上全定义且值落在表内、ω 命名的提供者必须已安装)被每一步保持。 这是「注册表永远是一个合法的树 + 依赖永远指向活人」的形式化。代码里对应的是一条条防御性检查(见 落差 6)。
Thm 68
恢复精确性
gnu(γu) ≃K (Ψtl ∘ ⋯ ∘ Ψt₁)(γb)——在某 fiber 的整个 life 期间,别人的步等效于「从没装载过它」。 整篇论文最强的工程承诺:运行期插进来的那些别的组件的动作,不会污染我卸载后的状态。归纳证明的两处支点分别是见证条件与独立性。
Cor 69
终止恢复
life 结束时同样成立,特别地 σnu+1=∅(表被清空)——这正是 O-Remove 的前提。 「卸载完了就真的干净了」;也是 _unload() 里 this.store = undefined 的理论出处。
Thm 70
有序性
①一次转移只在依赖齐备时开始;②消费者的 life 结束早于它的提供者(提供者的 life 包含消费者的 life);③期间该键的绑定只被「声明了该键的 fiber 的操作」改动。 这解决了 §3.2 留下的两个缺口之一。这是「关连接池时必须还能拿到 provider」的定理形式。代码里就是 provide() disposer 中那个 await allSettled(dependents.await())。
Thm 71
解析一致性
整个装载过程跑在同一个解析结果上;中途目标变了则二选一——要么正常完成,要么经 L-Divert 走卸载。 挡住「装载到一半,手里的依赖被换人了」这种最难查的竞态。对应代码里 iteration 边界的 epoch !== oldEpoch 检查与 reload/unload 的相互链式。
Thm 73
进展
在 ≺ 无环、len(en) ≤ K、名字集合有限的假设下:①¬quiet 则必有规则可用(不死锁);②S(n) ≤ (K+3)(V(n)+1),且总步数有限(终止);于是每个极大生命周期序列都终结于静默态。 守卫本来会死锁。不死的理由是:一个 fiber 一进入 Unloading 就从 σγ 里消失,于是没有任何 target 还能指向它,所有曾经依赖它的 fiber 也都在离开的路上。这是「等待图必然消解」的证明。
Thm 80
合流 / 范式
任意到达静默态 γT 的序列,都能重排成一条「规范序列」;取同样编排步骤的两条规范序列,终态在重命名与 ≃ 意义下相同。 这条定理是装载器的合法性证明:编排器无论怎么增删替换,只要最终配置一样,系统停下来时就和「一开始就按最终配置写死」一样。论文对此的评语是:「这条定理允许我们把一个 Cordis 应用当作静态组装出来的那样去推理。」
Theorem 80 的边界:它说的是「状态」,不是「发射」

论文自己划了这条线:「它讲的是状态,不是系统沿途产生的那些发射(emissions)」。§6.1 把这条线展开成一对概念:

获取(acquisition)——拿资源并装一条记录在边界内:open 装一个描述符、malloc 占一块、fork 起一个子进程。记录本身是可回滚的效果。
发射(emission)——把数据通过这条通道推出去:write 交给文件、send 把数据报丢上网。这一步在形式上就是 idΓ,不跟踪、不回滚。

要弥补只能靠两样:把发射推迟到「产生它的状态确定会持久化」之后(即 rollback-recovery 里的 output commit 问题),或者用补偿(compensation)——删掉刚创建的文件、退款刚扣的钱。补偿和逆一样按 LIFO 复合,但定理不跟着走:独立性是对 ≃ 证的,换成一个更粗的「应用自己提供的等价」就必须重新证一遍。

4.4 四个扩展:每个都在代码里留了疤

论文 §4.4 给了四个扩展,而且明说「每一个都被 §5 的实现实装,并且都保持 §4.3 的结果不变」。这四个恰好是理论与工程摩擦最大的地方,值得逐条看。

扩展 1

异步:inertia(惯性)

代码里有

规则是同步的:一步里状态映射整体生效。但异步宿主里,迭代和逆都返回 future——在飞的映射不论你是否还需要它,都会跑完,于是 L-Divert 的「中止」那个备选分支根本不存在。论文给这类宿主起了名字:惯性(inertial)。

惯性的定义就是「L-Divert 只取落地那一支」:一个 fiber 的目标在迭代途中变了,它就等这一步落地,然后从 𝘜𝘯𝘭𝘰𝘢𝘥𝘪𝘯𝘨 状态、握着刚得到的那个逆,去卸载。论文强调:所有结果都是对所有序列量化的,所以自动涵盖惯性序列;而且 Theorem 73 的证明一次都没用到「中止」那一支,所以惯性宿主依然会静默。

另外两句话很关键:「逆在飞时不需要惯性的对应物」——规则从不拒绝一次卸载,而且别的 fiber 落在累加器应用期间的步,会和「尚未应用的逆」交换(靠 Definition 65 / Lemma 66 / 67),所以一个跨区间的卸载到达的状态与一步到位的卸载在 ≃K 下相同。「卸载可以直接链回装载」——累加器跑完之后无论目标变成什么,从 Inactive 又能立刻 L-Begin,这就是实现里 reload/unload 的相互链式。

代码:fiber.inertia 只有一个字段,但它是整个异步语义的开关 —— fiber.ts:197 声明、fiber.ts:629(if (this.inertia) return)是「转移在飞时不再启动新转移」、fiber.ts:669 / 692 是两条链式。
扩展 2

失败:FAILED 状态

代码里有

把迭代器细化成 Γ → 𝖤𝗂𝗍𝗁𝖾𝗋(Ξ, Γ × (Γ→Γ) × Maybe(ℑ)),见证只约束 Right 分支——raise 没有东西可撤。一次 raise 以「去掉目标视图前提的 L-Divert」路径离开 𝘙𝘦𝘭𝘰𝘢𝘥𝘪𝘯𝘨,带着到失败那一步为止的累加器进 𝘜𝘯𝘭𝘰𝘢𝘥𝘪𝘯𝘨,最后带着「什么都没装上」到达 Inactive(Corollary 69),并把错误记录在 fiber 上作为 outcome。

三个设计决定值得抄:① outcome 阻止重入——L-Begin 要求 fiber 无错误,所以「在未变的环境里不会重试」;② quiet 判定里,失败的 fiber 无论目标如何都算静默;③ 错误留在自己身上而不向父级传播,兄弟继续跑。

论文也诚实标注了代价:合流性把失败 fiber 排除在外,而且必须排除——「一次迭代是否 raise 取决于它遇到的状态,所以一个调度可能让某个 fiber 失败,而另一个调度让它成功,两个静默态就在这个 fiber 的生命周期状态上不同」。而按 Corollary 69,二者除了这一点之外没有别的差别。

代码:FiberState.FAILED(fiber.ts:145)、_reload() 的 catch 把 _error = reason; epoch = INACTIVE(fiber.ts:659-664)、_getState() 因 _error 直接返回 FAILED(fiber.ts:574-579)。注意 update() 会显式清掉 _error(fiber.ts:742, 750)——这就是「修订 = 重新插入且不带 outcome」。
扩展 3

隔离:把 realm 读成一个更大的键空间

论文自限 · 代码另有一套

论文给了一个很漂亮的技巧:把键空间从 K 换成 K × R,每个对 (k, r) 继承原本 k 的值集与操作集、继承它的可交换性见证;单源原则在「对」上读,就自动变成「同一个 realm 内不相交」。共享 realm 就是对角线 (k,k)。「键对规则而言和名字一样是原子:没有规则计算它、检视它的结构、或以相等之外的任何方式关联两个键」——所以 §4.3 的全部结果原封不动适用。

但这个读法止步于 isolate 本身:Definition 25 的 isolate 是在运行中的上下文上重新指派 ρ;而在配对读法下,重新指派等于把一个声明从一个对搬到另一个对,而 dn 和 pn 是「随条目写下就永不修改」的(Lemma 59(5))。所以「运行期 realm 发生变化的 fiber,其接口已经变了」——被归到「配置修订」那一类,不再是一条规则。

而 dsh 真的需要它。装载器的 isolate 选项支持把条目在组之间移动(true = 条目私有 realm,以 id 打标;string = 以该字符串命名的全局 realm),于是 vendor 里出现了一段论文没有的专门算法——用「分隔符(delimiter)」判断「这个绑定到底是不是这个条目自己的」:

论文 Algorithm 7 ↔ loader/src/config/isolate.ts:96-153:delims[name] ??= Symbol('delim:'+name) 就是 δk;entry.ctx[delim] = Symbol(`${name}#${entry.id}`) 就是「在条目上下文上写一个自己的标签,由后代继承」;论文式 (64) 的 γ′[δ_k] = d₁ ⟺ γ′ derived from entry's context 与代码里那个四元组 [symbol1, symbol2, flag1, flag2] 及其判定 (flag1 === flag3) !== (flag1 === flag2)(isolate.ts:140-145)逐字对应。
扩展 4

配置:修订 = 规则的复合

论文把它归入演算 · 代码另起一层

论文的处理很干脆:组件带配置,于是「同一个组件绑两份配置」就是两个不同的组件(Definition 48 的两个元素,效果函数不同)。声明式层允许编排器修订一个运行中的 fiber —— 换配置、重指派 realm、禁用后重新启用。每一次修订都是规则的复合:

  • 禁用 = 一次 O-Retire;
  • 其它任何修订 = 退休 → 让生命周期规则去激活 → 删条目(子先于父,满足 O-Remove)→ 用新的效果函数/realm 对/原组件在同一名字上重新插入;
  • 重启用必须走这个复合,而不是「写一个把 τ 改回 ⊥ 的规则」——理由有两条:① Theorem 80 依赖「被累加器退休的 fiber 保持退休」(Lemma 59(5));② Definition 53 不读父指针,所以一个在「实例化它的 fiber 已经跑完累加器」之后被取消退休的 fiber,会在创建者已经不在的情况下激活。

而复核被持有在终点而不是步骤上:由 Theorem 80,系统静默的位置和「从零装载修订后的配置」一样——而那个终点正是装载器那些「更短的路径」所答复的东西:新 payload 交给一个只在实质变化时才 reload 的组件、realm 搬家而不 reload 它的 provider。

代码:Entry.update()(loader/src/config/entry.ts:142-246)把这段话逐条落地了 —— 无 fiber → init();变 disabled → _dispose() 但保留条目;diff 不含 name/inject/group → _patchContext(diff)(就地);含则「先 import 新模块 → dispose 旧 → start 新」。disabled 分支正是「条目是修订中存活的身份,fiber 只是一次启用」的分工。

05 / 实现论文 §5 与 2,693 行源码的逐条对照

前面四节是论文说了什么。从这里开始是代码到底做了什么。我的口径是:凡是论文提到的机制,都在 ~/project/dsh-official/vendor/ 里找到落点,并给出文件:行号;凡是代码里有而论文没写的,单列出来。

5.0 一张对照表(论文 Table 2 的补全版)

论文自己给了一张 Theory ↔ Implementation 对照表(Table 2)。我把它补成三列,因为第三列和论文第二列并不总是一致——这本身是一个值得记录的发现。

理论 ↔ 论文所说的实现名 ↔ 仓库里真实存在的代码
理论(Section 3/4)论文 Table 2 的写法vendor/cordis 4.0.2 实际一致?
Γ∞ctxContext(Proxy 实例)context.ts:35一致
𝔈Γ / ℑΓ回调返回 / yield 出逆4 种形状:函数、Promise、同步 Iterable、异步 Iterablefiber.ts:366-398一致(且更宽)
effectΓ(e)ctx.effect(callback)Context.effect → Fiber.effectfiber.ts:418一致
Σctx[@@store]ReflectService.store(按 realm symbol 索引)+ fiber.store拆成了两张
Σisoctx[@@isolate]ctx[Context.isolate](原型链上的 symbol 映射)context.ts:121一致
Σinterctx[@@intercept]ctx[Context.intercept] + Service[symbols.resolveConfig]service.ts:86一致
⟨d,p,e,π,σ,τ,θ⟩fiberclass Fiberfiber.ts:184一致
dfiber.injectfiber.inject(Dict)一致
p组件的 provide没有声明式字段;由 ctx.provide() 调用动态决定reflect.ts:277只有运行时形态
e(效果函数)fiber.applyruntime.callback + fiber.config(没有 apply 字段)名字不存在
O-Insert/O-Retirectx.use + 回调的逆ctx.plugin() / registry.plugin()registry.ts:316名字不存在
θ 状态fiber.stateFiberState{PENDING,LOADING,ACTIVE,FAILED,DISPOSED,UNLOADING}fiber.ts:139-154一致(多 2 态)
g(累加器)fiber.disposefiber._disposables(DisposableList)+ 每个 effect 的 wrapper形态不同
ω(已提交视图)fiber.committedfiber.store(已发布快照)fiber.ts:193, 647名字不存在
target(γ,n)fiber.target(“一个 hash”)fiber._runner.epoch(provider uid 的拼接串)fiber.ts:611-623名字不存在 · 是拼接不是 hash
inertiafiber.inertiafiber.inertiafiber.ts:197一致
L-Begin/Iter/Finishexecute 的迭代循环_execute 的 asyncIterator 分支 + collectfiber.ts:383-395一致
L-Leaverefresh 把 fiber 标为 UNLOADING_setEpoch → _updateState 回调返回 UNLOADINGfiber.ts:625-639一致
L-Unloadunload 及其惯性链_unload()fiber.ts:675-696一致
守卫 ¬reliedunload 里 await 被通知的依赖者reflect.provide() 的 disposer 里 await Promise.allSettled(fibers.map(f => f.await()))reflect.ts:297-303一致
失败 outcome记录在 fiber 上的错误,target 置 ⊥_error + epoch=INACTIVE → FiberState.FAILEDfiber.ts:659-664没有显式设 target
关于这四行「名字不存在」

ctx.use、fiber.apply、fiber.committed、fiber.target 在 4.0.2 源码里一个都没有。仓库自带的生成式 API 目录(docs/cordis-api/fiber.md,由 scripts/gen-cordis-catalog.ts 从源码 JSDoc 生成)记的是 fiber.store / fiber.inertia / fiber.uid,用的是代码的名字。

两种解释:① 论文对着的是上游另一个命名世代(上游快照 cordiverse/cordis @ 56b3d4f7,而 dsh 这个 vendor 的 package.json 已到 4.0.2,vendor/README.md 的清单表还停留在 4.0.0-rc.7);② 作者为了行文统一做了重命名。论文 §5.1 明确宣称「下文用的是运行时名字」,所以①更可能。读论文的时候必须做这层名字翻译,否则在源码里会一个都对不上。

5.1 核心库:9 个文件、2,693 行,承载 81 条结果

先把体量摆清楚,这个比例本身就是结论的一部分。

vendor/cordis/src 全景(行数含注释)
文件行数对应论文关键实体
fiber.ts754§3.1 效果迭代器 · §4.1–4.2 生命周期 · §4.4 异步/失败FiberState、Fiber.effect/_execute/_checkImpl/_refresh/_setEpoch/_reload/_unload
reflect.ts418§3.2 get/set · §5.1.4 Proxy 访问ReflectService、Proxy handler、provide/notify、mixin/accessor
events.ts352§3.2.3 拦截的实现面5 种分发模式、internal/* 拦截点、listener 也是 effect
registry.ts337§4.1 注册表 · Definition 52 实例化RegistryService、Plugin.Runtime、Inject.resolve、uid 计数器
logger.ts270—(工程)LoggerService、Exporter、格式化
utils.ts287—(基础设施)DisposableList、symbols、getTraceable、composeError
context.ts146§3.3.1 统一上下文 · §3.2.3 派生实现Context、extend/isolate/intercept
service.ts115§3.2.3 拦截(Config 合并)Service 基类、resolveConfig、callable service
index.ts14—再导出
合计 2,693生态外围 loader 1,149 · hmr 612 · include 377 · schemastery 902 · cosmokit 477 · timer 147 · logger-console 145 · group 3 ⇒ vendored 全栈 ≈ 6,505 行

5.2 效果跟踪:ctx.effect 的 240 行

论文说得很简洁:「Cordis 里的每一次上下文变更都流经唯一的原语 ctx.effect:余效应提供、组件实例化、以及其它所有会改变上下文的操作,都归约为一次 ctx.effect 调用。」这一点在源码里是可以逐条验证的:

「所有变更都是 effect」的验证
操作实现是否 effect
ctx.provide(name, value)reflect.ts:278 → this.ctx.fiber.effect(...)是
ctx.accessor(name, opts)reflect.ts:346 → fiber.effect是
ctx.mixin(source, keys)reflect.ts:366 → fiber.effect(function* (){ yield accessor ... })是(生成器形态!)
ctx.on(name, listener)events.ts:256 → fiber.effect是
ctx.plugin(plugin)fiber.ts:265 → parent.fiber.effect(...)(子 fiber 的生命周期是父的一次效果)是
ctx.isolate / ctx.interceptcontext.ts:121/140 → extend(),只造原型链子对象否,派生实现
ctx.set(name, value)reflect.ts:254 → 直接改 impl.value,不通知否(见落差 3)

最后两行正是论文刻意设计的:派生实现「没有效果可跟踪、没有逆要跑」;而 ctx.set 的就地改写论文明确说了依赖者观察不到——「一个原地覆盖自己绑定的 provider 因此不被观察到;想要替换传播出去的组件,应当撤回绑定再重新装上。」代码完全一致:ReflectService.set 改完就返回,连 notify 都不调。

vendor/cordis/src/fiber.ts:356-398效果的四种形状与迭代器守卫
356  private _execute<T>(runner: EffectRunner<T>) {
357    const oldEpoch = runner.epoch
358    return composeError((info) => {
359      const safeCollect = (dispose: void | Disposable) => {
360        if (typeof dispose === 'function') {
361          runner.collect(dispose)
362        } else if (!isNullable(dispose)) {
363          throw new TypeError('Invalid effect')
364        }
365      }
366      const effect: Effect = runner.execute.call(this)
367      if (typeof effect === 'function') {
368        return runner.collect(effect)          // 𝔈Γ:直接返回一个逆
369      } else if (isNullable(effect)) {
370        // return                              // 无逆(纯查询式 effect)
371      } else if (!isObject(effect)) {
372        throw new TypeError('Invalid effect')
373      } else if ('then' in effect) {
374        return effect.then(safeCollect)        // Promise<Disposable>
375      } else if (Symbol.iterator in effect) {
376        info.error = new Error()
377        const iter = effect[Symbol.iterator]()  // ℑΓ:同步迭代器,一次跑到底
378        while (true) {
379          const result = iter.next()
380          safeCollect(result.value)
381          if (result.done) return
382        }
383      } else if (Symbol.asyncIterator in effect) {
384        const iter = effect[Symbol.asyncIterator]()
385        return (async () => {
386          // force async stack trace
387          await Promise.resolve()
388          info.error = new Error()
389          while (true) {
390            if (runner.epoch !== oldEpoch) return  // ← L-Divert 的实现
391            const result = await iter.next()
392            safeCollect(result.value)
393            if (result.done) return
394          }
395        })()
396      } else {
397        throw new TypeError('Invalid effect')
398      }
399    }, runner.getOuterStack)
400  }

390 行是整段代码里最重要的一行。论文 Algorithm 1 写作「每一步迭代前都咨询一个 caller-supplied guard;guard 一断,迭代就停,只剩已经累积的逆」。这里 oldEpoch 就是那个 guard:异步迭代器在每次 next() 之前对比当前 epoch 是否还是启动时那个。一旦依赖在迭代途中变了,循环直接返回——这正是 L-Divert 的「中止」那一支,与论文 Theorem 71(解析一致性)讲的「转场跨越的区间里检查目标」逐字对应。

注意它只对 asyncIterator 生效:同步迭代器(375-382)一口气跑完,没有暂停点,所以论文说「可中止的宿主」与「inertial 宿主」的区别在实现里体现为你写的是同步还是异步生成器。而 dsh 的 cordis 文档里也把 generator 当作一等形态(+ ctx.mixin() 自己就用了 function*)。

vendor/cordis/src/fiber.ts:418-442effect 的收集与逆序释放(每个 effect 内部)
418  effect(execute: () => Effect, label = 'anonymous'): any {
419    this.assertActive()
420    if (this.state === FiberState.UNLOADING) {
421      throw new CordisError('INACTIVE_EFFECT')
422    }
423
424    const disposables: Disposable[] = []
425    let disposing = false
426    let disposalTask: void | Promise<void>
427    const dispose = () => {
428      if (disposing) return disposalTask          // 幂等:重复调用只返回同一个 task
429      disposing = true
430      let task!: void | Promise<void>
431      for (const disposable of disposables.splice(0).reverse()) {
432        if (task) {
433          task = task.then(() => runDisposable(disposable))   // ← 严格 LIFO 串行
434        } else {
435          const result = runDisposable(disposable)
436          if (isObject(result) && 'then' in result) {
437            task = result as any
438          }
439        }
440      }
441      return disposalTask = task
442    }

431–433 是 Theorem 16 的实现:splice(0).reverse() 先清空再倒序,然后用 task.then(...) 把后续的逆串成链——只有当上一个逆 settle 之后,下一个才跑。这就是「反序撤销,于是每个逆拿到的正是它自己那次应用产生的状态」。

注意区分两个层级:这一段是「一个 effect 内部」的逆序;而 fiber 级别(_unload)是并发的,见 落差 2。420 行还体现了一条本地加固:卸载中不允许再创建 effect(把「清理期注册的新东西逃出卸载快照」这个洞焊死)。

05.3生命周期机器:一个字符串摘要 + 一个 Promise 字段

这是全文技术含量最集中的地方。论文用 Definition 49–55、Theorem 68–80 讲了十几页的状态机;代码里承担它的核心是五个函数、约 90 行。看懂这五个函数,你就看懂了整篇论文的工程形态。

vendor/cordis/src/fiber.ts:597-639依赖解析 → 目标摘要 → 状态转移
597  _checkImpl(name: string) {
598    const impl = this.ctx.reflect._getImpl(name, true)   // strict:只认 ACTIVE 的提供者
599    if (!impl) return delete this._store[name]
600    try {
601      if (impl.check && !impl.check.call(getTraceable(this.ctx, impl.value))) {
602        return delete this._store[name]                  // 可用性谓词(Service[Service.check])
603      }
604    } catch (error) {
605      impl.fiber.ctx.logger.error(error)
606      return delete this._store[name]
607    }
608    this._store[name] = impl
609  }
610
611  _refresh() {
612    let epoch: string | boolean = false
613    epoch = ''
614    for (const name of Object.keys(this.inject)) {
615      const impl = this._store[name]
616      if (!impl) {
617        epoch = INACTIVE                             // 有一个没齐 → 目标 = ⊥
618        break
619      }
620      epoch += ':' + impl.fiber.uid                  // ← target 摘要:提供者的身份
621    }
622    this._setEpoch(epoch)
623  }
624
625  private _setEpoch(epoch: string) {
626    const oldEpoch = this._runner.epoch
627    if (epoch === oldEpoch) return                     // 目标没动 → 什么都不做(neutral)
628    this._runner.epoch = epoch
629    if (this.inertia) return                           // ← 转移在飞:只记目标,不启动
630    this._updateState(() => {
631      if (epoch !== INACTIVE && oldEpoch === INACTIVE) {
632        this.inertia = this._reload()                  // L-Begin → LOADING
633        return FiberState.LOADING
634      } else {
635        this.inertia = this._unload()                  // L-Leave → UNLOADING
636        return FiberState.UNLOADING
637      }
638    })
639  }

611–623 就是论文 Definition 53 的 targetn(γ)。论文写:「实现把这个映射放在 fiber.committed,并在 fiber.target 里放它的一个 hash」;代码里则是 store 放映射、_runner.epoch 放「把每个依赖的提供者 uid 用冒号拼起来」的串。语义等价:uid 每次抽取都是新鲜的、永不复用,所以「换了个人提供」与「还是同一个人提供」在摘要上必然可区分,哪怕两者提供的是同一个值。

627 行的早退是「neutral 分类」的实现:目标没变就一律不动。这意味着一次依赖表的变动,只对真正相关的 fiber 产生转移——这正是 Definition 22 的三分类,只是把「分类」实现成了「比较字符串」。

629 行是 inertia。转移在飞时,新的目标只被记下(_runner.epoch = epoch),不启动新转移;等在飞的那个跑完,由 _reload/_unload 尾部再看一次 epoch,决定是收尾还是链到另一个方向。论文 §4.4 说得完全一样:「一个在迭代中目标被翻转的 fiber,在该迭代落地之后、从 UNLOADING 状态、握着它产出的那个逆去卸载」。

598 行的 strict=true 是关键细节:只有状态为 ACTIVE 的提供者才算数。对应论文 §5.1.2 的:「一个绑定只有在安装它的 fiber 处于 ACTIVE 时才对依赖者算可得……于是「撤回」对依赖者来说比「真的发生」早一步可见——进入 UNLOADING 的提供者已经停止供出,它的依赖者于是算出目标不可满足,在它的绑定还全都在原处的时候就开始自己的拆除。」

vendor/cordis/src/fiber.ts:646-696reload / unload:惯性链与提交视图
646  private async _reload() {
647    this.store = { ...this._store }                     // ← 提交视图(committed = resolve(inject))
648    const oldEpoch = this._runner.epoch
649    try {
650      await Promise.resolve()                          // 让出一次:期间可能已被作废
651      if (this._runner.epoch === oldEpoch) {
652        this.config = this._resolveConfig(this._config)
653        await this._execute(this._runner)              // 跑插件的 apply / effect 迭代
654        this._error = undefined
655      }
656    } catch (reason) {
657      this.ctx.logger.error(reason)                    // ← 失败被记录,而不是抛出
658      this._error = reason
659      this._runner.epoch = INACTIVE                    // target ← ⊥(§4.4 的 failure)
660    }
661    this._updateState(() => {
662      if (this._runner.epoch === oldEpoch) {
663        this.inertia = undefined                       // 目标未变 → 停在 ACTIVE
664      } else {
665        this.inertia = this._unload()                  // 否则链入卸载(惯性)
666        return FiberState.UNLOADING
667      }
668    })
669  }
670
675  private async _unload() {
676    await Promise.all(this._disposables.clear().map(async (dispose) => {
677      try {
678        await composeError(async (info) => {
679          await Promise.resolve()
680          info.error = new Error()
681          await runDisposable(dispose)
682        }, this._runner.getOuterStack)
683      } catch (reason) {
684        this.ctx.logger.error(reason)                  // ← 清理失败被吞,只记日志
685      }
686    }))
687    this.store = undefined                             // ← 丢弃已提交视图(L-Unload)
688    this._updateState(() => {
689      if (this._runner.epoch === INACTIVE) {
690        this.inertia = undefined
691      } else {
692        this.inertia = this._reload()                  // 目标又变成「有」→ 链回装载
693        return FiberState.LOADING
694      }
695    })
696  }

647 / 687 两行是两个「时刻」的全部实现:装载时先提交视图再执行效果(于是组件在运行期间读到的依赖,永远是它装载时那一份);卸载时跑完所有逆之后才丢弃视图(于是组件在拆除自己的过程中仍然读得到它的依赖)。论文 §5.1.3 说:「三条线承载了 Theorem 70 的余效应有序性,而每条线坐在哪里正是有序性成立的原因。」——指的就是这两行加刷新时的第 10 行(L-Leave)。

对偶的两条链式(665 / 692)是「重新装载」与「重新卸载」的相互递归,也就是 §4.4 说的「从 Inactive 可以立刻 L-Begin」与「家失目标时链路」。inertia 的存在保证了同一时刻至多一个转移,这正是「惯性」的形式定义。

656–659 是失败路径的完整实现:错误进 _error(→ 状态变 FAILED)、epoch 置 INACTIVE(→ 目标变 ⊥,不再重试)、且不向父级传播。与论文 §4.4 的 Failure 扩展逐条对齐。注意第 657 行「错误被 logger 吃掉」这个选择——它保证了兄弟不被打断,代价是一次失败的装载不会让任何调用者知道,除非有人 await fiber(await() 会重抛 _error,见 704-710)。

676 行的 Promise.all 是唯一一处与论文 Algorithm 1 的精神不完全一致的地方:论文的算法把逆按 value ∘ inverse 折成一条链(严格 LIFO 串行),而 fiber 级这里把整份列表同时启动。论文自己在 §5.1.3 的脚注里承认了这件事(「fiber.dispose 并发地启动一个 fiber 的各个效果」),但它在 §3.1.3/Theorem 16 里承诺的是反序。详见 落差 2。

论文 Algorithm 5 与代码的逐行对照
Algorithm 5 伪代码代码备注
refresh: target ← target(γ,n); if target = fiber.target then return_refresh() + _setEpoch 的 627 行早退目标用 epoch 摘要代替整张 map
if fiber.inertia then returnfiber.ts:629逐字对应
state ← UNLOADING(先于任何逆被调度)_updateState 回调同步返回 UNLOADING;逆真正开始跑要等 await Promise.resolve() 之后的微任务顺序保证成立
reload: fiber.committed ← resolve(fiber.inject)this.store = { ...this._store }(647)逐字对应
recover ← await execute(fiber.apply, () ↦ fiber.target = target₀)_execute(runner),其 guard 是 runner.epoch !== oldEpochguard 形态不同:一个是「目标是否仍是启动时的」,一个是「epoch 是否仍是启动时的」——同义
if fiber.target = target₀ then ACTIVE; notify(provided)662-664 停在 ACTIVE;服务本身由 provide() 在 effect 里注册时已经 notify通知时机不同
unload: await all(notify(...).map(f ↦ f.await()))不在 _unload 里,而在 provide() 的 disposer 里(reflect.ts:299-300)位置不同 · 语义相同
await fiber.dispose(); fiber.committed ← ⊥676-687一致
if fiber.target = ⊥ then INACTIVE else LOADING; reload688-695逐字对应

5.4 撤销守卫:14 行代码换一条定理

论文 Theorem 70(有序性)说的是:一个提供者只有等所有解析到它的依赖者都去激活之后,才撤回自己的绑定。这就是 §2 里「局部保证留下、等全局补上」的那一条。代码里它是这样落地的:

vendor/cordis/src/reflect.ts:277-336provide 的逆 = 先撤绑定、再通知依赖者、等它们全部卸载、最后才清理自己
277  provide(name: string, value?: any, check?: () => boolean) {
278    return this.ctx.fiber.effect(() => {
279      // …设 props / 取 realm symbol…
287      const key = this.ctx[symbols.isolate][name]
288      const impl: Impl = { name, value, fiber: this.ctx.fiber, check }
289      if (this.store[key]) {
290        throw new Error(`service "${name}" has been registered at <${this.store[key].fiber.name}>`)
291      }
292      this.store[key] = impl
293      this.ctx.fiber.store![name] = impl               // 先让自己看得见
294      if (this.ctx.fiber.state === FiberState.ACTIVE) {
295        this.notify([name])
296      }
297      return async () => {
298        delete this.store[key]                        // ① 停止供出(L-Leave 的效果)
299        const fibers = this.notify([name])            // ② 让依赖者重算目标 → 它们开始拆
300        await Promise.allSettled(fibers.map(fiber => fiber.await()))  // ③ 守卫:等它们拆完
301        // ensure self access before dependencies cleanup
302        delete this.ctx.fiber.store![name]            // ④ 最后才丢掉自己的视图条目
303      }
304    }, `ctx.provide(${JSON.stringify(name)})`)
305  }
306
314  notify(names: string[], filter = (ctx, name) => ctx[symbols.isolate][name] === this.ctx[symbols.isolate][name]) {
315    const fibers: Fiber[] = []
316    for (const runtime of this.ctx.registry.values()) {
317      for (const fiber of runtime.fibers) {
318        let hasUpdate = false
319        for (const name of names) {
320          if (!(name in fiber.inject)) continue      // 只碰声明了这个键的 fiber
321          if (!filter(fiber.ctx, name)) continue     // 只碰同一 realm 的
322          hasUpdate = true
323          fiber._checkImpl(name)                     // 重算这一个键的解析
324        }
325        if (!hasUpdate) continue
326        fiber._refresh()                             // 重算目标摘要 → 可能转移
327        fibers.push(fiber)
328      }
329    }
330    // …emit 'internal/service'…
335    return fibers
336  }

298–302 是论文 Theorem 70 的全部实现,而且四步顺序一个都不能换:

① 先 delete store[key] → 别人再也解析不到它(对应论文 𝜎γ 只并集活跃 fiber 的表);
② 再 notify → 依赖者算出目标不可满足,进入各自的卸载;
③ 再 await 依赖者全部 settle → 这就是 ¬reliedn(γ) 那个守卫;
④ 最后才删自己的视图条目 → 保证「我自己在拆除过程中还读得到我的依赖」(注释原文:ensure self access before dependencies cleanup)。

而 notify 的 filter(314 行的默认参数)正是论文强调的那个「按绑定而非按 fiber」的读法:只有「声明的键解析到同一个 realm」的依赖者才被算作依赖我。论文原文:「reliedn(γ) 测试的是某个已提交视图是否指向 n,所以一个没声明 n 的任何一个键的 fiber 不是障碍,在另一个 realm 里解析了 n 的键的 fiber 也不是。」

300 行的放置位置论文专门解释过:这个等待必须坐在整个恢复之前,而不是坐在「被等待的某一个逆里面」——「因为 fiber.dispose 并发地启动一个 fiber 的各个效果,把等待放进其中一个逆里会让其余逆失去顺序。」这正是 落差 2 那个并发清理的成因:等待必须在外面,才能覆盖里面那堆并发。

这段代码解释了一个反直觉的现象

为什么 Cordis 里「卸载一个 provider」会感觉慢?因为它不是一步:卸载是沿依赖图逐层、串行地展开的。这正是 Theorem 73 里那个界 S(n) ≤ (K+3)(V(n)+1) 的现实形态。

而它为什么不会死锁?论文的论证是:一个 fiber 一旦进入 𝘜𝘯𝘭𝘰𝘢𝘥𝘪𝘯𝘨 就从 σγ 里消失,于是没有任何目标视图还能指向它——代码里,UNLOADING 状态让 _getImpl(name, strict=true) 直接返回 undefined(reflect.ts:241),所以依赖者重算时必然失败,必然也走上卸载路。等待图因此必然消解。这个「严格模式」看起来只是个 getter 参数,其实是整个无死锁证明的支点。

05.5装载器:论文 §5.2 的三条承诺,代码逐条对账

论文对第 5.2 节的承诺是三层:① 声明式配置 + 配置协调;② 热模块替换;③ 二者都建立在 core 的原语上(「它们都是普通组件,所以嵌套树留在演算之内」)。这三层的代码分别在 vendor/loader(1,149 行)、vendor/hmr(612 行)、vendor/include(377 行)。

A. 协调:diff 在哪一层、什么改什么

先纠正一个可能的误读。「配置协调」不是把新配置 merge 进插件内部状态,而是:在条目(Entry)层做键级 diff,然后按「改了哪个字段」选一种破坏性最小的动作。这是所有细节的分水岭。

vendor/loader/src/config/entry.ts:142-160 / 194-246diff 与四条分支(节选)
142  async update(options: Partial<EntryOptions>, create = false, force = false) {
143    const previousOptions = this.options
144    const legacy = { ...previousOptions }
145    const candidate = create ? options as EntryOptions : { ...previousOptions }
146    if (!create) {
147      for (const [key, value] of Object.entries(options)) {
148        if (isNullable(value)) {
149          delete candidate[key as keyof EntryOptions]      // 显式置空 = 删除该字段
150        } else {
151          candidate[key as keyof EntryOptions] = value as never
152        }
153      }
154    }
155    sortKeys(candidate)
156
157    const diff = Object
158      .keys({ ...candidate, ...legacy })
159      .filter(key => !deepEqual(candidate[key], legacy[key]))      // ← 唯一的 diff 判据
160    if (!diff.length && !force) return                          // 空 diff = 完全 no-op
...
194    const replace = diff.some(key => key === 'name' || key === 'inject' || key === 'group')
195    if (!replace) {                                              // ① 就地:不重新 import 模块
196      this.options = candidate
197      try {
198        await this._patchContext(diff)
199      } catch (error) {
200        this.options = previousOptions                        // ← 回滚:恢复旧 options
201        try {
202          await this._patchContext(diff)                      // ← 再把旧配置 patch 回去
203        } catch (rollbackError) {
204          throw updateError('rollback', legacy, new AggregateError([error, rollbackError]))
205        }
206        this.context.emit('loader/partial-dispose', this, candidate, true)
207        throw updateError('apply', candidate, error)
208      }
...
214    let plugin: any
215    try {
216      plugin = diff.includes('name')
217        ? this.loader.unwrapExports(await this.parent.tree.import(candidate.name, ...))  // ② 先 import 新的
218        : previous.runtime!.callback
219    } catch (error) { throw updateError('import', candidate, error) }
220
223    const previousPlugin = previous.runtime!.callback
224    this.options = candidate
226    await this._dispose(previous)                              // ③ 再 dispose 旧的
232    try {
233      await this._start(plugin)                                // ④ 最后 start 新的
234    } catch (error) {
235      this.options = previousOptions
237      await this._start(previousPlugin)                        // ← 失败则用旧插件重建
241      this.context.emit('loader/partial-dispose', this, candidate, true)
242      throw updateError('apply', candidate, error)
243    }

②③④ 的顺序是 vendor 日志里专门记录的一条本地加固:「Loader imports a changed entry name before disposal, awaits lifecycle settlement, and restores the previous plugin or config when candidate application fails」。先 import 再 dispose 的理由很实在:如果新模块语法有错,你还没把旧的那个拆掉,系统仍可用。这个顺序在论文的演算里没有对应规则(演算里没有「编译期」),所以它是纯工程增量。

四种错误阶段被编码进错误消息(import / dispose / apply / rollback,entry.ts:24-27)——这让「失败在哪一步」在日志里可判定,也是后面 落差 讨论的依据。

但请注意「就地」的真实含义。_patchContext(entry.ts:114-122)在 diff 含 config 时会调用 this.fiber.update(config, true),而 Fiber.update 最终走的是 restart()——卸载全部 effect 再重跑插件回调。「就地」保住的只是 Entry 与 Fiber 对象的身份(测试 config-reload.spec.ts:147-161 断言的正是 entry.fiber === fiber),不是插件内部状态。论文 §5.2.1 那句「交给组件自己决定如何应用新 payload,通常是对比新旧再决定是否重载」在代码里只体现为 Entry 层的 deepEqual。

论文 §5.2.1 那张「按字段分流」的表 ↔ 代码
字段论文承诺代码一致?
id, url重建条目(身份或组件变了)diff 含 name → 走 replace 分支(entry.ts:194)是
isolate重指派 realm(Algorithm 7)loader/patch-context 里的 diff + delimiter 判定(isolate.ts:96-153)逐行对应
intercept就地更新,因为元数据是读时查的,不需要 reloadswap(entry.ctx[Context.intercept], options.intercept)(isolate.ts:126),不触发 fiber 重启是
config交给组件,组件自己决定fiber.update() → internal/update waterfall → restart()半是(见上)
disabled置位时卸载,清除时重新装载entry.ts:181-192(只 dispose,条目保留)与 paper 的 O-Retire + 重插入复合完全同构是
group 的 config按子 id 做 keyed diff,递归下钻Group.update(group.ts:59-106):oldMap/newMap + create/remove是
vendor/loader/src/config/group.ts:70-105组的事务更新 = Theorem 80「终点与顺序无关」的工程实现
 70    try {
 71      const outcomes = await Promise.allSettled(config.map(options => this.create(options)))
 72      // Disposal owns termination: sibling starts can still be settling after
 73      // the containing tree has gone away, but their failures no longer
 74      // describe a live update to roll back.
 75      if (this.ctx.fiber.uid === null) return
 76      const failures = outcomes.filter(o => o.status === 'rejected').map(o => o.reason)
 77      if (failures.length === 1) throw failures[0]
 78      if (failures.length > 1) throw new AggregateError(failures, 'loader entries failed to apply')
 81      for (const id of Object.keys(oldMap)) {
 82        if (!newMap[id]) await this.remove(id, true)      // 全部成功后,才移除消失的条目
 83      }
 84      this.data = config
 85    } catch (error) {
 86      const rollbackErrors: unknown[] = []
 87      for (const id of Object.keys(newMap).reverse()) {
 88        if (oldMap[id]) continue
 89        await this.remove(id, true)                       // 逆序删掉新增的
 95      for (const options of oldConfig) {
 96        await this.create(options)                        // 按旧顺序重建旧的
102      this.data = oldConfig

候选条目并发启动(71),全部成功才移除旧条目(82),失败先逆序删新增再重建旧的(87-96),最后才提交 this.data(102)。这正是论文说的:「装载模块可以并发进行,因为依赖限制的是 fiber 何时激活,而不是 模块何时被抓取和求值」——「一个声明了尚未提供的键的 fiber,会在它的 L-Begin 处等待」。

而那句「Disposal owns termination」(72-75)是纯工程补丁:如果整个树在启动途中已经被卸载了,兄弟条目的失败就不再描述一次活着的更新,不该触发回滚。演算里不会出现这种情形,因为它没有「异步启动到一半,宿主已经没了」这种时刻。

B. realm 重指派:论文 Algorithm 7 与 40 行实现

这段是全篇最「论文式」的代码——因为它真的是照着一个带公式的算法写出来的。论文用「分隔符 δk」回答了一个朴素 diff 回答不了的问题:同一个 realm symbol 可能被好几个 fiber 共享,其中只有一个才是提供者;当我搬迁一个条目时,那个绑定到底该不该跟着搬?

vendor/loader/src/config/isolate.ts:103-145分隔符判定(= 论文式 (64))与依赖者通知
103    // step 2: generate service diff
104    const diff: Dict<[symbol, symbol, symbol, symbol]> = Object.create(null)
105    const oldMap = entry.ctx[Context.isolate]
106    for (const name in { ...newMap, ...delims }) {
107      if (newMap[name] === oldMap[name]) continue
108      const delim = delims[name] ??= Symbol(`delim:${name}`)        // ← δ_k
109      entry.ctx[delim] = Symbol(`${name}#${entry.id}`)              // ← 写一个条目自己的标签
110      for (const symbol of [oldMap[name], newMap[name]]) {
111        const impl = symbol && entry.ctx.reflect.store[symbol]
112        if (!impl) continue
113        if (!impl.fiber) { entry.ctx.logger.warn(...); continue }
117        diff[name] = [oldMap[name], newMap[name], entry.ctx[delim], impl.fiber.ctx[delim]]  // (s₁,s₂,d₁,d₂)
118        if (entry.ctx[delim] !== impl.fiber.ctx[delim]) break
119      }
120    }
132    for (const [symbol1, symbol2, flag1, flag2] of Object.values(diff)) {
133      if (flag1 === flag2 && entry.ctx.reflect.store[symbol1] && !entry.ctx.reflect.store[symbol2]) {
134        entry.ctx.reflect.store[symbol2] = entry.ctx.reflect.store[symbol1]   // 把这个绑定搬过去
135        delete entry.ctx.reflect.store[symbol1]
136      }
137    }
140    ctx.reflect.notify(Object.keys(diff), (ctx, name) => {
141      const [symbol1, symbol2, flag1, flag2] = diff[name]
142      const symbol3 = ctx[Context.isolate][name]
143      const flag3 = ctx[delims[name]]
144      return (symbol1 === symbol3 || symbol2 === symbol3) && (flag1 === flag3) !== (flag1 === flag2)
145    })

论文式 (64):γ′[δ_k] = d₁ ⟺ γ′ 由该条目的上下文派生。代码里 flag1 / flag2 就是论文里的 d₁ / d₂(条目自己的标签与提供者的标签),flag3 是某个候选依赖者继承到的标签。133 行「两个标签相等 ⇒ 这个绑定是条目自己的,于是搬迁」;144 行「依赖者要么本来就在新 realm,要么本来就在旧 realm,而且『它是否属于这个条目』的判定在两个 realm 下不同 ⇒ 它真的受这次搬迁影响,需要通知」。

这段代码值得单独记住的地方是:它是一个「用 symbol 身份而不是用值比较」来判断所有权的技巧。标签不是数据、不进配置、不参与序列化,只在运行期被 Object.create 的原型链继承——一次赋值就把「谁的后代」这件事编码进了 JS 的原型继承语义里。论文对它的评价是:「一次重指派里,满足 own 的上下文从 s₁ 移到 s₂,其他的留在原地。」

C. 热模块替换:论文十行伪代码,代码 150 行

论文 §5.2.2 的立论是:「因为一个 fiber 已经把它组件的所有效果与余效应都圈住了,所以一个本身就是组件的模块,可以只靠 fiber 操作被替换:dispose 旧 fiber 恢复一切,从重载后的模块实例化一个新 fiber 重新装上。HMR 因此不需要开发者标注的接受边界(acceptance boundary),这与 Webpack/Vite 不同。」

「不需要标注接受边界」的实现方式很聪明:接受边界从模块图里自动推出来。算法是三步:

Phase 1 · classify从「内容变了的文件」出发,沿 import 图反向传播:一个模块只要有一个 import 被接受,它就被接受;一个模块的所有 import 都被拒绝,它就被拒绝。剩下的(比如陷在循环里的)默认拒绝。
→
Phase 2 · detect把每个 loader 条目的入口模块的传递依赖闭包收集起来(遇到 declined 就停下);闭包与 accepted 相交的条目就是「陈旧条目」。
→
Phase 3 · reload清掉 accepted 模块的缓存(ESM 与 CJS 两份,先把被删掉的备份下来),重新 import,逐个换上新 fiber。任何一步失败就回滚缓存与旧插件。
论文 Algorithm 8–10 ↔ vendor/hmr
论文代码备注
Algorithm 8 classify(stashed, externals)analyzeChanges()hmr/src/index.ts:345-398用 getLinked(url)(模块的 import 目标)做图遍历,与伪代码同构
Algorithm 9 detect / get_dependenciespartialReload()hmr/src/index.ts:400-443粒度是 loader 条目(nameMap 来自 ctx.loader.entries()),不是「组件」
Algorithm 10 invalidate_caches → backupesmBackup / cjsBackuphmr/src/index.ts:461-489论文脚注 3 提到「ESM 与 CJS 两套缓存都要清」;代码里的注释比论文更细:Node 24 的 LoadCache.delete 只把类型槽置 undefined,所以必须用 Map.prototype.delete.call 绕过
catch: restore_caches + 用 backup[url] 重建rollback() + reload(旧 plugin, 旧 runtime)hmr/src/index.ts:482-545一致,并且每个 fiber 用 oldFiber._config 原样重建(保证重载后 config 不丢)
(论文未提)防自触发主 watcher ignoreInitial: truehmr/src/index.ts:239;registerConfig 的 ignoreInitial: false:147代码有 · 论文无 见 落差 7
(论文未提)前置条件构造时要求 ctx.loader.internal,否则抛 '--expose-internals is required for HMR service'hmr/src/index.ts:118-125代码有 · 论文无:HMR 要摸 Node 内部模块加载器
(论文未提)framework 文件变更命中 externals → loader.exit(),而 Loader.exit() 默认是空函数loader/src/index.ts:187-189代码有 · 论文无:框架自己改了要整进程重启,且默认没人实现
HMR 的边界(论文没写,代码写明)

① 它只重挂「装载器条目」。用 ctx.plugin(fn) 在代码里程序式注册的插件不在 ctx.loader.entries() 里,HMR 不会重建它们,只会发一个 hmr/change 事件(hmr/src/index.ts:270)。

② 它需要能摸到 Node 内部 loader(--expose-internals 或 node-addon-require-builtin),否则构造直接抛错。

③ 只有 change 事件才触发热替换;新增/删除文件不会触发挂载或卸载(hmr/src/index.ts:256)。

④ 没有时间戳比较,去抖靠 debounce(默认 100ms)+ stashed 集合 + 内容相等早退;失败时 stashed 保留,于是下一轮会重试——这既是重试机制,也是「失败会一直重试到成功」这个行为没有上限的原因。

D. Include:文件 → 条目树,以及那条死了的只读分支

文件到组件树的映射规则很硬:

  • path 相对 ctx.baseUrl 解析;扩展名只接受 .yaml / .yml / .json(include/src/index.ts:198-201);
  • 文件内容必须是顶层数组,数组元素就是条目(:261-263);
  • Include 子树的 baseUrl 被改写成配置文件所在目录(:204),所以条目里的相对路径相对配置文件解析;
  • group: true 的条目其 config 又是子条目数组,由此形成嵌套树;嵌套 id 用 : 拼接(loader/src/config/tree.ts:8);
  • initial 只在首次 read 遇到 ENOENT 时写盘并重读(:273-289)。

而配置覆盖层(patch)的语义被单独抽成了一个纯函数,因为 dsh 的 --dump-config 必须打印与真正挂载完全一致的结果:

一个可以当范本的设计

vendor 日志第 11 条:把 patch 算法的函数体原样导出为 applyEntryPatches(data, patches, warn),理由写在注释里——「配置工具绝不能重新实现(并因此漂移)patch 算法」。

同时它修了一个论文级的小 bug:「patch 列表是一层一源地复合的(每个 bundle 一层,然后用户的,然后 --patch 覆盖层),而一层必须能够配置或禁用一个更早的层插入的行;上游在 patch 循环之前只建一次 id 索引,于是被插入的行静默地不可 patch。」修法是:每插入一批就 buildMap(insert) 一次(include/src/index.ts:101)。

这是一个很好的例子:论文层面的「声明式配置」在工程层面的真实难点,不是协调算法,而是标识与索引的时机。

另外有一处死代码值得记录,因为它说明了「代码没有论文那么干净」:

include/src/index.ts:199-203 —— 构造函数已经拒绝了非白名单扩展,所以 this.type 恒为真、this.readonly 恒为 false;于是 read() 里那个「用 import() 读任意模块」的分支(:255-257)不可达。也就是说:注释里暗示的「文件可写时才写回」在实际实现里等价于「永远可写」。

05.7DSH 怎么用它:一个把自己的插件树交给模型改的 harness

论文 §1.2.2 把「会自己改自己的 agent harness」写成未来动机,并把它列为 §8 的 future work。而 dsh 的仓库里,这件事已经是默认能力。这一节看四件事:体量、机制、模型接口,以及它为什么必须打补丁。

A. 体量:所有东西都是 Cordis 插件

dsh 与 cordis 的关系(数字口径:仓库工作副本 0.1.5-rc.2)
框架层vendor/ 9 个包、约 6,505 行源码(核心 2,693);全部源码 vendor 而非 npm 依赖
产品层packages/ 下 51 个一级目录、1,595 个 .ts 源文件、约 297,142 行
耦合面1,635 处 from '@deepseek-ai/cordis'(口径:packages/ 与 apps/ 下的 .ts/.tsx/.mts,排除 node_modules 与构建产物,含测试)。符号高度收敛:Context 出现在 1,574 处 import 里(多数还是 import type),Service 162、Fiber 42、FiberState 19
编译期接线tsconfig.base.json 的 paths 把 @deepseek-ai/cordis 直接指到 源码目录 ./vendor/cordis/src——不做构建即可调试框架本体
一致性门禁桌面端 smoke 脚本断言「不会加载出第二个 Cordis 实例」(ctx instanceof Context);verify-vendored-links 断言没有任何包被从 npm 拉进来

论文 §5.3 用 Koishi(4000+ 社区插件)做案例,论点是「表达力 + 通用性」。dsh 提供了第二个、而且是更极端的案例:Koishi 的插件是人写的,dsh 的插件是模型在会话里现写的。

B. 机制:动态双半边的插件

dsh 把「模型写一个插件并装进正在运行的系统」做成了四个包的流水线。它们的接缝设计值得单独看,因为它体现了「动态组合」在跨进程/跨运行时时的全部麻烦。

四个 Cordis 扩展包
包体量半边职责
cordis-host-runner3,355Host / Node动态包的登记处、node:vm 沙箱、host-half fiber 生命周期、12 个 @Remote 方法、调用处理器表
cordis-client-runner6,090Client / 浏览器接 host 的 run 请求、求值并挂载 client-half、跨页审批、浏览器侧 Timer Service、client 侧 inspect 目录
tool-cordis7,826Host / 模型面向7 个模型工具(3 个只读 inspect + 4 个生命周期)、系统提示段、@pluginId 上下文注入
ui-cordis2,461Client / 浏览器帧级 Cordis 面板、工具卡片、tool.view.cordis 业务视图槽、@pluginId 输入补全

模型看到的循环

① 查cordis_inspect_list / cordis_inspect_query / cordis_inspect_self 读活的服务方法表、事件模式、工具 schema、槽树
→
② 定义cordis_define 登记 host/client 两段源码。只登记不运行;id 由前缀 + 单调序号铸造,永不复用
→
③ 装载cordis_run:先起 host half;若含 client half 则要一次人类审批(单勾授权当前 package,双勾授权该插件的后续版本)
→
④ 收cordis_stop / cordis_undefine。停止 = fiber.dispose(),不需要任何 helper

三处与论文直接咬合的设计

能力中介 沙箱里传给插件的 ctx 是一个 Proxy 门面,白名单只有 effect / on / once / provide / timeout / interval / throttle / debounce(guard.ts:636)。访问一个没在 inject 里声明的服务会被拒绝并附带教学文案:「把它声明进 inject,这样当 provider 消失时 cordis 会让这个包 park」(guard.ts:723-735)。
这几乎是论文 §6.3「Capability-based access control」的逐字实现:「inject 声明充当能力请求,而上下文代理充当能力中介。因为这些请求是静态声明的,组件所需的全部代理中介能力在它运行之前就已知,让编排器可以在装载时审查批准,而不是在访问发生时才发现。」
派生实现的边界 门面还把「服务方法返回一个 Context」当场拒绝(guard.ts:669-678)——这是对 Definition 23「派生实现」在安全上的补丁:如果子组件能拿到父上下文,它就能绕过自己的生命周期去装效果。论文 §6.7 把这称为「库式实现的固有弱点」:「一个组件可能通过闭包或全局变量碰到另一个组件的上下文;它装在那里的效果就泄漏出了自己的生命周期。」
为什么需要审批 因为论文 §6.3 的第二半说得明白:「当一个组件的代码不可信时,语言级访问控制是不够的,因为一个恶意组件只要拿到宿主运行时就能直接触到下面的对象,让这些检查形同虚设。」 dsh 的选择是把「审批」放在装载路径上,并把沙箱明确声明为协作边界而非安全边界(host-runner README 原文:“the sandbox isolates globals but is not a security boundary”)。

一个漂亮的细节:模型的 @pluginId 上下文注入

当用户消息里出现 @abcde-1 这种插件 id 时,tool-cordis 在 agent/pre-step 的 waterfall 里动态注入一条 user message,内容是「先 cordis_inspect_self,再用 cordis_define plugin.kind="existing",最后 cordis_run mode="update"」的操作指引;如果那个 id 已经不存在,注入的是明确的「不要静默新建替身」(tool-cordis/src/index.ts:384-401, 511-532)。

这在论文的语汇里是什么? 是「余效应规格」在人机界面上的投影:用户用 @id 声明「我要这个上下文」,系统把这个声明解析成一段真实的上下文,再交给模型。论文只讨论了组件之间的依赖声明,没有讨论「人和模型之间的依赖声明」——但这恰好是这套机制能自然长出来的东西。

C. 为什么必须打补丁:19 条本地修改

这是我认为整篇分析里信息密度最高的一块证据。dsh 的 vendor/README.md 维护着一份穷尽的偏离清单(协议要求:每一次偏离上游都必须登记),共 19 条。其中至少 8 条直接落在本文讨论的语义上:

与「可回滚/依赖/生命周期/热替换」直接相关的本地修改
#改动它补的是一个什么样的洞
6fiber.ts 生命周期加固(7 处)重入释放的缺口:effect 的 wrapper 必须在 setup 体之前登记(否则在 setup 内部发起的卸载看不到它);同步 setup 失败要移除 wrapper 并回滚已收集的清理;异步清理要一直对 owner 可见直到静止;卸载中禁止创建新 effect;子 fiber 必须在 internal/plugin 广播之前就注册好父级持有的 disposer(否则一个同步观察者可以在此刻 dispose 掉父或子);「重入卸载在第一个检查点之前就把这次装载作废,就不要执行插件代码」。
8Loader/Include 事务化协调改名的条目先 import 新模块、再 dispose 旧的;候选失败要恢复旧插件或旧配置;Group 的更新要并发启动、等全部结果、对兄弟失败负责、在活更新失败时撤销改动与新增、等移除完成、只在成功之后才落盘。
9HMR 精确配置监听对「父目录还不存在」的配置路径要 realpath 最深已存在祖先、并在注册时就不漏掉必须立刻生效的用户补丁层。
11patch 语义导出 + 插入行索引被 insert 进来的行必须能被同一个 patch 列表里更靠后的 patch 命中(上游只建一次索引,于是这些行静默不可 patch)。
12子树的串行变异 + HMR 初始扫描抑制一次真实的 exit 13 崩溃:序列化之前,失败的最初 apply 触发的回滚会 dispose 掉 HMR,而 HMR 的拆除又等待排在同一个 apply 后面的 refresh —— 互相等待,进程静默退出,没有任何诊断。修法是主 watcher 加 ignoreInitial: true。
14持久化的去抖写盘写放大与瞬态文件系统错误(Windows 的 EACCES/EBUSY/EPERM)需要串行 + 有界重试。
15懒配置解析config 的求真值要推迟到「依赖已激活、且能对这个插件上下文求值」的时候;HMR 重建时必须携带原始 config。
18/19disabled 表达式插值 · Node 内部 loader 形状探测条件化组合要用表达式;而 Node 22–24 的内部 loader 在两个大版本之间换过 API,按「拥有哪个方法」判断而不是按版本号判断。
这张表的读法

它不是说理论错了。它说的是:论文的演算把一个「同步、单线程、无重入、无 I/O 失败」的世界形式化得很完整;而真实宿主是异步、可重入、会失败、有文件系统语义的。论文确实开了异步(惯性)与失败(FAILED)两个口子,但那两个口子没有覆盖重入——第 6 条里那些「在 setup 内部发起卸载」「同步观察者在广播点 dispose 父或子」「在第一个检查点之前就被作废」都是重入现象,在演算里没有对应的规则,因为它们要求「一步之内再发一步」。

所以最准确的评价是:Cordis 的定理给出了一个正确设计的骨架,而把骨架接到真实宿主上,是要靠工程去补的一块块木板。值得学的是 dsh 把这些木板都登记在案——一份穷尽的、带理由的偏离日志,比一百条注释都有用。

05.8实战:一个真实插件的一生(tool-cordis)

前面都是机制。这一节把一个真实的 dsh 插件从配置文件里的一行,走到它被卸载、依赖回来又自己复活的全过程。选 tool-cordis 是因为它同时用到了这一套的每一种能力:声明依赖、提供注册、监听事件、以及「依赖不在时安静地等待」。

tool-cordis 的四个声明与它们的性质
代码论文里的东西运行期后果
export const inject = ['tools','systemPrompt','dynamicCordisRunner','cordisInspect']余效应规格 d ⊆ K(Definition 21)四个键没齐之前,这个插件一行代码都不跑;而且它会被登记为这四个键的依赖者,任何变化都会重算它的目标视图
ctx.systemPrompt.section({...})效果(带回滚)提示词段跟着 fiber 的生死走
ctx.effect(() => ctx.cordisInspect.register(provider), label)𝔈Γ / ℑΓ把「注册一个 inspect provider」这件事变成一次可撤销的效果
ctx.tools.register(defineTool({...})) × 7效果 + 服务多路复用(broker,§6.2)7 个工具挂在 ctx.tools 这一个键上;每个注册各自可撤销
ctx.on('agent/pre-step', handler)监听器也是效果agent 每走一步都会问到它,直到插件卸载

九个小时刻

一个插件的完整生命线,以及每一步对应论文的哪一条
#发生了什么规则代码
1配置层的一行条目(id / name / config)。注意 tool-cordis 默认不装:没有任何 shipped bundle 挂它,要用得自己往 patch 里加一行。Definition 81packages/extensions/tool-cordis/README.md:28
2装载器 import 模块 → ctx.plugin(plugin, config) → 分配 uid、从父上下文派生自己的子上下文、状态 PENDING、把四个键写进 fiber.inject。Definition 52(O-Insert)registry.ts:316-336 · fiber.ts:234-245
3对每个声明的键做一次解析:_checkImpl(name) 只在提供者 ACTIVE 时把它写进草稿表。四个键分别由 base bundle 与 cordis-host-runner 提供。Definition 53(provider 关系)fiber.ts:597-609
4算目标摘要 epoch = ':uid₁:uid₂:uid₃:uid₄',与已提交的比:初始是 INACTIVE → 触发装载。Definition 53(target)fiber.ts:611-639
5先提交视图,再执行插件:store = {..._store} 之后才调用 apply(ctx)。于是插件整个生命期内读到的依赖,永远是它装载时那一份。Theorem 70(有序性的一半)fiber.ts:647
6apply 里的每一次注册都落到 ctx.effect,返回的逆被收进 fiber._disposables。插件作者一行清理代码都不用写。ℑΓ 与 Definition 18见下
7装载完成,状态 ACTIVE;_updateState 检测到跨过 ACTIVE 边界,于是 notify 它提供的键(这里是空集,但它消费的键的服务方会这样通知它)。Definition 22(activating)fiber.ts:581-595
8运行期:模型通过 cordis_define / cordis_run 挂新插件;新 fiber 的父是 host-runner 里那个 cordis-dynamic group fiber —— 子 fiber 是父的一次效果,所以卸载 group 会级联清空。Definition 52(实例化)cordis-host-runner/src/index.ts:1237-1240
9某个被依赖的服务撤销 → notify → 这个插件的 epoch 变 INACTIVE → L-Leave(先停止供出)→ 跑掉全部逆 → 状态回到 PENDING(不是 DISPOSED)。依赖回来时它会自己重新装载。Definition 22(deactivating)+ Corollary 69fiber.ts:625-696

第 9 步这件事在 dsh 里有专门的测试断言,标题就是论文那句话的白话版:

来自 dsh 测试契约(逐字)

it('stopping the provider sends the consumer back to pending and unwinds its registrations', …)
→ Assertion: 停止 provider 之后,ctx.tools.get('greet') 与 ctx.get('greeter') 都变成 undefined。

位置:packages/extensions/cordis-host-runner/tests/composition.spec.ts:59。「回到 pending」而不是「死掉」,正是余效应模型与普通 DI 的分水岭。

第 6 步长什么样:三次下钻,回到 ctx.effect

插件里只写了一行 ctx.tools.register(defineTool({...}))。这行调用穿了三次,最后落在 Cordis 的效果原语上——而中间那层本身就是用生成器效果写的,这是这套模型在生产代码里最漂亮的一处自证:

packages/core/scope/src/store.ts:226-263dsh 自己的分层存储:一次注册 = 一个生成器效果
226  effect(
227    ctx: Context,
228    action: (layer: L) => () => void,
229    options: { label: string; notify?: boolean },
230  ): () => void {
231    const scope = scopeOf(ctx)
232    const notify = options.notify ?? true
233    const dispose = ctx.effect(function* (this: ScopedLayers<L>) {   // ← ℑΓ:一个效果迭代器
234      let layer: L
235      let created = false
236      if (scope === undefined) {
237        layer = this.global
238      } else {
239        const existing = this.scoped.get(scope)
240        if (existing === undefined) {
241          layer = this.createLayer(scope)      // 阶段一:按需创建层(副作用)
242          this.scoped.set(scope, layer)
243          created = true
244        } else { layer = existing }
245      }
246
247      let undo: () => void
248      try {
249        undo = action(layer)                     // 阶段二:真正的注册,拿回 undo
250      } catch (error) {
251        if (scope !== undefined && created && layer.isEmpty()) this.scoped.delete(scope)
252        throw error                              // 失败就地回滚自己刚造的东西
253      }
254
255      yield () => {                              // ← 把「逆」交还给运行时
256        undo()
257        if (scope !== undefined && layer.isEmpty()) this.scoped.delete(scope)
258        if (notify) this.onChange()
259      }
260      if (notify) this.onChange()
261    }.bind(this), options.label)
262    return dispose
263  }

这段代码几乎是论文 §3.1.1 与 §3.1.3 的逐条实现:创建与撤销写在同一个迭代里(关注点局部性);逆用 yield 交回(Definition 17 的 Just(逆));失败时自己把刚创建的空层删掉(Corollary 69 的「终止恢复」在下一层的体现);而 notify 通知依赖者——注意它先 yield 逆、后 onChange,顺序不是随意的。

调用链:tool-cordis:apply → ctx.tools.register()(core/tools/src/index.ts:1047)→ layers.effect(ctx, …)(就是上面这段)→ ctx.effect(function*(){…}) → fiber 的 disposables。同理 ctx.systemPrompt.section() 也是 layers.effect(core/system-prompt/src/index.ts:448-457)。

这就是「一切注册都是效果」在 dsh 里的真实形态:不是靠约定,是靠所有服务都共用同一个分层存储、而这个存储的效果原语就是 ctx.effect。

05.9照着抄:153 行的 mini-Cordis

如果你不想读完 92 页论文再动手,这里是可以直接跑的版本。它把论文最核心的四件事压进 153 行(含注释):带逆的效果、按提供者身份算的目标摘要、只跨 ACTIVE 边界通知的三分类、以及撤销时的守卫。我在本机 Node 24 上跑过,输出附在后面。

mini-Cordis 覆盖了什么、没覆盖什么
论文机制mini 里说明
𝔈Γ / ℑΓ 效果迭代器有ctx.effect(body):支持「返回一个逆」「返回逆的序列」「返回(异步)迭代器」;异步迭代器在每个边界检查目标
Σ 依赖表 + provider有core.providers;解析只在提供者 ACTIVE 时成立
target 摘要(按提供者身份)有epoch += ':' + impl.fiber.uid,与真实实现同形
Definition 22 三分类有摘要没变直接 return(neutral);变 INACTIVE 走卸载,变有值走装载
inertia 惯性 + 相互链式有转移在飞时只记目标;reload 与 unload 在结尾互相链
Theorem 70 撤销守卫有provide 的逆:撤离 → 通知 → await 依赖者 → 才算完
Corollary 69 终止恢复有卸载末尾丢弃 committed view;测试显示最终 providers/fibers 都归零
隔离 Σiso / 拦截 Σinter省略真实实现是 Object.create 原型链 + symbol 表,照抄 context.ts:96-145 即可
confined / 观测等价 ≃省略它们是证明用的条件,不是运行时机制;省略不改变行为
失败 → FAILED简化这里只把错误记在 fiber 上并作废目标;真实实现见 fiber.ts:656-660
mini-cordis.mjs可直接 node mini-cordis.mjs 运行
// mini-cordis.mjs —— 时空可组合性内核的最小可运行形态
// 论文对应:Σ(依赖表) · 𝔈Γ/ℑΓ(效果迭代器) · Definition 22(三分类) ·
// Definition 53(target 摘要) · Theorem 70(撤销有序 + 守卫) · Corollary 69(终止恢复)
const INACTIVE = null                          // 「目标不可满足」的哨兵(对应 INACTIVE_EFFECT 那套)

class Core {                                   // 应用级:一张依赖表 + 全部 fiber
  providers = new Map()                        // Σ:name -> { fiber, value }
  fibers = new Set()
  notify(names) {                              // Algorithm 3:反应式通知(Definition 22)
    const affected = []
    for (const f of this.fibers) {
      if (!names.some(n => n in f.inject)) continue
      f.resolve(); f.refresh(); affected.push(f)
    }
    return affected
  }
}

class Fiber {
  static seq = 0
  constructor(core, parentCtx, plugin, config) {
    this.core = core
    this.uid = ++Fiber.seq                     // uid 新鲜、永不复用 ⇒ 身份可比较
    this.plugin = plugin; this.config = config
    this.inject = Object.fromEntries((plugin.inject ?? []).map(n => [n, null]))
    this.state = 'PENDING'                     // Inactive
    this.draft = {}; this.committed = null; this.epoch = INACTIVE
    this.inertia = null; this.disposables = []; this.retired = false
    this.provided = new Set()
    this.ctx = Object.create(parentCtx)        // Definition 23 的派生实现
    this.ctx.fiber = this
    core.fibers.add(this)
  }

  // ctx.effect:body 返回一个逆、逆的序列、或一个(异步)迭代器
  effect(body) {
    const collected = []
    let task = null
    const r = body()
    if (typeof r === 'function') collected.push(r)
    else if (r?.[Symbol.asyncIterator]) {
      task = (async () => {
        const it = r[Symbol.asyncIterator]()
        const mark = this.epoch
        while (true) {
          if (this.epoch !== mark) return       // ← 迭代边界的目标检查(= L-Divert 的中止支)
          const { value, done } = await it.next()
          if (typeof value === 'function') collected.push(value)
          if (done) return
        }
      })()
    } else if (r?.[Symbol.iterator]) {
      for (const d of r) if (typeof d === 'function') collected.push(d)
    } else if (r?.then) task = r.then(d => { if (typeof d === 'function') collected.push(d) })

    const dispose = async () => {
      if (task) await task
      for (const d of collected.splice(0).reverse()) await d()   // 严格 LIFO
    }
    this.disposables.push(dispose)
    return dispose
  }

  resolve() {                                  // 每个声明的键解析到「活着的」提供者
    for (const name of Object.keys(this.inject)) {
      const impl = this.core.providers.get(name)
      if (impl && impl.fiber.state === 'ACTIVE') this.draft[name] = impl
      else delete this.draft[name]
    }
  }

  refresh() {                                  // target(γ,n):把提供者身份拼成摘要
    let epoch = ''
    for (const name of Object.keys(this.inject)) {
      const impl = this.draft[name]
      if (!impl) { epoch = INACTIVE; break }
      epoch += ':' + impl.fiber.uid
    }
    if (epoch === this.epoch) return            // neutral:目标没动 → 什么都不做
    const old = this.epoch
    this.epoch = epoch
    if (this.inertia) return                    // 惯性:转移在飞时只记目标
    const activating = epoch !== INACTIVE && old === INACTIVE
    this.setTransition(activating ? this.reload() : this.unload())
  }

  setTransition(task) {
    this.inertia = task.finally(() => { this.inertia = null })
  }

  async reload() {                              // L-Begin → L-Iter → L-Finish
    const mark = this.epoch
    this.setState('LOADING')
    this.committed = { ...this.draft }          // ① 先提交视图
    this.disposables = []
    try { await this.effect(() => this.plugin.apply(this.ctx, this.config)) }
    catch (e) { this.error = e; this.epoch = INACTIVE; return this.unload() }
    if (this.retired || this.epoch !== mark) return this.unload()  // ② 目标变了 → 惯性链
    this.setState('ACTIVE')
  }

  async unload() {                              // L-Leave 已由 refresh 完成 → L-Unload
    this.setState('UNLOADING')                  // 「先停止供出」早于任何逆被调度
    for (const d of this.disposables.splice(0).reverse()) await d()   // 应用累加器 g(γ)
    this.committed = null                       // ③ 最后才丢弃已提交视图
    if (this.retired) return this.setState('DISPOSED')
    if (this.epoch !== INACTIVE) return this.reload()   // 目标又变「有」→ 链回装载
    this.setState('PENDING')
  }

  setState(s) {                                 // 状态变化 + 只跨 ACTIVE 边界才通知(见 cordis/src/fiber.ts:589)
    const old = this.state
    if (old === s) return
    this.state = s
    console.log(`      fiber#${this.uid} ${old} → ${s}`)
    if ((old === 'ACTIVE') !== (s === 'ACTIVE')) this.core.notify([...this.provided])
  }

  async dispose() {                             // O-Retire → 卸载 → O-Remove
    this.retired = true; this.epoch = INACTIVE
    if (this.state === 'ACTIVE') await this.unload()
    else if (this.inertia) await this.inertia
    this.core.fibers.delete(this); this.setState('DISPOSED')
  }
}

function createApp() {
  const core = new Core()
  const root = { core, uid: 0, state: 'ACTIVE', effect: body => { body() } }
  const base = {
    plugin(plugin, config) {                    // Definition 52:实例化 = 父的一次效果
      const f = new Fiber(core, this, plugin, config)
      this.fiber.effect(() => async () => f.dispose())   // O-Insert / O-Retire
      queueMicrotask(() => { f.resolve(); f.refresh() })
      return f
    },
    get(name) { return core.providers.get(name)?.value },
    provide(name, value) {                      // set(k,v):本身是一个效果
      const f = this.fiber
      f.provided.add(name)
      core.providers.set(name, { fiber: f, value })
      f.effect(() => async () => {              // 逆 = 撤离 + 通知 + 守卫
        core.providers.delete(name)
        const affected = core.notify([name])    // ① 依赖者开始拆
        await Promise.allSettled(affected.map(x => x.inertia ?? Promise.resolve()))  // ② 守卫
      })
      return () => core.providers.delete(name)
    },
    effect(body) { return this.fiber.effect(body) },
  }
  const ctx = Object.assign(Object.create(null), base, { core, fiber: root })
  return { root, ctx, core }
}

// ───────────────────────── 演示 ─────────────────────────
const { ctx, core } = createApp()
const sleep = ms => new Promise(r => setTimeout(r, ms))

const db = { name: 'db', apply(ctx) {
  ctx.provide('db', { query: () => '42 行' })
  console.log('      [db] 提供 db')
} }
const app = { name: 'app', inject: ['db'], apply(ctx) {
  const conn = ctx.get('db')
  ctx.effect(() => { console.log('      [app] 注册 工具 A'); return () => console.log('      [app] 撤销 工具 A') })
  ctx.effect(async function* () {                       // 迭代器形态:分两步装
    yield () => console.log('      [app] 撤销 步骤 1')
    yield () => console.log('      [app] 撤销 步骤 2')
  })
  console.log(`      [app] 用连接查询 → ${conn.query()}`)
} }

;(async () => {
  console.log('① 装载 db');            const f1 = ctx.plugin(db);  await sleep(20)
  console.log('② 装载 app');           const f2 = ctx.plugin(app); await sleep(20)
  console.log('③ 卸载 db —— 注意顺序:app 先拆完,db 才真正撤离');
  await f1.dispose(); await sleep(20)
  console.log('④ 重新装载 db —— app 应自动复活');  const f3 = ctx.plugin(db); await sleep(20)
  console.log('⑤ 卸载 app');           await f2.dispose(); await sleep(20)
  console.log('⑥ 卸载 db');            await f3.dispose(); await sleep(20)
  console.log(`   终态:providers=${core.providers.size}  fibers=${core.fibers.size}`)
})()

三个值得单独看的地方:

① refresh() 里那句 if (epoch === this.epoch) return —— 整个反应式机制的成本就是这一次字符串比较。
② provide() 返回的逆里,await Promise.allSettled(affected.map(x => x.inertia)) —— 这就是 Theorem 70 的守卫,也是「卸载一个 provider 为什么不是瞬时的」的原因。
③ setState() 里 if ((old === 'ACTIVE') !== (s === 'ACTIVE')) this.core.notify([...this.provided]) —— 通知只发生在跨过 ACTIVE 边界时,这与真实实现的 fiber.ts:589 一致;它避免了「每次状态抖动都惊动一遍依赖者」。

一处有意的偏离:mini 的 fiber 级清理是严格 LIFO 串行的,而真实 Cordis 是并发启动 + LIFO 顺序(见落差 03)。我选择串行,是为了让演示输出的顺序可读且可解释;如果你要照抄进生产代码,请按真实实现改成并发,并接受「顺序要靠独立性保证」。

实际输出(node mini-cordis.mjs)Node 24.14 · 逐字
① 装载 db
      fiber#1 PENDING → LOADING
      [db] 提供 db
      fiber#1 LOADING → ACTIVE
② 装载 app
      fiber#2 PENDING → LOADING
      [app] 注册 工具 A
      [app] 用连接查询 → 42 行
      fiber#2 LOADING → ACTIVE
③ 卸载 db —— 注意顺序:app 先拆完,db 才真正撤离
      fiber#1 ACTIVE → UNLOADING
      fiber#2 ACTIVE → UNLOADING
      [app] 撤销 步骤 2
      [app] 撤销 步骤 1
      [app] 撤销 工具 A
      fiber#2 UNLOADING → PENDING
      fiber#1 UNLOADING → DISPOSED
④ 重新装载 db —— app 应自动复活
      fiber#3 PENDING → LOADING
      [db] 提供 db
      fiber#3 LOADING → ACTIVE
      fiber#2 PENDING → LOADING
      [app] 注册 工具 A
      [app] 用连接查询 → 42 行
      fiber#2 LOADING → ACTIVE
⑤ 卸载 app
      fiber#2 ACTIVE → UNLOADING
      [app] 撤销 步骤 2
      [app] 撤销 步骤 1
      [app] 撤销 工具 A
      fiber#2 UNLOADING → DISPOSED
⑥ 卸载 db
      fiber#3 ACTIVE → UNLOADING
      fiber#3 UNLOADING → DISPOSED
   终态:providers=0  fibers=0

第 ③ 段是整个演示的重点,请对照时间顺序读:

fiber#1 ACTIVE → UNLOADING(db 先停止供出,但一个逆都还没跑)
→ fiber#2 ACTIVE → UNLOADING(app 算出目标不可满足,开始自己的拆除)
→ app 的逆按 LIFO 跑完(步骤2 → 步骤1 → 工具A,注意它是生成器效果,顺序是运行时给的)
→ fiber#2 UNLOADING → PENDING(app 没有死,只是回到「等待依赖」)
→ 直到这时 fiber#1 才 UNLOADING → DISPOSED。

最后一步之所以能发生,是因为 db 的逆在 await 之后又检查了一遍:依赖者已经 settle,守卫释放。这就是 Theorem 70 与 Theorem 73 在终端里的样子。而第 ④ 段显示了反方向的反应:新的 db fiber 一进 ACTIVE,notify 就让 app 自己重新装载——没有任何人显式要求它复活。

06 / 批判11 处落差 + 一份对账

前面五节基本是「论文说了什么、代码怎么实现」。这一节做相反的事:把论文的承诺和代码的现实并排放,标出后者多出来的、前者覆盖不到的、以及两者不一致的地方。共 11 处落差,按「对使用者的实际影响」从大到小排序;最后一张卡是反过来的一份对账——逐条核对下来确实对得上的地方。

落差 01

观测等价 ≃ 有盲区:绕过 ctx 的效果完全不受保证

影响最大

这是论文自己写明的边界,但它的重要性远超它在原文里的篇幅。Definition 56 要求「每个 fiber 的效果函数必须落在上下文中介的迭代器类里」;落在类外的(读了上下文不持有的位置、或者用了没有键绑定的通道)就不在演算之内。Definition 33 又明说:「没有键绑定的那部分状态因此被遗忘」。合起来是一句很硬的话:

只有你 reify 成键的东西,才可能被回滚。

§6.1 把它展开成 acquisition / emission 的区分:open / malloc / fork 这类获取会在边界内留一条记录(描述符、块、子进程号),那条记录是可回滚的效果;而 write / send 这类发射在形式上就是 idΓ——不跟踪、不回滚。要弥补只能靠「推迟发射」(output commit)或「补偿」(退款、删文件),而补偿不能直接继承定理,因为独立性是对 ≃ 证的。

对 dsh 的具体含义:
· 一个插件若直接 process.on('SIGINT', ...)、写全局单例、起一个 child_process、或调外部 API 发了消息——卸载它是不会撤销这些的;
· 沙箱门面只挡「通过 ctx 的访问」,不挡 escape(guard.ts 自己的注释说得很清楚:host-realm helper functions remain an escape route);
· 结论:把 Cordis 当「事务」用是误用。它是一个「可回滚的注册表 + 依赖解析器」,不是一个事务系统。
· 旁证:同一份论文存档里还有一篇第三方评估(arXiv:2608.16393,腾讯朱雀实验室《Security Assessment of DeepSeek Harness with A.I.G》,14,560 次受控执行,主题是指令注入)。那篇谈的是「能力边界的另一侧」——当一个组件是模型写的、且可以被诱导时会发生什么;两篇放在一起读,正好是 Cordis 的「协作边界」与真实安全边界之间的那段距离。
落差 02

两个「见证」都没有人校验——而所有定理都建立在它们之上

理论前提

论文有两处「见证」:① 𝔈Γ* 要求每个效果返回的逆真的能回滚(g(δ) = γ);② Definition 46 要求每个键的操作两两可交换。论文的原话是:「运行时不检查 𝔈Γ* 携带的那个见证:回调提供逆,而『逆回滚它伴随的效果』是组件作者的义务,不是运行时验证的性质。」余效应的可交换性见证「以同样的方式不被检查」。

代码证实了这一点:ctx.effect() 只做三件事——调回调、把返回的函数塞进 disposables、必要时倒序调用。它无法验证 g(f(γ)) = γ,因为那需要一个可比较的状态模型,而这正是它要避免的。

所以准确的说法是:Cordis 提供的不是「保证」,而是「让保证可以被陈述、被局部化、被组合的语法」。局部性才是它真正的贡献——义务落在写插件的人身上,而且只落一次、落在一处。这不是缺陷,但如果 README 让人以为「用了 Cordis 就自动安全」,那就是误读。

可核对的证据:fiber.ts:418-442(effect 的全部内容)、论文 §5.1.1 与 §5.1.1 末段(「The witness of a coeffect … is unchecked in the same way」)。
落差 03

「反序撤销」只在单个 effect 内部成立;fiber 级是并发

语义漂移

论文 §3.1.3 把整个装载建模成一个效果迭代器,Theorem 16 说反序撤销时「每个逆都拿到它自己那次应用产生的状态」。Algorithm 1 也把它实现为一条链:inverse ← value ∘ inverse,并且 ctx.dispose ← dispose ∘ ctx.dispose——处处都是串行复合。

但仓库里 fiber 级的累加器是一份列表 + 一次并发清扫:

fiber.ts:676 — await Promise.all(this._disposables.clear().map(async (dispose) => …))
DisposableList.clear() 会先把列表清空并 reverse()(utils.ts:27-31),所以启动顺序确实是 LIFO;但 .map() 里的 async 函数同时开始,于是彼此之间没有顺序保证。

只有一个 effect 内部的多个 yield(ctx.mixin 那种)才是严格串行 LIFO(fiber.ts:431-433)。嵌套 ctx.effect 也会变成串行——因为内层 effect 的 wrapper 会被从 owner 列表里摘掉、由外层单独持有(fiber.ts:451:this._disposables.delete(dispose))。所以严格的说法是:树是串行的,兄弟是并发的。

论文并非完全没注意到这一点(§5.1.3 正文里写着「fiber.dispose 并发地启动一个 fiber 的各个效果,而把等待放进其中一个逆里会让其余逆失去顺序」),但它在 §3.1.3 和 Theorem 16 里承诺的是反序。这两处的落差不会导致错误——因为 Theorem 43 说了:只要独立性成立,清理顺序任意都可以。但它把「顺序」从一个结构保证降级为一个需要独立性假设的保证。对插件作者的实际建议因此变成:兄弟 effect 之间不要共享可观察的中间状态;需要顺序就放进同一个 effect 里(dsh 的 primer 也是这么写的)。

落差 04

演算没有「重入」——7 处本地加固就是它的补丁

模型缺口

论文的规则是「一步一次状态转移」,而真实 JS 宿主里,一次转移的同步段可以再次触发转移:插件在 setup 里调用 ctx.plugin()、一个同步的 internal/plugin 观察者顺手 dispose 掉父级、effect 的 setup 抛错时 owner 已经开始卸载……这些都不是「调度问题」,而是一步之内再发一步。

dsh 的 vendor 日志第 6 条一栏里就列了七个这样的洞,而且每一条的措辞都能看出它是被真实事故逼出来的:「effect 的 owner-list wrapper 必须在 setup 体之前登记」;「同步 setup 失败要移除 wrapper 并回滚已收集的清理」;「异步清理必须对 owner 保持可见直到静止」;「卸载中拒绝创建 effect(UNLOADING),而 PENDING/LOADING 仍合法」;「子 fiber 必须在 internal/plugin 广播之前拿到父级持有的 disposer」;「重入卸载在第一个检查点前作废这次装载时,不要执行插件代码」;「清理失败的定向通知要按观察者隔离,免得一个回调饿死同侪」。

代码里能直接看到的对应物:fiber.ts:419-422(卸载中拒建 effect)、fiber.ts:459-537(setupBarrier/setupFailed/inFlight/removeWrapper 那一整坨状态)、fiber.ts:118-135(emitPluginDisposed 按观察者 try/catch)。

这段代码的复杂度几乎是论文那部分的两倍,而它保护的正是论文假设里不存在的东西。

落差 05

清理期抛错被吞掉:恢复精确性在这里失去了前提

边界条件

Theorem 68(恢复精确性)与 Corollary 69(终止恢复,「σnu+1 = ∅」)都假设累加器能跑完。ctx.effect 的语义也保证了「已收集的 disposer 都会被调用」。

但代码里的两种失败路径不一样:

  • 装载失败(_reload 的 catch,fiber.ts:656-660):被记录成 FAILED,论文 §4.4 的 Failure 扩展专门覆盖了这一情形——「raise 只约束 Right 分支」,而「一个 raise 从 𝘙𝘦𝘭𝘰𝘢𝘥𝘪𝘯𝘨 退出,带着到失败那一步为止的累加器」。
  • 清理失败(_unload 的 catch,fiber.ts:683-685):只 logger.error,然后继续。论文的 Failure 扩展没有覆盖这一侧——它的 raise 是迭代器抛出的,而卸载期跑的已经不是迭代器,是累加器。

后果不是「崩溃」,而是更阴的那种:一个 disposer 抛错,后面的清理照样跑,系统看起来回到了干净状态,但可能留下了没有被撤销的一半改动。Theorem 68 的前提在这里断了,而运行时不会告诉任何人。

顺带一个可核对的细节:_reload 的 catch 里注释写着「impl guarantees that the error is non-null (?)」——那个问号是原作者的犹豫,它出现在一个 catch 块里,说明「错误一定是非空」这件事在这条路径上没被真正证明过。
落差 06

「就地更新」是条目级身份,不是状态保留

名实之别

论文 §5.2.1 的措辞是:条目字段变化时,装载器「incrementally 协调,而不是把 fiber 拆掉整体重建」,其中 config 一项「交给组件,组件自己决定怎么应用新 payload,通常是对新旧做 diff,只在实质变化时才重载」。

代码的现实:deepEqual 的 diff 只发生在 EntryOptions 的顶层键上;一旦认定 config 变了,_patchContext → fiber.update() → internal/update waterfall → restart() = 卸载全部 effect + 重跑插件回调。「就地」保住的是 Entry 与 Fiber 对象的身份(测试断言 entry.fiber === fiber),不是插件的任何运行时状态。

这在很多场景下无关紧要(插件的状态本来就该从 ctx 重建),但它推翻了一个容易产生的直觉:「改 config 不会中断我的服务」。除非组件自己实现 internal/update 钩子并不调用 next()(那就是 veto 掉默认的 restart),否则任何 config 变化都会来一次完整的卸载—装载循环,包括所有依赖它的 fiber 跟着重算。

更细的一处:Entry.update 的 config-only 回滚路径会再次调用 _patchContext,而如果此时 fiber 不在 ACTIVE,Fiber.update 只做 _setEpoch(INACTIVE); _refresh() 并返回 undefined(fiber.ts:739-745)——回滚的 reload 不会被 await,其错误只会被 _reload 内部吞掉。也就是说:回滚是尽力而为、非原子的;回滚本身失败会抛 AggregateError,系统可能停在候选状态。
落差 07

HMR 的六项工程前提,论文一条都没提

承诺打折

论文对 HMR 的卖点是「不需要 Webpack/Vite 那种开发者标注的接受边界」。这个论断本身成立(代码确实从模块图自动推出接受集),但能成立的条件相当硬:

  1. 需要摸到 Node 内部模块加载器(--expose-internals 或一个原生 addon),否则服务构造就直接抛错;
  2. 只重挂 loader 条目;程序式 ctx.plugin(fn) 注册的插件不会被重建,只会收到 hmr/change 事件;
  3. 只有 change 事件触发;新增/删除文件不触发挂载/卸载;
  4. 框架自身文件的变化走 loader.exit(),而 Loader.exit() 默认是空函数——不覆写就等于什么都不做;
  5. 「事务性」只覆盖整批重载:任何一个模块 import 失败或 fiber 重建失败,才回滚全部;单个条目的部分成功不在事务内(但失败的批次会把 stashed 留着,下一轮重试——没有重试上限);
  6. 没有 mtime/时间戳比较,防自触发靠 debounce + 内容相等 + ignoreInitial;而 ignoreInitial 这一条是一次死锁事故的产物(见 05.7 C 的第 12 条补丁:initial scan 重新播报了 boot 刚消费的文件 → 触发 include 刷新 → 失败的初始 apply 回滚时 dispose 掉 HMR → HMR 的拆除又等待排在同一 apply 后面的 refresh → 互相等待,进程以 exit 13 静默退出,零诊断)。

最后那件事最值得记:一个「理论上不需要接受边界」的机制,在生产里被一个「初始扫描顺序」问题拖进了死锁。这正是第 06 节开头那句话的来源:形式模型管得住的,和工程上会崩的,是两个集合。

落差 08

定理的量化边界:四个前提里有两个没人检查

适用范围

把主结果的假设列出来,能看清理论覆盖到哪里为止:

定理前提现实
Thm 80 合流每个组件「total on its provision」;序列到达静默态;各组件已定义论文自己说:失败 fiber 被排除在外,而且必须排除(「一次迭代是否 raise 取决于它遇到的状态」)。代码里 FAILED 的 fiber 会永远停在 FAILED 直到环境变化或显式 update。
Thm 73 进展① ≺(pn ∩ dm ≠ ∅)无环;② len(en) ≤ K;③ 名字集合有限① 代码不检查环,环的后果是两个 fiber 永久 PENDING(论文说这是可判定的,运行期可以报告——但实现没报);② 一个 while(true) 的异步生成器就把 K 推到无穷;③ 实践中成立。
Thm 43 排列无关效果两两独立独立性依赖两个见证(落差 02)。对提供者/消费者这种「纠缠(entangled)」对,论文说得非常直接:「纠缠的 fiber 是独立性覆盖不了的那些对,而且也不该期待它能覆盖:消费者的操作正是作用在提供者的扩展所安装的那个值上。」它们靠的是规则本身——即那套守卫与有序性。
Lemma 66 两两独立每个键都可交换递归到底仍然是「组件作者提供了见证」。
落差 09

单源原则很干净,而真实系统靠 broker 绕开它——broker 的语义不在论文里

覆盖空白

演算为了保证「每个键只有一个可能的提供者」(否则 σγ 的并集就不是函数),在 O-Insert 的最后一条前提里禁止两个组件的 provision 相交。论文承认这是「简化形式化而不是简化它建模的系统」,并给出两条出路:realm,或者 §6.2 的 broker。

dsh 用的是 broker:ctx.tools 是唯一的键与唯一提供者,几十个插件通过 ctx.tools.register(...) 往里塞工具;每个注册都是一个可撤销的效果。问题是:broker 自己成了一个没有理论覆盖的组件。它可以有序(注册顺序 = 中间件顺序,对应论文里那个「不可交换的有序链」的例子),可以优先,可以拒绝,而这些都发生在「值」内部,对余效应层不可见。论文 §3.4.2 其实把这个陷阱讲清楚了——「键的值是一个有序链时,键不可交换:插在别人前面的中间件看到的请求不一样,两个顺序都无法在不扰动对方的前提下被撤回。」

所以在 Cordis 里,设计一个 broker 键,等于在一次性地承担这份可交换性义务:你要么让它可交换(条目带自己的标识)、要么承认它的顺序敏感并接受「重排会改变行为」。

落差 10

类型层与运行时层是两个世界

工程债

论文 §6.7 设想的是语言协同:把上下文做成隐式的、把余效应规格放进类型系统,于是「依赖环在编译期就能报」、依赖可以按类型结构而不只是按键名匹配。

TypeScript 实现的现实是:键名匹配 + 运行时 Proxy 检查。类型侧靠模块声明合并(declare module './context.ts')把服务挂到 Context 接口上——这给的是写代码时的补全与检查,与运行期的 fiber.inject 表没有任何强制关系:你完全可以在ctx.foo上通过类型检查,却在运行期因为没有 inject 到 foo 而被抛错(那个错误消息「cannot get property "foo" without inject」就是这个鸿沟的产物,reflect.ts:144)。

更有说服力的证据是 dsh 里那个手抄的枚举镜像:FiberState 是 const enum,运行期不能 import,于是 tool-cordis/src/fiber-state.ts 里复制了一份等值的对象字面量,并在另一处(boot 包)用注释声明「必须与它保持一致」。一个理论上的「第一等公民状态机」,在工程上需要一个跨包手工同步的副本。

这也解释了论文 §6.4 为什么反复强调「语言级支持」:它知道自己现在是一个 overlay,而 overlay 的类型信息是建议性的。jsdoc 注释里那句「waterfall listeners MUST call next()」也是同一类问题的另一面——一个纯约定的接口契约,靠文档和代码审查维持。
落差 11

论文 §5 的运行时名字,和仓库里的名字对不上

可核对的事实

论文 §5.1 明确宣称「下文用运行时名字」。但 ctx.use、fiber.apply、fiber.committed、fiber.target 这四个名字,在 vendor/cordis 4.0.2 里一个都不存在;代码用的是 ctx.plugin、runtime.callback、fiber.store、fiber._runner.epoch。仓库自带的生成式 API 目录(docs/cordis-api/*.md,由脚本从源码 JSDoc 生成)用的是后一套。

另外论文把 fiber.target 描述为「a hash of it」,而代码里是一个由 uid 拼接成的字符串(epoch += ':' + impl.fiber.uid)——语义等价,但「hash」这个词会让人以为在做内容摘要。

最可能的解释是命名世代:vendor 清单表里记的上游快照是 4.0.0-rc.7,而 package.json 已经是 4.0.2(那份表本身就落后了——这是一个可验证的小事实,说明「论文写的是某个版本、仓库跑的是另一个版本」是常态)。对读者的实际影响:照论文找代码会一无所获,必须做一次名字翻译。

对账 · 非落差

反过来:论文经受住了检验的地方比想象中多

对账成功

为了不让这份分析显得只有批评,这里是逐条核对下来确实对得上的清单——而且其中有几条相当不平凡:

  • target 摘要用「提供者身份」而不是值(§5.1.3 明文)→ epoch += ':' + impl.fiber.uid,一字不差;registry.counter 的自增 getter 保证 uid 新鲜不复用(registry.ts:207)。
  • L-Leave 必须在任何逆被调度之前→ _setEpoch 里状态同步置 UNLOADING,而 disposer 真正开跑要等一个微任务(因为 _unload 的首个 await)。
  • 「提交视图 → 执行效果」「跑完逆 → 丢弃视图」两条时序→ fiber.ts:647 与 :687 两行。
  • guard 按「绑定」而不是按「fiber」判定(realm 不同的依赖者不算)→ notify 的默认 filter 比较 isolate symbol。
  • Algorithm 7 的分隔符 δk 与式 (64)→ isolate.ts 的 delims[name] 与四元组 (s₁,s₂,d₁,d₂),连不等式的形状都一致。
  • Algorithm 10 的事务性重载→ 双缓存备份 + rollback() + 用旧 plugin 重建 fiber。
  • 失败是「记录在 fiber 上的 outcome」而非异常传播→ _error + FAILED,兄弟不受影响;update() 显式清 _error 对应「修订 = 重新插入且不带 outcome」。
  • 派生实现「无逆可跑、recovery 是隐式的」→ isolate/intercept 只造原型链子对象,零 disposer 注册。
  • 迭代器 = 语言里的 generator→ _execute 原生支持同步与异步生成器;ctx.mixin() 自己就写成 function*。
  • Theorem 70 的四步序→ provide() 的 disposer 里 298–302 四行,顺序一步不差。

07 / 数据数字速览

全部数字都可核对。论文数字来自 PDF 文本抽取;代码数字来自 ~/project/dsh-official 工作副本(版本 0.1.5-rc.2,vendored cordis 4.0.2)。

论文
页数92(正文 4–82 页,参考文献 83–92 页)
参考文献127 条
编号结果81:46 Definition · 18 Theorem · 16 Lemma · 1 Corollary(共用一条序列,编号 1–81)
算法10 个(Algorithm 1–10)
表 / 图2 张表(Table 1 规则即写入、Table 2 理论↔实现对应)· 1 张图(Figure 1 生命周期状态机)
技术高点Theorem 43(排列无关)、Theorem 68(恢复精确性)、Theorem 71(解析一致性)是三条最巧的论证;篇幅最长的是 §4.3.1(为保持性做的三项准备:≃-不变性、等变性、残留条目)与 §4.3.5(合流,连用 Lemma 78 转置与 Lemma 79 删除)。Theorem 73(进展)的证明分「无死锁」与「终止」两半,后者用 V(n)(目标翻转次数)对 S(n)(作用于该 fiber 的步数)给出界 S(n) ≤ (K+3)(V(n)+1)
案例规模Koishi:4000+ 社区插件,四年演进;论文脚注注明 Koishi 跑的是 Cordis v3
VS Code 统计Top 100 中 87 个含可执行代码(卸载需重启宿主)· 仅 7 个声明了非内置依赖
代码
包文件数源码行数对应论文
cordis(核心)92,693§3 全部 + §4 全部 + §5.1
loader71,149§5.2.1 声明式配置与协调
hmr2612§5.2.2 热模块替换
include1377§5.2.1 的「文件后端」
schemastery1902配置校验(论文未展开)
cosmokit6477工具库(deepEqual 支撑 diff)
timer1147§5.1 的「服务」范例:所有定时器都是 effect
logger-console3145—
group13再导出(实现其实在 loader 里)
vendored 全栈≈ 6,505核心占 41%
比例与耦合
核心代码 / 论文2,693 行 ↔ 92 页、81 条结果、10 个算法 ⇒ 约 33 行代码承载一条编号结果
真正吃重的代码_checkImpl(11 行)+ _refresh(13)+ _setEpoch(15)+ _reload(24)+ _unload(22)+ provide 的守卫(6)= 约 91 行,对应 Definition 49–55 与 Theorem 68–80
dsh 规模51 个一级包目录 · 1,595 个源文件 · 297,142 行
耦合面1,635 处 from '@deepseek-ai/cordis'(含测试,排除构建产物)· Context 出现在其中 1,574 处
本地补丁vendor 偏离清单 19 条,其中 8 条落在「回滚 / 依赖 / 生命周期 / 热替换」语义上
四个 cordis 扩展包3,355 + 6,090 + 7,826 + 2,461 = 19,732 行(其中约 10,300 行是生成物目录)
三个我认为最值得记住的数字

91 : 12 —— 承载全部全局定理的代码约 91 行;而针对同一批代码的重入/竞态加固,加上装载器与 HMR 的事务化补丁,占了 vendor 偏离清单 19 条里的 8 条。理论的核心是小的,把核心接到真实宿主上的成本才是大头。

0 —— 运行时校验「见证」的次数。所有定理的最后一公里靠作者自觉。

1,574 / 1,635 —— dsh 对 Cordis 的用法极其收敛:1,635 处 import 里有 1,574 处只是要那个 Context,而且多是类型。它把 Cordis 当接口用,不当库用。

08 / 结论可操作结论:三类读者的清单

如果这篇分析只留下一页,我希望是这一页。

给写插件的人:八条

1不要写 load()/unload() 一对。写一个函数,每做一件事就把「怎么撤掉它」还回去(返回 disposer / 用 ctx.on 这类自带撤销的注册器)。顺序交给运行时,复杂度立刻降一个量级。
2要顺序,就放进同一个 effect。fiber 级的多个兄弟 effect 在卸载时是并发启动的(落差 03),只有同一 effect 的多个 yield 才是严格 LIFO。
3只声明你需要的。余效应声明不是「顺便查一下」的便利,它是能力边界(论文 §6.3;dsh 的沙箱把它实现成了真正的白名单)。
4别指望 ctx.set 会让依赖者刷新。就地覆盖自己的绑定不被观察;要让替换传播,就撤回再重装。
5想要「少 reload」,就少在依赖链上换人。epoch 摘要比的是提供者的身份;同一个 provider 改自己的内部值不触发任何 reload,换一个 provider 提供同一个值也必然触发 reload。这是一个故意选择的语义。
6提供键的人要承担可交换性。你的键的值是一张表、每个条目自带标识 → 可交换(多注册可任意顺序、可单独撤回);你的键是有序链 → 不可交换,并且这个代价不会消失,只会转移给使用者(中间件顺序敏感)。论文 §3.4.2 把这说成一条设计程序:少公布一个 outcome,你的键就更好组合。
7卸载路径上不要抛错。它会被 logger 吃掉,而你以为干净的状态可能不干净(落差 05)。做不到就把失败记在明面上(自己的记录器/状态键)。
8绕过 ctx 做的事,不会回滚。进程信号、全局单例、子进程、外部写操作——论文把它们归到「系统边界之外」,这是设计而非遗漏。

给框架作者:六条

1「逆」应该是返回值,不是注册一个钩子。释放与创建在同一个语法位置,是让清理可验证的唯一办法。VS Code 的 activate/deactivate 分离就是反例(论文 §1.2.1)。
2依赖要按「提供者身份」而不是「值」来比较。一次字符串比较替代一次深 diff,而且能区分「换了个人提供同样的值」这件事。代价是「同一个 provider 改自己的值不通知」——接受它,并写进文档。
3卸载要分三步,顺序不能换:先撤自己的绑定(让别人解析不到)、再让依赖者开始拆、等它们拆完、最后才清理自己的下游依赖。这一条对应整个 Theorem 70,也是唯一能同时保证「关连接池时还能拿到 provider」与「provider 不会被上层的拆解过程重新触发」的形态。
4给出「状态转移在飞」这一个显式字段。inertia 一个 Promise 就换来了惯性语义、转移互斥、以及两条自动链式(reload↔unload)。比一堆 isLoading 布尔量便宜且不容易写错。
5把「更新」实现成「撤回 + 重插」的复合,而不是一条能改状态的规则。这样终态等于「按最终配置从零装载」(Theorem 80),而这些复合之所以安全,靠的是不变量而不是逐步推理。对应代码:条目保留、fiber 换新、disabled 只卸载不删条目。
6准备好为「重入」买单。同步回调里再次触发转移、在 setup 里卸载自己、广播点上被观察者反向 dispose——这些都不在同步演算的刻画里,却是异步宿主的日常(落差 04)。

给读这篇论文的人:三句话

① 它的贡献是把两个概念搬家,而不是发明新概念。效应与余效应都是老东西;新在「搬到了运行时」。评价它的时候,标准应该是搬家有没有掉东西——本文第 06 节就是这份清单。

② 它最实用的部分其实是 §3.4 那个「可交换性」判据。它在告诉你:一个接口能不能被安全地组合,取决于它公布了哪些可被区分的 outcome。这是可以从今天就开始用的东西,不需要任何运行时支持。

③ 它的形式化是最诚实的部分。Theorem 15 直说「effect 不把 𝔈Γ* 送进 𝔈∂Γ*」;§3.3.2 直说「物理状态不可能被原样恢复」;§4.4 直说「合流必须排除失败的 fiber」;§5.1.1 直说「见证不被检查」。一篇敢把自己的边界写在定理里的论文,比一篇只有好话的论文更值得信任。

最后一句

Cordis 值得学的不是「它证明了什么」,而是它敢于把「清理」变成一门有语法、有类型、有代数结构的事情。绝大多数插件系统把清理当成纪律问题(要靠人记得写 dispose);Cordis 把它变成一个结构问题——只要有逆,复合就有逆;只要声明了依赖,变化就会被分类。剩下的那一小截(见证是否真实、宿主是否守规矩)留给作者和工程,并且被清楚地标了出来。

09 / 附录索引与方法

四个附录:A 把论文的 81 条编号结果全部列出(这是全文的骨架,可以当读数表用);B 是符号速查;C 是概念到代码的定位表;D 交代这篇分析的方法与它自己的边界。

附录 A · 81 条编号结果全索引

论文共用一条编号序列(1–81),交替出现定义、定理、引理与推论。下表按出现顺序列出,并在小节处插入分组行。

论文 §3–§5 全部 81 条编号结果
编号名称一句话
§3.1 可回滚效应
定义 1扭合 ∘(f₁,g₁)∘(f₂,g₂) ≔ (f₁∘f₂, g₂∘g₁):正向按序,逆反序;得幺半群 𝔗Γ
定义 2效果上下文 ∂Γ(状态 γ, 累加器 φ);φ 是「到目前为止所有逆的复合」
定义 3track(f,g) 把 g 摞到累加器上:(γ,φ) ↦ (f(γ), φ∘g)
定理 4跟踪不改正向行为pr₁∘track(f,g) = f∘pr₁ —— 插桩不能改变语义
定理 5track 是幺半群同态单步跟踪 = 把一串一次性跟踪完 —— 后面所有归纳证明的杠杆
定义 6recover(γ,φ) ↦ (φ(γ), id):应用累加器并清零(全有全无)
定理 7恢复保不变式逆正确 ⇒ recover 的结果不动;φ(γ)=γ₀ 即「可靠性不变式」
定义 8𝔈Γ 与 𝔈Γ*效果函数(输入侧返回逆)+ 带见证版本(每次返回的逆都在它自己那点上回滚)
定义 9效果复合 ⋄(f⋄g)(γ) = let (δ,s)=g(γ); (ε,t)=f(δ) in (ε, s∘t)
定理 10(𝔈Γ,⋄) 是幺半群单位 η(γ)=(γ,id);𝔗Γ 到 𝔈Γ 有同态
定理 11见证在复合下存活𝔈Γ* 是子幺半群;均匀的逆在每一点都是见证
定义 12effect 提升(γ,φ) ↦ ((δ, φ∘g), track(g, pr₁∘e)):逆本身也是效果,而它的逆是重做原效果
定理 13effect 保持 ⋄effect(f) ⋄ effect(g) = effect(f⋄g)
定理 14提升的投影性质提升后正向与逆都在投影下与原来一致
定理 15提升后的逆闭式g′(Δ) = (γ, φ∘g∘f):状态精确恢复,累加器只在 g∘f=id 时复位 —— effect 不把 𝔈Γ* 送进 𝔈∂Γ*
定理 16反序撤销e₁…eₙ 反序撤销:每个逆面对它自己应用时的状态,且中间态都满足不变式
定义 17效果迭代器 ℑΓΓ → Γ×(Γ→Γ)×Maybe(ℑ):三重(状态,逆,延续)= 语言里的 generator;普通效果是「第一次就 Nothing」的退化情形
定义 18effectiter 提升逐次把逆按应用顺序叠进累加器,于是应用时按 LIFO 回滚;迭代器本身也是一个效果
§3.2 反应式余效应
定义 19余效应上下文 ΣK 上的依赖部分函数,键带类型族 𝒱_k
定义 20get / setset(k,v) 的类型是 𝔈Σ* —— 依赖注册天然可回滚,逆是删键
定义 21余效应规格𝔇Σ ≔ Set(K):一个组件声明的依赖集合
定义 22notify 三分类每个状态转移对规格分类:activating / deactivating / neutral
定义 23两种实现方式in-place(改状态、返回非平凡逆)vs derived(派生新上下文、逆为 id、丢弃即恢复)
定义 24带隔离的上下文 Σiso(ρ, σ):键先解析到 realm 再解析到值;不在 ρ 里的键解析到自己
定义 25get/set/isolateisolate 是派生实现(不是效果函数),所以「重指派而不拒绝」,无需前置条件
定义 26带拦截的上下文 Σinter(ι, σ):上下文元数据表 + 「元数据 → 值」的 provider 表;每个键的元数据带一个幺半群
定义 27get/set/intercept取用时计算 σ(k)(μ ⊕_k ι(k));合并右偏,外层上下文可以覆盖组件的声明
§3.3 上下文范式
定义 28统一上下文 Γ∞μΓ. Γ × (Γ→Γ) × Σ:自相似;Σ 的键空间无约束,因此可以吞掉所有共享可变状态
定义 29键 = (值类型, 操作集)a : X_a → 𝒱_k ⇀ 𝒱_k × (𝒱_k→𝒱_k) × B_a —— 类型本身把操作限制在这一个键上
定义 30上下文中介的迭代器ℑ^𝒜_Σ(S,P):只允许「对 S 内键的操作阶段」与「对 P 内键的提供阶段」;参数可以依赖前面阶段的产出
定义 31测试与不可区分≃_k ≔ 由该键的操作生成的测试下的不可区分性(同定义 / 同 outcome)
引理 32≃_k 最粗它是等价关系、被所有操作尊重,且任何被尊重的等价都含于它 —— 证明方法论
定义 33按键集比较 ≃_S只比较 S 里的键;不在这集合里的状态部分被遗忘(这正是 Theorem 7 能按 ≃ 读的原因)
定义 34≃ 沿类型扩展函数按「相关输入⇒相关输出」、元组逐分量、Maybe 分情形、递归类型共归纳取最大不动点
引理 35≃_S 是偏等价在映射与迭代器上对称且传递;因此两个相关的成员各自「尊重」它
定义 36𝔈Γ^S按 ≃_S 重新宣读的带见证效果函数:见证条件变成 g(δ) ≃_S γ
定义 37ℑΓ^S同上,但延续也按 ≃ 比较并按递归再见证一次
引理 38等式的重读§3.1 的每条状态等式把 = 换成 ≃ 仍成立;证明只用到传递性 + 尊重
引理 39提升沿 stage 保持在固定键集上提升保持见证关系
§3.4 独立性
定义 40reach 与 𝔐(i)可达迭代器集合,及由正向映射与 yield 出的逆共同生成的变换幺半群
引理 41交换只需看生成元生成元两两交换 ⇒ 两个幺半群整体交换;并且 ⋄ 不扩大 𝔐
定义 42独立(1) 任取两个变换都交换;(2) 谁也不扰动对方 yield 出的逆与延续(yield 稳定性)
定理 43排列无关两两独立的效果,其逆按任意置换顺序应用都回到起点 —— 清理顺序可以随便排
定义 44操作独立lift 独立 + 谁也不扰动对方 yield 的 outcome;一个键「可交换」= 它的任意两个操作独立
定理 45不同键自动独立因为每个生成元只读写一个键 —— 负担全部落在同一个键上
定义 46带见证的余效应把「该键可交换」的证明作为余效应的第三个成分随身携带(义务在 provider 身上)
定理 47迭代器独立只看键P₁∩S₂ = P₂∩S₁ = ⌀ 且共有键都可交换 ⇒ 独立 —— 这就是 Lemma 66 的引擎
§4.1 组件与 fiber
定义 48组件(d, p, e):我读什么、我可能提供什么、以及一个按 d∪p 见证过的效果迭代器
定义 49fiber⟨d,p,e,π,σ,τ,θ⟩;θ 携带(剩余迭代器 i, 累加器 g, 已提交视图 ω)
定义 50注册表与上下文F_γ : 𝔑 ⇀ 𝔉Γ;σ_γ = 所有 活跃 fiber 的表的并(单源原则保证良定义)
定义 51按键集的投影 σ^S_γ覆盖所有 fiber(不只活跃的)—— 因为见证要在随时可能处于转移中的 fiber 上被宣读
§4.2 九条规则
定义 52实例化原语迭代可以插入组件,并把「退役该 fiber」作为它的逆 —— 逆只能 retire 不能 remove,因为 remove 带前提
定义 53目标视图与静默target_n(γ):已退役或依赖不满足则为 ⊥,否则把每个声明键映到提供者;quiet = 每个 fiber 都停在它的目标上
定义 54被依赖 relied某个已安装的 fiber 把某个键解析到 n —— 这就是 L-Unload 的守卫
定义 55confined一次应用的写入(只动 σ_n 与在 d_n 上其它表的取值)与读取(只看这两样)受限;实例化是唯一例外
定义 56stage 提升与 ℑ^𝒜(n)每个 fiber 的效果函数被要求落在「操作/提供/实例化」三种迭代形式之内
§4.3 元理论
引理 57成员既 confined 又有见证上下文范式里每个组件都自动满足 Definition 48 的接口要求
定义 58步的索引化记号step_t = r(n);episode = fiber 在注册表里连续存在的区间;状态因子化为 edit_t ∘ Ψ_t
引理 59每步只动该动的字段5 条:表只在 Ψ 里动;ω 只在 Begin/Unload 生成/消失;只有 L-Unload 应用累加器;安装/卸除只由 Begin/Unload 决定;π/d/p/e 写入即永不修改、τ 单调
引理 60≃-不变性整个演算下降到商集 Γ/≃ 上 —— 规则看不见 ≃ 能忘记的东西
引理 61等变性名字做双射重命名后逐步对应 —— 这就是「新 uid 永远新鲜」的理论位置
引理 62残留条目不可见退役后留下的空壳与「没有它」在 ≃_K 下相等,且对其它 fiber 的规则完全透明
定义 63良构注册表四条:父指针落在表内;p 两两不交;已安装则 ω 在 d 上全定义且值落在表内;ω 命名的提供者必须已安装
定理 64保持性九条规则都保持良构 —— 「注册表永远是合法的树,依赖永远指向活人」
定义 65合流用的独立性纠缠 = 一方 p 与另一方 d∪p 相交;两两独立序列 = 每个名字对要么独立、要么纠缠且共有键可交换
引理 66任何序列都两两独立靠 Definition 46 的见证 + Theorem 47 —— 这是全局定理的发动机
引理 67纠缠步纠缠的提供者在其消费者的 episode 期间不可能被卸载(守卫挡住),相关映射逐对交换
定理 68恢复精确性别人的步等效于「从来没装载过它」—— 整篇论文最强的工程承诺
推论 69终止恢复episode 结束时同样成立,特别地 σ_n = ∅(正是 O-Remove 的前提)
定理 70有序性只在依赖齐备时开始转移;消费者的 episode 严格包含在提供者的 episode 内;期间该键只被声明了它的 fiber 的操作改动
定理 71解析一致性整个转移跑在同一个解析结果上;中途目标变了就改道卸载(同步宿主可中止,异步宿主只能落地)
定义 72优先关系 ≺n ≺ m ≔ p_n ∩ d_m ≠ ⌀ —— 「n 可能提供 m 声明的键」;论文明确:这是假设,不是定义保证的
定理 73进展≺ 无环 + len(e)≤K + 名字有限 ⇒ 不死锁且终止,界 S(n) ≤ (K+3)(V(n)+1)
定义 74支撑集 A最不动点:未被退役 ∧ 创建者被支撑 ∧ 所有声明的键由被支撑的 fiber 提供
引理 75支撑良基≺ 无环 ⇒ ⊲ 良基、A 是唯一解,且 A 只依赖 τ/π/d/p 四个字段
定义 76total on provision「一次完成的激活会把 p 里每个键都装上」—— 把「声明提供」收紧成「确实提供」
引理 77静默时支撑 = 活跃在 ≺ 无环 + total 的条件下,支撑集恰好是活跃 fiber 集合
引理 78转置两个相邻、作用于不同 fiber 的激活步可以换序并到达同一状态(痕迹理论基础)
引理 79删除一条闭合的 episode(连同它实例化出的 fiber)可以从序列里删掉而终态不变
定理 80合流任意到达静默态的序列都重排为规范序列;取同样编排步骤的两条规范序列终态 ≃ 相同 —— 装载器的合法性证明
§5.2 装载器
定义 81条目 entryid / url / isolate / intercept / config / disabled —— 一条声明就能忠实描述一个 fiber,因为支撑集只读 τ,π,d,p 四个字段

附录 B · 术语与符号速查

术语与符号速查
符号含义代码里的对应出处
Γ上下文类型Context(Proxy 对象)—
∂Γ效果上下文(状态 + 累加器)fiber.store + _disposables—
Γ∞统一上下文(自相似)ctx(单一入口)§3.3.1
𝔗Γ扭合复合幺半群—(只存在于复合语义里)Definition 1
𝔈Γ / 𝔈Γ*效果函数 / 带见证ctx.effect 的回调返回值形状Definition 8
ℑΓ / ℑΓ*效果迭代器 / 带见证生成器函数(同步或异步)Definition 17
Σ余效应上下文(依赖表)ctx.reflect.store(按 realm symbol 索引)Definition 19
Σiso带隔离的上下文ctx[Context.isolate] 的 symbol 映射Definition 24
Σinter带拦截的上下文ctx[Context.intercept] + Service[resolveConfig]Definition 26
𝒱_k / 𝒜_k键的值类型 / 操作集服务的类型 + 它的方法Definition 29
𝔇Γ余效应规格(d ⊆ K)fiber.injectDefinition 21
𝔓Γ余效应提供(p ⊆ K)由 ctx.provide() 动态决定Definition 48
≃_k / ≃_S观测等价(按键 / 按键集)—(不显式实现,是设计的标准)Definition 31/33
𝔐(i)转换幺半群—(概念性)Definition 40
ω已提交视图fiber.store + _runner.epochDefinition 49
target(γ,n)目标视图_runner.epoch(提供者 uid 拼接串)Definition 53
relied_n被依赖判定notify 返回的 fiber 列表Definition 54
g累加器_disposables + 每个 effect 的 wrapperDefinition 49
θ生命周期状态FiberStateDefinition 49
π父 fiberfiber.parent.fiberDefinition 49
τ退休标记(无显式字段;由 loader 的 disabled 与 fiber 卸载表达)Definition 49
inertia转移在飞fiber.inertia§4.4
O-Insert / O-Retire插入 / 退役ctx.plugin() / fiber.dispose()Definition 52
L-Leave / L-Unload停止供出 / 跑累加器_setEpoch 置 UNLOADING / _unload()§4.2.2
guard撤销守卫provide() disposer 里的 allSettled(await)Definition 54

附录 C · 概念 → 代码索引

按「机制」而不是按文件组织,方便倒查。文件根目录是 ~/project/dsh-official;cordis 核心在 vendor/cordis/src/。

概念 → 代码索引(根目录 ~/project/dsh-official)
机制 / 论文概念位置
效果收集与四种形状(函数/Promise/同步迭代器/异步迭代器)fiber.ts:356-399
异步迭代器的 epoch 守卫(= L-Divert 的中止支)fiber.ts:389-390
单个 effect 内部的逆序串行释放(= Theorem 16)fiber.ts:427-442
卸载期拒绝创建 effect(本地加固)fiber.ts:419-422
effect 的 reentrant 处置:setupBarrier / setupFailed / inFlightfiber.ts:459-560
FiberState 六态枚举fiber.ts:139-154
子 fiber 的创建:注册为父的一次 effect(= Definition 52)fiber.ts:265-320
依赖解析 _checkImpl(strict:只认 ACTIVE 的提供者)fiber.ts:597-609
target 摘要 epoch(= Definition 53)fiber.ts:611-623
状态机入口 _setEpoch(惯性互斥 + 两条链式)fiber.ts:625-639
装载:提交视图 → 执行效果fiber.ts:646-673
卸载:并发清理 → 丢弃视图 → 可能链回装载fiber.ts:675-696
FAILED:错误进 _error、epoch 置 INACTIVE、不向父传播fiber.ts:656-660, 574-579
await()/restart()/update() + internal/update waterfallfiber.ts:704-753
上下文代理解析(向上爬 fiber 链,见 Algorithm 6)reflect.ts:135-171
服务读取(严格模式)与就地覆盖(不通知)reflect.ts:233-265
provide + 撤销守卫(Theorem 70 的四步)reflect.ts:277-305
notify:反应式重算 + realm 过滤reflect.ts:314-336
isolate / intercept 的派生实现(零 disposer)context.ts:96-145
Service 基类(构造即 provide)service.ts:42-59
拦截配置合并(祖先在前,右偏)service.ts:86-102
事件分发五模式(emit/waterfall/parallel/serial/bail)events.ts:183-243
监听器本身是一个 effectevents.ts:254-260
internal/* 拦截点声明(plugin/status/service/config/update/get/set/listener/dispatch)events.ts:329-352
DisposableList(O(1) 删除 + clear 时反转)utils.ts:5-40
uid 计数器(自增 getter,读即分配)registry.ts:207
插件注册入口 registry.plugin(返回 thenable)registry.ts:316-336
Loader:Entry.update 的 diff 与四条分支loader/src/config/entry.ts:142-246
Loader:Group 的事务更新(并发启动 + 逆序回滚)loader/src/config/group.ts:59-106
Loader:realm 重指派的分隔符算法(= Algorithm 7 / 式 64)loader/src/config/isolate.ts:96-153
Loader:任务排空与模块 importloader/src/config/tree.ts:36-63, 144-162
Include:patch 覆盖层语义(唯一实现,离线工具复用)include/src/index.ts:58-128
Include:事务性 refresh 与提交点include/src/index.ts:301-321
HMR:双 watcher(主 / 精确配置)+ ignoreInitial 抑制hmr/src/index.ts:134-186, 228-274
HMR:模块图分类(Algorithm 8)hmr/src/index.ts:345-398
HMR:陈旧条目检测(Algorithm 9)hmr/src/index.ts:400-443
HMR:双缓存备份 + 事务回滚(Algorithm 10)hmr/src/index.ts:461-545
HMR:内部 loader 形状探测(v1/v2,不按版本号)loader/src/internal.ts:131-143
DSH:模型面向的 7 个 Cordis 工具packages/extensions/tool-cordis/src/index.ts:44-382
DSH:沙箱 ctx 门面(能力白名单 + 未声明即拒)packages/extensions/cordis-host-runner/src/guard.ts:636-819
DSH:node:vm 沙箱与 Node-API 陷阱(require/fetch/timers)packages/extensions/cordis-host-runner/src/sandbox.ts:96-145
DSH:host half 的启动与「等待依赖」判定packages/extensions/cordis-host-runner/src/lifecycle.ts:27-57
DSH:本地偏离清单 19 条(含生命周期加固与事务化协调)vendor/README.md:29-51

附录 D · 方法与边界

这篇分析依据了什么
  • 论文全文的文本抽取(pdftotext -layout,92 页,含全部证明与表格),逐节阅读;
  • vendor/cordis/src 全部 9 个文件通读,loader / hmr / include 的关键路径逐行阅读;
  • dsh 侧四个 cordis 扩展包与 docs/architecture.md、docs/cordis-primer.md、生成式 API 目录;
  • 最有价值的一份材料:vendor/README.md 的「Local modifications」清单(19 条)——它记录了上游与本地行为的精确边界,也是本文第 06 节的主要证据。
这篇分析没有做什么
  • 没有验证证明本身。论文的数学我按文本理解并转述,没有逐条检查证明的每一步(尤其是 Theorem 73 的终止性界与 Lemma 67 的纠缠步分析,那两处技术性最强)。
  • 没有跑实验。所有关于行为与性能的论断都来自代码结构与 dsh 自带的测试契约(引用了 config-reload.spec.ts 等),不是我自己实测的。
  • 没有比对上游。论文用的是哪一版命名我没有独立证据(仓库无法联网拉上游),落差 11 的结论以「与 4.0.2 不一致」为限。
  • 没有覆盖 dsh 的全部用法。1,635 处 import 我只做了符号统计与抽样阅读,重点是框架层与四个扩展包。
一处需要读者自己判断的地方

第 06 节的「落差」是我按「论文承诺 × 代码事实」的对照写出来的,其中「影响」的排序带有我的判断。特别是落差 02(见证不校验)与落差 01(观测等价有盲区),论文自己都写明了,严格说不算「论文没说」,更准确的说法是「论文写在了正文的边角,而它们是全部结论的实际承重点」。我把它们排在最前面,是因为对使用者而言它们决定了这套东西能不能被信任到什么程度。