dsl/_router.py 的核心（flow/dsl/_router.py:142）：

# flow/dsl/_router.py:142
def decorator(func: Callable[P, R]) -> RouterMethod[P, R]:
    wrapper = RouterMethod(func)

    if emit is not None:
        router_events = _normalize_router_emit(emit)      # 显式给了 emit
    else:
        router_events = _get_router_return_events(func) or []  # 否则从返回注解推

    method_definition_kwargs: dict[str, Any] = {
        "do": _method_action(func),
        "router": True,                                   # ★标记为路由
        "emit": router_events or None,                    # 可能吐出的事件名列表
    }
    if condition is not None:
        method_definition_kwargs["listen"] = _to_definition_condition(condition)

    _merge_flow_method_definition(wrapper, FlowMethodDefinition(**method_definition_kwargs))
    return wrapper

不显式写 emit 时，从函数的返回注解里抠（flow/dsl/_router.py:86）：

# flow/dsl/_router.py:86
def _get_router_return_events(function: Any) -> list[str] | None:
    values = _string_values_from_annotation(_return_annotation(function))
    return list(dict.fromkeys(values)) if values else None   # 去重、保序

# :45（节选）从 Literal / Enum / Union 注解里提取字符串常量
def _string_values_from_annotation(annotation: Any) -> list[str]:
    if isinstance(annotation, type) and issubclass(annotation, Enum):
        return [m.value for m in annotation if isinstance(m.value, str)]   # 枚举 → 取值
    origin = get_origin(annotation)
    ...
    if origin is Literal or getattr(origin, "__name__", "") == "Literal":
        return [arg for arg in args if isinstance(arg, str)]               # Literal → 取字面量
    ...

一个方法完成后，_execute_listeners 先把所有 router 处理完（runtime/__init__.py:2751）：

# runtime/__init__.py:2751
router_results = []
current_trigger = trigger_method
current_result = result

while True:                                              # ★循环处理 router
    routers_triggered = self._find_triggered_methods(
        current_trigger, router_only=True)              # 只找被当前触发点触发的 router
    if not routers_triggered:
        break                                           # 没有 router 了 → 退出

    for router_name in routers_triggered:
        router_result, current_triggering_event_id = await self._execute_single_listener(
            router_name, router_input, current_triggering_event_id)  # 跑这个 router
        if router_result is None:
            current_trigger = FlowMethodName(""); continue
        router_result = router_result.value if isinstance(router_result, enum.Enum) else router_result
        router_result_event = FlowMethodName(str(router_result))     # ★返回值 → 事件名
        router_results.append(router_result_event)
        current_trigger = router_result_event           # 路由结果又可能触发下一个 router

router 处理完，把"原触发点 + 所有路由结果"合成触发列表，逐个找 listener（runtime/__init__.py:2803）：

# runtime/__init__.py:2803
all_triggers = [trigger_method, *router_results]        # 原触发点 + 路由吐出的事件

for idx, current_trigger in enumerate(all_triggers):
    if current_trigger:
        listeners_triggered = self._find_triggered_methods(
            current_trigger, router_only=False)         # ★这次只找普通 listener
        if listeners_triggered:
            listener_result = router_result_payloads.get(str(current_trigger), result)
            ...
            tasks = [self._execute_single_listener(name, listener_result, ...)
                     for name in listeners_triggered]
            await asyncio.gather(*tasks)                # ★普通 listener 并行执行

D42 的条件树，在这里被真正"求值"（runtime/__init__.py:172）：

# runtime/__init__.py:172
def _condition_satisfied(condition: FlowDefinitionCondition, events: set[str]) -> bool:
    if isinstance(condition, str):
        return condition in events               # 叶子：这个事件出现过吗？
    operator, branches = _condition_branches(condition)   # "and" / "or"
    combine = all if operator == "and" else any
    return combine(_condition_satisfied(branch, events) for branch in branches)  # 递归

而"是否满足"要靠累积已见事件来判断（runtime/__init__.py:2860）：

# runtime/__init__.py:2860
def _condition_met(self, condition, trigger_method, subscription_key) -> bool:
    seen = self._pending_events.setdefault(subscription_key, set())
    seen.add(str(trigger_method))                # ★记下"这个 listener 又收到了一个事件"
    if not _condition_satisfied(condition, seen):
        return False                             # 还没集齐 → 先不触发
    del self._pending_events[subscription_key]   # 集齐了 → 清空、准备下次
    return True

路由结果如果能触发一个 @start(条件)，引擎会重新执行那个起点——这就是循环（runtime/__init__.py:2846）：

# runtime/__init__.py:2846
if current_trigger in router_results:
    for method_name in self._start_method_names():
        if self._start_condition_triggered_by(method_name, current_trigger):
            if method_name in self._completed_methods:
                # ★循环重执行：临时清掉"恢复中"标志，让方法真的再跑一遍
                was_resuming = self._is_execution_resuming
                self._is_execution_resuming = False
                await self._execute_start_method(method_name)
                self._is_execution_resuming = was_resuming
            else:
                await self._execute_start_method(method_name)