dsh-plugin-guide 0.3.42 → 0.4.1

package/references/official-docs/docs/cordis-tutorial/01-first-plugin.zh.md

@@ -1,95 +0,0 @@
-# 1. 编写第一个插件
-
-[English](01-first-plugin.md) | 中文
-
-在本教程使用的 loader 配置中，Cordis 插件模块通过命名导出提供 `apply` 函数。Cordis 加载模块时，会用一个 **上下文** 调用 `apply`；该上下文就是 `ctx` 对象，插件通过它注册自己贡献的所有内容。
-
-## 编写插件
-
-在 `tmp/cordis-tutorial` 目录中（参见[环境设置](index.zh.md#setup)）创建 `hello.ts`：
-
-```ts
-import type { Context } from '@deepseek-ai/cordis'
-
-export const name = 'hello'
-
-export function apply(ctx: Context) {
-  console.log('hello from my first plugin')
-}
-```
-
-`name` 导出项是可选的显示元数据；它用于在诊断信息中标识插件。
-
-## 组合应用
-
-本教程的启动器通过配置组装应用。创建 `cordis.yml`：
-
-```yaml
-- name: './hello.ts'
-```
-
-该文件是一组 Cordis 配置项的列表。`name` 是模块指定符，可以是相对路径或 NPM 包名；loader 会挂载每个配置项。各项会并发启动，因此它们在列表中的位置不保证插件的加载先后；顺序由服务依赖（`inject`，参见[第 3 章](03-services.zh.md)）决定，而非文件中的位置。
-
-## 运行
-
-```sh
-node --import tsx ../../vendor/cordis/bin.js
-```
-
-预期输出：
-
-```
-hello from my first plugin
-```
-
-当没有任何内容继续运行时，进程会自行退出。具体过程如下：
-
-1. 启动器创建根 `Context`，并挂载 **Loader** 插件。
-2. Loader 读取 `cordis.yml`，解析 `./hello.ts`，然后将其作为子插件挂载。
-3. Cordis 调用你的 `apply(ctx)`。
-
-你的文件中没有框架启动代码：插件描述自己的贡献，`cordis.yml` 则组合应用。例如，[`dsh` base](../../packages/bundle/base/cordis.patch.yml) 就是一份更长的插件组合，由部署 overlay 对它进行修补。
-
-## 其他两种插件形态
-
-函数是最常见的形式，但 Cordis 接受三种形式：
-
-```ts
-import { Service, type Context } from '@deepseek-ai/cordis'
-
-// 1. Function plugin (what you just wrote).
-export function apply(ctx: Context) {}
-
-// 2. Object plugin: an object with an `apply` method.
-export const objectPlugin = {
-  name: 'object-plugin',
-  apply(ctx: Context) {},
-}
-
-// 3. Class plugin: a Service subclass (covered in chapter 3).
-export class MyService extends Service {
-  constructor(ctx: Context) {
-    super(ctx, 'myTutorialService')
-  }
-}
-```
-
-在你需要公开服务之前，请一直使用函数形态；[第 3 章](03-services.zh.md)介绍了何时应当使用类形态。
-
-## 尝试制造错误
-
-让 `apply` 抛出异常：
-
-```ts ignore-check
-export function apply(ctx: Context) {
-  throw new Error('apply exploded')
-}
-```
-
-再次运行：进程会因该错误而终止。插件加载失败会明确报错，不会仅跳过该配置项。
-
-还需要尽早了解一个例外：如果某个配置项的模块无法被 **解析**，例如路径或包名拼写错误，Cordis 会通过 logger 服务报告错误，而不会使进程崩溃。在启动阶段，这条报告可能在 console 导出器开始观察之前丢失。如果新增配置项似乎没有任何效果，请先检查拼写。
-
-下一章：[生命周期与 effect](02-lifecycle-and-effects.zh.md)：插件卸载时会发生什么。
-
-[![](https://img.shields.io/badge/powered_by-dsh-4D6BFE?style=flat-square&logo=deepseek&logoColor=white)](https://github.com/deepseek-ai/deepseek-harness)

package/references/official-docs/docs/cordis-tutorial/02-lifecycle-and-effects.i18n.yaml

@@ -1,16 +0,0 @@
-# Bilingual-pair consistency record for 02-lifecycle-and-effects.md (docs/i18n/README.md): per heading
-# section, a hash of its English and Chinese blocks outside code blocks and generated regions.
-# After editing either side, bring the other along and re-record with:
-#   pnpm run verify-translation-pairing --write docs/cordis-tutorial/02-lifecycle-and-effects.md
-/2-lifecycle-and-effects:
-  en: d8936e9239303f91
-  zh: ee5a15bead15f7fa
-/2-lifecycle-and-effects/effects:
-  en: 2405133f23696f0e
-  zh: 30bcd69cba560176
-/2-lifecycle-and-effects/the-fiber-state-machine:
-  en: fe65d99ee289a273
-  zh: ee5cc95f67a2bc4c
-/2-lifecycle-and-effects/what-is-already-an-effect:
-  en: e986a639aac5eaff
-  zh: 8f907581f5725119

package/references/official-docs/docs/cordis-tutorial/02-lifecycle-and-effects.md

@@ -1,98 +0,0 @@
-# 2. Lifecycle and effects
-
-English | [中文](02-lifecycle-and-effects.zh.md)
-
-A Cordis plugin can be unloaded by a config edit, hot reload, explicit disposal, or loss of a required service. Registrations made through Cordis APIs are effects and are undone when their owning plugin unloads; resources managed outside those APIs must be wrapped in `ctx.effect()`.
-
-## Effects
-
-For a resource Cordis does not already manage — a timer, a connection, a watcher — wrap it in `ctx.effect()` and return a disposer:
-
-Create `lifecycle.ts` in `tmp/cordis-tutorial`:
-
-```ts
-import type { Context } from '@deepseek-ai/cordis'
-
-export const name = 'lifecycle-demo'
-
-function heartbeat(ctx: Context) {
-  console.log('heartbeat plugin loading')
-  ctx.effect(() => {
-    const timer = setInterval(() => console.log('tick'), 200)
-    return () => {
-      clearInterval(timer)
-      console.log('heartbeat cleaned up')
-    }
-  })
-}
-
-export function apply(ctx: Context) {
-  // Mount a child plugin and keep its fiber to dispose it later.
-  const fiber = ctx.plugin(heartbeat)
-  // The demo timer is itself an effect: if THIS plugin is unloaded first,
-  // the pending callback is cancelled instead of firing on a dead app.
-  ctx.effect(() => {
-    const timer = setTimeout(async () => {
-      await fiber.dispose()
-      console.log('disposed')
-      process.exit(0)
-    }, 700)
-    return () => clearTimeout(timer)
-  })
-}
-```
-
-Point `cordis.yml` at it:
-
-```yaml
-- name: './lifecycle.ts'
-```
-
-Run (`node --import tsx ../../vendor/cordis/bin.js`) and you get:
-
-```
-heartbeat plugin loading
-tick
-tick
-tick
-heartbeat cleaned up
-disposed
-```
-
-Three things to notice:
-
-- `ctx.plugin(heartbeat)` mounts a function **from code** as a plugin — the same operation the YAML loader performs for each config entry. A function plugin needs no `apply` method: Cordis calls the function directly and uses its name only for diagnostics. An `apply` method is required only for the object form, `ctx.plugin({ apply(ctx) { /* ... */ } })`. The call returns a **fiber**, the runtime handle for one loaded plugin instance.
-- The effect body runs during load; the disposer it returns runs during unload. You never call the disposer yourself for a plugin-lifetime resource.
-- `fiber.dispose()` resolves after all of the plugin's cleanup — including async disposers — has finished, and recursively unloads any child plugins it mounted.
-
-## The fiber state machine
-
-Every loaded plugin instance owns a fiber that moves through these states:
-
-```
-PENDING → LOADING → ACTIVE → UNLOADING → DISPOSED
-                 ↘ FAILED
-```
-
-- **PENDING** — declared, but a required service (chapter 3) is not available yet.
-- **LOADING / ACTIVE** — `apply` is running / has completed.
-- **FAILED** — `apply` or config validation threw.
-- **UNLOADING / DISPOSED** — disposers are running / everything is torn down.
-
-You will meet PENDING again in [chapter 6](06-composition-and-hmr.md), where it is the usual answer to "why does my plugin print nothing?".
-
-## What is already an effect
-
-You rarely write `ctx.effect()` yourself, because the built-in registration APIs are effects already:
-
-- `ctx.on(event, listener)` — the listener is removed on unload ([chapter 4](04-events.md)).
-- `ctx.plugin(child)` — the child is disposed with its parent.
-- Service registrations are effects. Harness registries such as `ctx.tools.register(...)` also attach their returned disposers to the calling plugin, so they unwind automatically ([chapter 7](07-into-the-harness.md)).
-
-For a resource Cordis does not manage, acquire it inside `ctx.effect()` and return a disposer that releases it. Cordis then invokes that release during unloading, including hot reload.
-
-One ordering caveat: disposers start in reverse registration order, but multiple **async** disposers run concurrently. If teardown steps must run in sequence, keep them in one disposer and await them there.
-
-Next: [Services](03-services.md) — how plugins share capabilities.
-
-[![](https://img.shields.io/badge/powered_by-dsh-4D6BFE?style=flat-square&logo=deepseek&logoColor=white)](https://github.com/deepseek-ai/deepseek-harness)

package/references/official-docs/docs/cordis-tutorial/02-lifecycle-and-effects.zh.md

@@ -1,98 +0,0 @@
-# 2. 生命周期与 effect
-
-[English](02-lifecycle-and-effects.md) | 中文
-
-Cordis 插件可能因修改配置、热重载、显式资源释放或所需服务消失而卸载。通过 Cordis API 建立的注册属于 effect，会在所属插件卸载时撤销；在这些 API 之外管理的资源必须包装在 `ctx.effect()` 中。
-
-## Effect
-
-对于 Cordis 尚未管理的资源，例如定时器、连接或 watcher，应将其包装在 `ctx.effect()` 中并返回 disposer（资源释放函数）：
-
-创建 `lifecycle.ts`，将它放在 `tmp/cordis-tutorial` 中：
-
-```ts
-import type { Context } from '@deepseek-ai/cordis'
-
-export const name = 'lifecycle-demo'
-
-function heartbeat(ctx: Context) {
-  console.log('heartbeat plugin loading')
-  ctx.effect(() => {
-    const timer = setInterval(() => console.log('tick'), 200)
-    return () => {
-      clearInterval(timer)
-      console.log('heartbeat cleaned up')
-    }
-  })
-}
-
-export function apply(ctx: Context) {
-  // Mount a child plugin and keep its fiber to dispose it later.
-  const fiber = ctx.plugin(heartbeat)
-  // The demo timer is itself an effect: if THIS plugin is unloaded first,
-  // the pending callback is cancelled instead of firing on a dead app.
-  ctx.effect(() => {
-    const timer = setTimeout(async () => {
-      await fiber.dispose()
-      console.log('disposed')
-      process.exit(0)
-    }, 700)
-    return () => clearTimeout(timer)
-  })
-}
-```
-
-让 `cordis.yml` 指向该文件：
-
-```yaml
-- name: './lifecycle.ts'
-```
-
-运行（`node --import tsx ../../vendor/cordis/bin.js`）后会得到：
-
-```
-heartbeat plugin loading
-tick
-tick
-tick
-heartbeat cleaned up
-disposed
-```
-
-请留意三点：
-
-- `ctx.plugin(heartbeat)` 会把一个**来自代码**的函数挂载为插件，这与 YAML loader 为每个配置项执行的操作相同。函数插件不需要 `apply` 方法：Cordis 会直接调用该函数，其名称只用于诊断。只有对象形态才要求 `apply` 方法，例如 `ctx.plugin({ apply(ctx) { /* ... */ } })`。调用会返回一个 **fiber**，即一个已加载插件实例的运行时句柄。
-- effect 主体在加载期间运行；它返回的 disposer 在卸载期间运行。对于生命周期与插件一致的资源，你绝不需要自行调用 disposer。
-- `fiber.dispose()` 会等该插件的所有清理工作（包括异步 disposer）完成后才结束，并递归卸载它挂载的所有子插件。
-
-## Fiber 状态机
-
-每个已加载插件实例都拥有一个 fiber，并在以下状态之间转换：
-
-```
-PENDING → LOADING → ACTIVE → UNLOADING → DISPOSED
-                 ↘ FAILED
-```
-
-- **PENDING**：已经声明，但所需服务（第 3 章）尚不可用。
-- **LOADING / ACTIVE**：`apply` 正在运行／已经完成。
-- **FAILED**：`apply` 或配置校验抛出异常。
-- **UNLOADING / DISPOSED**：disposer 正在运行／一切均已拆除。
-
-你会在[第 6 章](06-composition-and-hmr.zh.md)再次遇到 PENDING，它通常就是「为什么我的插件没有输出」的答案。
-
-## 已经属于 effect 的操作
-
-你很少需要亲自编写 `ctx.effect()`，因为内置注册 API 本身已经是 effect：
-
-- `ctx.on(event, listener)`：监听器会在卸载时移除（[第 4 章](04-events.zh.md)）。
-- `ctx.plugin(child)`：子插件会随父插件一同 dispose（资源释放）。
-- 服务注册属于 effect。`ctx.tools.register(...)` 等 harness 注册表也会把返回的 disposer 附着到调用插件上，因此会自动撤销（[第 7 章](07-into-the-harness.zh.md)）。
-
-对于 Cordis 不管理的资源，应在 `ctx.effect()` 内获取它，并返回用于释放资源的 disposer。此后 Cordis 会在卸载期间调用该释放逻辑，热重载时也不例外。
-
-有一项顺序注意事项：disposer 会按注册顺序的逆序启动，但多个**异步** disposer 会并发运行。如果拆除步骤必须按顺序执行，请把它们放在同一个 disposer 中，并在其中依次等待每步完成。
-
-下一章：[服务](03-services.zh.md)：插件如何共享功能。
-
-[![](https://img.shields.io/badge/powered_by-dsh-4D6BFE?style=flat-square&logo=deepseek&logoColor=white)](https://github.com/deepseek-ai/deepseek-harness)

package/references/official-docs/docs/cordis-tutorial/03-services.i18n.yaml

@@ -1,22 +0,0 @@
-# Bilingual-pair consistency record for 03-services.md (docs/i18n/README.md): per heading
-# section, a hash of its English and Chinese blocks outside code blocks and generated regions.
-# After editing either side, bring the other along and re-record with:
-#   pnpm run verify-translation-pairing --write docs/cordis-tutorial/03-services.md
-/3-services:
-  en: 15915c1948e99dcd
-  zh: 769f50dcd06a1c6e
-/3-services/provide-a-service:
-  en: dafc130ada001863
-  zh: 820921c32e8ce5fe
-/3-services/consume-a-service-with-inject:
-  en: 1b4faa79ebc5e3d7
-  zh: 5170a8291e4aaf34
-/3-services/dependencies-are-tracked-after-load:
-  en: 5cadb845bd8ebdb3
-  zh: cce559c73d7bda66
-/3-services/optional-dependencies:
-  en: f765739ab1e2061a
-  zh: 71ddc054022b66a9
-/3-services/naming:
-  en: 11dfa5c4f8aed0e0
-  zh: d28f7c86f58cdf3e

package/references/official-docs/docs/cordis-tutorial/03-services.md

@@ -1,98 +0,0 @@
-# 3. Services
-
-English | [中文](03-services.zh.md)
-
-A **service** is a named capability one plugin provides and other plugins consume through `ctx`. In the harness, `ctx.tools`, `ctx.llm`, and `ctx.agents` are services. A consumer names the capability, such as `'tools'`, rather than importing its provider, so configuration can select a provider without changing the consumer.
-
-## Provide a service
-
-Create `greeter.ts` in `tmp/cordis-tutorial`:
-
-```ts
-import { Service, type Context } from '@deepseek-ai/cordis'
-
-declare module '@deepseek-ai/cordis' {
-  interface Context {
-    greeter: GreeterService
-  }
-}
-
-export class GreeterService extends Service {
-  constructor(ctx: Context) {
-    super(ctx, 'greeter')
-  }
-
-  greet(who: string) {
-    return `Hello, ${who}!`
-  }
-}
-
-export const name = 'greeter'
-
-export function apply(ctx: Context) {
-  ctx.plugin(GreeterService)
-}
-```
-
-Two pieces work together:
-
-- **Runtime**: `super(ctx, 'greeter')` registers the instance under the name `greeter`. From then on, any plugin can reach it as `ctx.greeter`. The registration is an effect — unloading the provider removes the service.
-- **Compile time**: the `declare module '@deepseek-ai/cordis'` block is TypeScript declaration merging. It adds `greeter` to the `Context` interface so `ctx.greeter` typechecks everywhere. It generates no code; without it the service still works at runtime, but consumers lose type safety.
-
-A `Service` subclass is itself a plugin (the class form from chapter 1), so `ctx.plugin(GreeterService)` mounts it like any other.
-
-## Consume a service with `inject`
-
-Create `consumer.ts`:
-
-```ts
-import type { Context } from '@deepseek-ai/cordis'
-
-export const name = 'consumer'
-export const inject = ['greeter']
-
-export function apply(ctx: Context) {
-  console.log(ctx.greeter.greet('world'))
-}
-```
-
-`inject` lists the services this plugin requires. Cordis holds the plugin in PENDING until every listed service exists, so inside `apply`, `ctx.greeter` is guaranteed ready. Load order in `cordis.yml` does not matter — dependencies, not file order, decide when plugins start.
-
-Compose and run:
-
-```yaml
-- name: './greeter.ts'
-- name: './consumer.ts'
-```
-
-```
-Hello, world!
-```
-
-Swap the two lines in `cordis.yml` and rerun: same output. Try removing `./greeter.ts` entirely: the consumer stays PENDING and prints nothing — no crash, no partial run. A PENDING fiber does not keep Node's event loop alive either, so a composition with nothing else running exits 0 silently. [Chapter 6](06-composition-and-hmr.md) shows how to diagnose that state.
-
-## Dependencies are tracked after load
-
-`inject` is not a one-shot boot check. If a required service disappears while the app runs — its provider was unloaded or hot-replaced — every dependent plugin is unloaded too, and loads again when the service returns. Combined with effects ([chapter 2](02-lifecycle-and-effects.md)), this prevents a running consumer from retaining a reference to an unavailable service: its own registrations are unwound when the dependency disappears.
-
-This is also why service replacement works in config: unload the `dsh-bash-local` entry, mount a different `shell` provider, and every plugin injecting `'shell'` cleanly restarts against the new implementation.
-
-## Optional dependencies
-
-`inject` is for hard requirements. For a capability the plugin can live without, skip `inject` and probe at the use site:
-
-```ts ignore-check
-export function apply(ctx: Context) {
-  // undefined when no provider is loaded; the plugin still runs.
-  const greeter = ctx.get('greeter')
-  console.log(greeter?.greet('maybe') ?? 'no greeter available')
-}
-```
-
-## Naming
-
-Service names live in one flat namespace per application. Prefix or namespace your own services distinctively (the harness claims plain names like `tools` and `llm`); the generated `cordis-surface` regions on the [subsystem pages](../subsystems/core.md) list every name the harness registers.
-
-Next: [Events](04-events.md) — communication without a shared service.
-
-[![](https://img.shields.io/badge/powered_by-dsh-4D6BFE?style=flat-square&logo=deepseek&logoColor=white)](https://github.com/deepseek-ai/deepseek-harness)

package/references/official-docs/docs/cordis-tutorial/03-services.zh.md

@@ -1,98 +0,0 @@
-# 3. 服务
-
-[English](03-services.md) | 中文
-
-**服务**是一个插件提供、其他插件通过 `ctx` 消费的具名能力。在 harness 中，`ctx.tools`、`ctx.llm` 和 `ctx.agents` 都是服务。消费方只指定 `'tools'` 之类的能力，而不导入其提供方，因此配置可以选择提供方，无需修改消费方。
-
-## 提供服务
-
-创建 `greeter.ts`，将它放在 `tmp/cordis-tutorial` 中：
-
-```ts
-import { Service, type Context } from '@deepseek-ai/cordis'
-
-declare module '@deepseek-ai/cordis' {
-  interface Context {
-    greeter: GreeterService
-  }
-}
-
-export class GreeterService extends Service {
-  constructor(ctx: Context) {
-    super(ctx, 'greeter')
-  }
-
-  greet(who: string) {
-    return `Hello, ${who}!`
-  }
-}
-
-export const name = 'greeter'
-
-export function apply(ctx: Context) {
-  ctx.plugin(GreeterService)
-}
-```
-
-两部分协同工作：
-
-- **运行时**：`super(ctx, 'greeter')` 以名称 `greeter` 注册该实例。此后，任何插件都可以通过 `ctx.greeter` 访问它。注册属于 effect，卸载提供方时会移除该服务。
-- **编译时**：`declare module '@deepseek-ai/cordis'` 块使用 TypeScript 声明合并，把 `greeter` 加入 `Context` 接口，使 `ctx.greeter` 在各处都能通过类型检查。它不会生成代码；没有该声明时，服务在运行时仍能工作，但消费方会失去类型安全。
-
-`Service` 子类本身就是插件（第 1 章介绍的类形态），因此 `ctx.plugin(GreeterService)` 会像挂载其他插件一样挂载它。
-
-## 使用 `inject` 消费服务
-
-创建 `consumer.ts`：
-
-```ts
-import type { Context } from '@deepseek-ai/cordis'
-
-export const name = 'consumer'
-export const inject = ['greeter']
-
-export function apply(ctx: Context) {
-  console.log(ctx.greeter.greet('world'))
-}
-```
-
-`inject` 列出该插件需要的服务。Cordis 会让插件保持 PENDING，直到列出的每项服务都存在，因此在 `apply` 内可以保证 `ctx.greeter` 已经就绪。`cordis.yml` 中的加载顺序无关紧要：决定插件何时启动的是依赖关系，而不是文件顺序。
-
-组合并运行：
-
-```yaml
-- name: './greeter.ts'
-- name: './consumer.ts'
-```
-
-```
-Hello, world!
-```
-
-交换 `cordis.yml` 中两行的顺序后重新运行，输出仍然相同。尝试彻底移除 `./greeter.ts`：消费方会保持 PENDING，不输出任何内容，既不崩溃，也不会只运行一部分。处于 PENDING 的 fiber 也不会让 Node 的事件循环保持活跃，因此如果组合中没有其他运行项，进程会静默地以状态码 0 退出。[第 6 章](06-composition-and-hmr.zh.md)介绍如何诊断这种状态。
-
-## 加载后仍会跟踪依赖关系
-
-`inject` 并非一次性的启动检查。如果应用运行期间所需服务消失，例如提供方被卸载或热替换，每个依赖插件也会随之卸载，并在服务恢复后再次加载。结合 effect（[第 2 章](02-lifecycle-and-effects.zh.md)），这能防止运行中的消费方保留对不可用服务的引用：依赖消失时，它自己的注册也会撤销。
-
-这也是配置中可以替换服务的原因：卸载 Cordis 配置项 `dsh-bash-local`，挂载另一个 `shell` 提供方，所有注入 `'shell'` 的插件都会重新启动并使用新实现。
-
-## 可选依赖
-
-`inject` 用于硬性依赖。如果某项功能缺失时插件仍可运行，请跳过 `inject`，并在使用处探测：
-
-```ts ignore-check
-export function apply(ctx: Context) {
-  // undefined when no provider is loaded; the plugin still runs.
-  const greeter = ctx.get('greeter')
-  console.log(greeter?.greet('maybe') ?? 'no greeter available')
-}
-```
-
-## 命名
-
-每个应用中的服务名称共用一个扁平命名空间。请为自有服务添加有辨识度的前缀或命名空间（harness 已占用 `tools` 和 `llm` 等普通名称）；[子系统页面](../subsystems/core.zh.md)上生成的 `cordis-surface` 区块列出 harness 注册的每个名称。
-
-下一章：[事件](04-events.zh.md)：无需共享服务即可通信。
-
-[![](https://img.shields.io/badge/powered_by-dsh-4D6BFE?style=flat-square&logo=deepseek&logoColor=white)](https://github.com/deepseek-ai/deepseek-harness)

package/references/official-docs/docs/cordis-tutorial/04-events.i18n.yaml

@@ -1,16 +0,0 @@
-# Bilingual-pair consistency record for 04-events.md (docs/i18n/README.md): per heading
-# section, a hash of its English and Chinese blocks outside code blocks and generated regions.
-# After editing either side, bring the other along and re-record with:
-#   pnpm run verify-translation-pairing --write docs/cordis-tutorial/04-events.md
-/4-events:
-  en: c0d426252aeee143
-  zh: a9d91f2ef46e2d3b
-/4-events/declare-emit-listen:
-  en: a5b9207a435caf1f
-  zh: 3e06d12249fb712e
-/4-events/dispatch-modes:
-  en: 24799f579b04b2d4
-  zh: 97d4d82dc3a02c75
-/4-events/waterfall-transform-or-short-circuit:
-  en: 8309aea415b395c3
-  zh: 480ee4a163543dd0