weifuwu 0.87.0 → 0.89.0

package/dist/client/vdom/browser/Browser.d.ts

@@ -36,6 +36,8 @@ export interface Browser {
     /** 事件监听（全局——组件层统一入口） */
     addEventListener(type: string, fn: (e: any) => void, options?: any): void;
     removeEventListener(type: string, fn: (e: any) => void, options?: any): void;
+    /** 页面刷新（location.reload——应用层重试/回滚后刷新） */
+    reload(): void;
     /** 滚动 */
     scrollTo(y: number): void;
     /** 当前滚动量（scrollingElement 优先——headless 漂移防护） */

package/dist/client/vdom/commands.d.ts

@@ -11,7 +11,10 @@
  * 使用：应用装配（main.tsx）注入 ctx——`ctx.toast('...')` 任意位置调用。
  */
 export type ToastType = 'success' | 'error' | 'info' | 'warning';
-/** 命令式轻提示（vdom 引擎渲染——自动消失——独立容器） */
+/** 命令式轻提示（vdom 引擎渲染——自动消失——独立容器）
+ *  **自动消失定时器上流（波次 6——隐式时序歼灭）**：setTimeout 裸调用 →
+ *  create<number>((obs) => { obs.next(1); obs.complete(); return () => {} }).pipe(delay(duration))——生命周期在流上——不可达的裸
+ *  timer 消除（未来 close 面可直接 takeUntil——取消语义就位） */
 export declare function toast(message: string, type?: ToastType, duration?: number): void;
 /** 命令式注入（应用装配——ctx.toast） */
 export declare function injectCommands<C extends Record<string, unknown>>(ctx: C): C & {

package/dist/client/vdom/context/UIContext.d.ts

@@ -54,6 +54,14 @@ export interface UIContext {
     ui: Ui;
     /** 路由参数（页面组件——UIRouter 注入） */
     params?: Record<string, string>;
+    /** 查询参数（UIRouter 注入——Object.fromEntries(searchParams)——随渲染替换） */
+    query?: Record<string, string>;
+    /** 路由上下文（UIRouter resolve 注入——path/params/query 三面——应用消费单点） */
+    route?: {
+        path: string;
+        params: Record<string, string>;
+        query: Record<string, string>;
+    };
     /** 国际化（middlewares i18n 注入——可选——组件读组件文案面） */
     i18n?: import('../middlewares/auth-i18n.ts').I18nState;
     /** 中间件注入面（api/auth/ws/i18n...——可选链消费） */

package/dist/client/vdom/core/diff/attrs.d.ts

@@ -6,5 +6,13 @@
  */
 import type { VNode } from '../vnode.ts';
 import type { Command } from '../command/index.ts';
-/** 属性精准 diff（值比较——只发变化的键；函数面引用比较——prev 传递） */
-export declare function diffAttrs(oldV: VNode, newV: VNode, id: string, emitCommand: (cmd: Command) => void): void;
+/** 属性精准 diff（值比较——只发变化的键；函数面引用比较——prev 传递）
+ *
+ * **表单控件 value 特判（2027-09——输入残留实证）**：opts.formControl=true
+ * 时 value 键**总是发**（即使渲染树新旧等值）——用户打字/IME 直改 DOM
+ * 值（渲染树从不感知——打字零渲染类优化）——清空到 '' 时 diff 的旧渲染
+ * 树值可能同为 '' → 不发 → DOM 残留旧文本——总是发 + patch 端现值比较
+ * （同值不上 DOM——无副作用；异值必写——程序化清空/回流修复） */
+export declare function diffAttrs(oldV: VNode, newV: VNode, id: string, emitCommand: (cmd: Command) => void, opts?: {
+    formControl?: boolean;
+}): void;

package/dist/client/vdom/core/field/attributes.d.ts

@@ -11,5 +11,17 @@
  */
 /** enumerated 属性白名单（HTML 规范——空字符串语义非 true） */
 export declare const ENUMERATED_KEYS: Set<string>;
+/**
+ * aria-* 枚举语义属性布尔归一（ReasoningBlock CDD 实证——v1 修复 v2 迁移丢失——回归补）
+ *
+ * aria-* 是枚举语义属性（同 draggable）——boolean 必须显式 'true'/'false'：
+ * boolean attribute 空字符串分支会把 aria-expanded: true 落成 aria-expanded=""
+ * （读屏语义 = false——可访问性失效）；v === false 被移除同属错误
+ * （aria-expanded=false 与无属性语义不同面——状态不可丢失）。
+ * **单一实现源**：客户端 applyAttribute 与 SSR attrsToHtml 共用本判定。
+ *
+ * @returns 'true' / 'false'（命中 aria 布尔）或 null（非 aria 布尔——走原分支）
+ */
+export declare function ariaBoolValue(key: string, value: unknown): string | null;
 /** attribute 通道——单键应用 */
 export declare function applyAttribute(el: HTMLElement, key: string, value: unknown): void;

package/dist/client/vdom/core/field/events.d.ts

@@ -39,12 +39,20 @@ export declare class EventRegistry {
      *  与 remove(nodeId)（全子树删除）区分——只删一个 (nodeId, event) 对 */
     removeEvent(nodeId: string, event: string): void;
     /** 子树清理（id 前缀匹配——remove/done 卸载指令） */
+    /** 子树删除（全量前缀扫描——**P1 性能升级前**的 O(N²) 路径——保留供
+     *  非 procRemove 调用方（dispose 等）——proc 消费端改用 removeOne 循环） */
     remove(nodeId: string): void;
+    /** O(1) 单个节点删除（**P1 性能升级（2027-09——admin 全量 59s 实证）**：
+     *  procRemove 子树循环逐条调用——替代 remove（全量前缀扫描 × 16k 条
+     *  = O(N²)）——procDone 同步改造） */
+    removeOne(nodeId: string): void;
     /** 根监听动态注册（document 捕获——首次绑定某事件类型——容器过滤可达） */
     private ensureRoot;
     /** 分发（模拟冒泡——target 向上祖先链查表——currentTarget 还原——
      *  handler 内 stopPropagation 停止向上） */
     private dispatch;
+    /** **清表（监听保留——resetRoot 整树替换式重置用）** */
+    clear(): void;
     /** 卸载清理（移除全部根监听 + 清表）——状态机迁移：active → disposed */
     dispose(): void;
 }

package/dist/client/vdom/core/field/input-sync.d.ts

@@ -0,0 +1,14 @@
+/**
+ * vdom core/field — input-sync（输入 DOM 组合态跟踪——IME 安全）
+ *
+ * 背景（2027-09——value 键 DOM 脱节修复的配套）：diff 对表单控件 value
+ * 总是发 setProp——patch 写 DOM 前必须避开 **IME 组合中**（composition
+ * 期间渲染树 value = 组合前——强写会打断输入法候选——中文输入法中断）。
+ * 机制：document 捕获监听 composition 事件 → 组合中的元素 WeakSet——
+ * patch 写 value 前查询（组合中跳过——组合结束后的渲染自然写回）。
+ *
+ * 零泄漏（WeakSet——元素可回收）；模块级单例（document 唯一——懒挂
+ * 首次需要时——多次创建幂等）。
+ */
+/** 输入是否处于 IME 组合中（compositionstart ~ compositionend） */
+export declare function isComposingEl(doc: Document, el: HTMLElement): boolean;

package/dist/client/vdom/core/field/key.d.ts

@@ -10,6 +10,9 @@
  *   （数组长度变化 + 无 key 组件项 → dev error）在 diff 层消费
  */
 export declare const KEY = "key";
+/** key 归一化（单一实现源——jsx 显式 key 参数与 props 路径同入口——
+ *  数字 key 不归一 → keyedId 的 key.replace 崩（key 必须字符串）） */
+export declare function normalizeKey(k: unknown): string | null;
 /** key 提取（props → vnode.key——string|number 有效——其余 warn + null） */
 export declare function extractKey(props: Record<string, unknown> | null | undefined): string | null;
 /** 从 props 拷贝中剥离 key（h/jsx 用——props 不泄漏 key） */

package/dist/client/vdom/core/field/props.d.ts

@@ -11,5 +11,17 @@
 export declare const PROPERTY_KEYS: Set<string>;
 /** 是否走 property 通道 */
 export declare function isPropertyKey(key: string): boolean;
-/** property 应用（值直接赋给 DOM 节点属性） */
+/** property 应用（值直接赋给 DOM 节点属性）
+ *  **undefined 分区语义（2027-08——v2 直连 + v1 JSON 编解码等价对齐）**：
+ *  - value 类（value/defaultValue/innerHTML/textContent/defaultChecked——DOM
+ *    现值是唯一来源——§5.3 非受控）→ 不写（保持现值——防 "undefined" 污染
+ *    ——SearchInput 非受控实证）
+ *  - 布尔态（disabled/checked/selected/readOnly/multiple/required/…）→
+ *    false（解绑——Transfer 移到右侧按钮 disabled 残留实证——v1 JSON 丢
+ *    undefined 值同样落到本函数——分区语义两引擎一致）
+ *  - 其余 → 不写（保守）
+ *  **value 现值比较（2027-09——DOM 脱节修复消费端）**：diff 对表单控件
+ *  value 总是发——写前与 DOM 现值比较（同值不上 DOM——打字每键的差集
+ *  渲染零副作用）；**IME 组合中跳过**（compositionstart~end——组合期
+ *  渲染树 value=组合前——强写打断中文输入法）——组合结束后渲染写回 */
 export declare function applyProperty(el: HTMLElement, key: string, value: unknown): void;

package/dist/client/vdom/core/field/ref.d.ts

@@ -31,8 +31,14 @@ export declare class RefRegistry {
     mount(id: string, el: HTMLElement): void;
     /** 卸载（ref(null) 子树——前缀匹配——表删除） */
     unmount(id: string): void;
+    /** O(1) 单个 ref 卸载（**P1 性能升级（2027-09——admin 全量 59s 实证）**：
+     *  procRemove 子树循环逐条调用——替代 unmount（全量前缀扫描 × 16k 条
+     *  = O(N²)）——procDone 同步改造） */
+    unmountOne(id: string): void;
     /** move 前缀重映射（节点移动——id 路径变化——表跟随） */
     remap(oldPrefix: string, newPrefix: string): void;
+    /** **清表（serve 整树替换式重置用）** */
+    clear(): void;
     /** 卸载清理（serve unmount）——状态机迁移：active → disposed */
     dispose(): void;
 }

package/dist/client/vdom/core/field/style.d.ts

@@ -13,5 +13,11 @@
 export declare const UNITLESS_KEYS: Set<string>;
 /** 单值应用（kebab/camelCase 键——CSS 变量走 setProperty） */
 export declare function applyStyleValue(el: HTMLElement, key: string, value: unknown): void;
-/** style 应用（对象/字符串——整体替换语义） */
+/** style 应用（对象/字符串——整体替换语义）
+ *
+ * **undefined/null/false → 整体移除（2027-XX——Affix 卡 fixed 实证修复）**：
+ * diff 侧「旧有新无」发 setProp('style', undefined)——此前 undefined 分支
+ * 静默 no-op → 旧 style 残留（Affix 滚回顶 content 仍 position:fixed——
+ * sentinel --active 已移除而 inline style 残留——两种面不一致）。与对象
+ * → 空对象同属整体替换语义（A5——键消失不残留）——整属性消失 = 清空。 */
 export declare function applyStyle(el: HTMLElement, style: unknown): void;

package/dist/client/vdom/core/node/component.d.ts

@@ -61,10 +61,9 @@ export interface ComponentRecord {
     renderBase: number;
     /** hook 状态缓存（per-instance——useOpen 等渲染期 hooks） */
     hookStates: Map<number, unknown>;
-    /** 组件状态机阶段（**MOUNTING 补全——审计 2026-XX**）：工厂 await 期间
-     *  = 'mounting'（rec 已注册——防御异步工厂重复执行/循环引用——重复
-     *  引用显式报错）；mount 命令消费后 = 'mounted' */
-    phase: 'mounting' | 'mounted';
+    /** 组件状态机阶段（**2027-08 断代**：工厂同步——无 mounting 窗口——
+     *  phase 恒 'mounted'——mount 命令是消费端确认） */
+    phase: 'mounted';
 }
 /** 组件实例注册表（uiServe 持有——renderToStream 写入——diff/unmount 消费） */
 export interface ComponentRegistry {

package/dist/client/vdom/core/node/native.d.ts

@@ -13,7 +13,12 @@ import type { Command } from '../command/index.ts';
 import type { ComponentSink } from './component.ts';
 /** 节点 id——确定性路径（root.0.a0——锚点法——组件实例隔离） */
 export declare function pathId(parent: string, i: number): string;
-/** 可序列化属性面（服务端吐 HTML 用）——事件/ref/函数值排除 */
+/** 可序列化属性面（服务端吐 HTML 用）——事件/ref/函数值排除
+ *  **undefined 过滤（2027-08——v2 直连污染实证）**：v1 浏览器链路经
+ *  JSON 编解码（undefined 键被丢弃——误过滤）；v2 命令直连 applier——
+ *  attrs.value=undefined → applyAttribute property 赋值 → DOM value
+ *  = "undefined"（SearchInput 非受控 value: undefined——deep-search
+ *  场景实证）——序列化面向统一过滤（SSR 侧同受益） */
 export declare function serializableAttrs(props: Record<string, unknown>): Record<string, unknown>;
 /** 原生元素渲染（create → insert → children 递归 → close——
  *  ref prop → **ref 指令**（insert 后——挂载完成）） */

package/dist/client/vdom/core/patch/index.d.ts

@@ -23,6 +23,27 @@ export declare class CommandApplier {
     nodes: Map<string, WfNode>;
     /** 本流已创建 id（done.full 清理） */
     touched: Set<string>;
+    /** P1 性能索引：父子（parent id → 子 id 集合）——procRemove 子树收集
+     *  O(N²)（前缀全量扫描——admin 全量 59s 实证）→ O(k) DFS。
+     *  语义：id 空间逻辑树（cmd.parent 字符串键——组件逻辑父/锚父同构——
+     *  与 DOM 树不必一致——collectDesc 从自身出发不受影响）。 */
+    childIds: Map<string, Set<string>>;
+    /** P1 反向索引（child id → parent id）——O(1) 摘除——防泄漏 */
+    byChild: Map<string, string>;
+    /** P2：插入序号（ref 组件 id 回退——「最后前缀命中 = 最新插入」的
+     *  O(1) 判定——原实现靠 nodes Map 插入序全量扫描——O(N)） */
+    seq: Map<string, number>;
+    private seqCounter;
+    /** 登记父子（procInsert 成功后——幂等） */
+    registerChild(parent: string, id: string): void;
+    /** 摘除子登记（O(1)——byChild 反查父集合——空集合清键） */
+    unregisterChild(id: string): void;
+    /** 子树收集（DFS——含自身——O(k)——procRemove 主路径） */
+    collectDesc(id: string): string[];
+    /** **整树替换式重置（2027-09——tour 违例实证）**：resetRoot（innerHTML
+     *  清空）后记录表同步清——后续 build 的 parentOf 不再命中残留锚
+     *  （DOM 已脱离——记录越权应用→id 空间违例）——事件/ref 清表不清监听 */
+    reset(): void;
     /** 事件代理注册表（document 捕获监听——分发） */
     eventRegistry: EventRegistry;
     /** ref 全局注册表（挂载/卸载查表触发） */
@@ -41,7 +62,9 @@ export declare class CommandApplier {
     clearNodeRefs(id: string): void;
     /** 子树 id 重映射（move——nodes/事件表/refs 前缀迁移） */
     remapSubtree(oldPrefix: string, newPrefix: string): void;
-    /** 父节点解析（root/节点表） */
+    /** 父节点解析（root/节点表）——**脱离记录回退（2027-09——tour 实证**：
+     *  整树替换后残留记录（DOM 已脱离——isConnected=false）——直中返回
+     *  残留锚/旧节点 → insertBefore/锚判定错误——跳过脱离记录继续回退） */
     parentOf(cmd: {
         parent: string;
     }): HTMLElement | null;

package/dist/client/vdom/core/patch/processors.d.ts

@@ -35,7 +35,14 @@ export declare function procInsert(applier: CommandApplier, cmd: Extract<Command
 export declare function procMove(applier: CommandApplier, cmd: Extract<Command, {
     op: 'move';
 }>): void;
-/** remove 处理器（卸载——ref(null) + 事件表 + 节点移除） */
+/** remove 处理器（卸载——ref(null) + 事件表 + 节点移除）
+ *  P1 性能升级（2027-09——admin 全量 59s 实证）：原实现每次 remove 全量
+ *  扫描 nodes（前缀 startsWith）——16k 条 remove × 160k 节点 = 2.6B 次
+ *  匹配——O(N²)——改为 childIds 索引 DFS 收集（O(k)）。
+ *  防御语义保持：子树记录清理（transform 组件→X 只发首 remove——无旧
+ *  vnode 引用无法递归发命令——子节点记录残留——按 id 前缀清全部后代
+ *  （keyed 子树 root.0.1.k3.0 同样路径前缀——事件/ref 表同步清）——
+ *  **索引主路径 + 前缀兜底**（索引未覆盖路径——防御降级——不静默） */
 export declare function procRemove(applier: CommandApplier, cmd: Extract<Command, {
     op: 'remove';
 }>): void;

package/dist/client/vdom/core/protocol.d.ts

@@ -0,0 +1,45 @@
+import type { VNode } from './vnode.ts';
+import type { UIContext } from '../context/UIContext.ts';
+import type { Command } from './command/index.ts';
+/** 函数表还原（$fn 标记 → 函数——编码/解码同进程共享） */
+export declare function reviveFn(fnTable: Map<number, unknown>): (k: string, v: unknown) => unknown;
+/** R1 熔断默认回退 UI（core 内建——inline style 零样式系统依赖——
+ *  errorFallback 未配置时使用——错误文案 + 重试按钮（恢复路径）） */
+export declare function defaultErrorFallback(err: Error, ctx: UIContext): VNode;
+/** NDJSON 命令流解析（行缓冲——命令可能跨 chunk——函数表还原——
+ * 导出（测试——跨 chunk 边界/畸形行合规断言）） */
+export declare function commandReader(reader: ReadableStreamDefaultReader<Uint8Array>, fnTable: Map<number, unknown>): AsyncGenerator<Command>;
+/** 命令流编码（函数面 → {$fn: n}——函数表——同进程共享）
+ *  函数 → 序号（WeakMap——同函数流内复用同序号——减少重复条目） */
+export declare function encodeCommands(stream: ReadableStream<Command>, fnTable: Map<number, unknown>): ReadableStream<Uint8Array>;
+/** 函数表（serve 级共享——编码/解码同进程） */
+export declare function createFnTable(): Map<number, unknown>;
+/** uiServe 选项（v1/v2 共同——公共面契约） */
+export interface UiServeOptions {
+    /** 根容器（选择器或元素） */
+    root: string | HTMLElement;
+    /** 错误熔断回退（R1——应用可配置） */
+    errorFallback?: (err: Error, ctx: UIContext) => VNode;
+    api?: unknown;
+    auth?: unknown;
+    ws?: unknown;
+    i18n?: unknown;
+    toast?: (message: string, type?: 'success' | 'error' | 'info' | 'warning', duration?: number) => void;
+    confirm?: unknown;
+    notification?: unknown;
+    [key: string]: unknown;
+}
+/** uiServe 句柄（v1/v2 共同） */
+export interface UiServeHandle {
+    ready: Promise<void>;
+    render(): Promise<void>;
+    navigate(path: string): Promise<void>;
+    /** 卸载（清理事件代理/组件实例——DOM 清空） */
+    unmount(): void;
+}
+export type ServePhase = 'active' | 'unmounted';
+export type RenderPhase = 'idle' | 'rendering';
+/** 渲染上下文（stream = 页面作者渲染入口——vnode → command 流） */
+export interface RenderCtx extends UIContext {
+    stream(vnode: VNode, init?: ResponseInit): Response;
+}

package/dist/client/vdom/core/router.d.ts

@@ -22,10 +22,17 @@ export declare class UIRouter {
     private notFoundHandler;
     /** 注册路由（shared Trie——静态/:param/*——params 注入 req） */
     get(path: string, handler: PageHandler): this;
+    /** 路由存在性（onDocClick 决策：无匹配 → 不拦截——默认完整导航——
+     *  实证：stats 页「← 填写页」链接被拦截但 navigate 落空——半跳转） */
+    has(path: string): boolean;
     /** 404 兜底 */
     notFound(handler: PageHandler): this;
     /** 解析请求 → 响应（Trie 匹配 + **params/query 注入 ctx**——对齐后端
      *  `ctx = { params, query }`——`Object.fromEntries(searchParams)`——
      *  不修改原始 Request） */
+    private _pipeline?;
+    private get pipeline();
+    /** 解析请求 → 响应（**shared pipeline 内核**——parse→match→ctx 注入→
+     *  执行→404 兜底骨架单源——非法编码 → 400（B1——对齐 server 语义）） */
     resolve(req: Request, ctx: UIContext): Promise<Response>;
 }

package/dist/client/vdom/core/ssr/absorb.d.ts

@@ -24,21 +24,48 @@
  *  显式 console.error（不再静默返回 null——非法顺序是 bug）
  */
 import type { WfNode } from '../patch/processors.ts';
+import { type Observable } from '../../observable/index.ts';
 /** 吸收阶段（状态机枚举） */
 export type AbsorbPhase = 'inactive' | 'consuming' | 'failed';
+/** 吸收迁移事件（**流化（2027-09）——事件序列 = 时间线——可回放**） */
+export type AbsorbEvent = {
+    kind: 'begin';
+} | {
+    kind: 'next';
+    matched: boolean;
+} | {
+    kind: 'end';
+    remaining: number;
+} | {
+    kind: 'reset';
+};
+/** 吸收迁移表（**纯 reducer——状态机维度总表语义不变——波次 4 流化**）：
+ *  - begin：任意 → consuming（无条件——幂等——现状）
+ *  - next matched：consuming → consuming（消耗）；matched=false = 耗尽——failed
+ *  - end：consuming → remaining>0 ? failed : inactive（mismatch 判定）
+ *  - reset：任意 → inactive（回退重建）
+ *  违例语义（保持现状——不抛——消费端防御）：next/end 于非 consuming =
+ *  无迁移（合法 no-op——procDone 无条件调用 end——未 begin 不报错）——
+ *  next 违例的方法层保留 console.error（audit 可见——2026 审计语义） */
+export declare function absorbReducer(s: AbsorbPhase, e: AbsorbEvent): AbsorbPhase;
 /** 吸收状态（CommandApplier 持有——apply 层消费） */
 export declare class AbsorbState {
     /** DFS 序快照（root 后代——create 按序消费） */
     queue: Node[] | null;
-    /** 吸收失败（SSR 与命令流不匹配——serve 回退清空重建） */
-    failed: boolean;
-    /** 状态机阶段（迁移：begin→consuming；end/reset→inactive；耗尽→failed） */
+    /** 状态机阶段（**单源 = events$ 的 scan 折叠写回**——2027-09） */
     phase: AbsorbPhase;
+    /** 迁移事件流（begin/next/end/reset 全序列——**时间线可回放**） */
+    readonly events$: Observable<AbsorbEvent>;
+    /** **吸收失败事件**（next 耗尽 / end 剩余——serve 回退闭环订阅点） */
+    readonly failed$: Observable<void>;
+    private readonly events;
+    constructor();
     /** 启动吸收（root 有 SSR 内容——DFS 序快照——不消费 root 自身） */
     begin(container: HTMLElement): void;
     /** 吸收结束（done.full）——剩余节点 = SSR 输出多于命令——mismatch
      *  **inactive 时 = 合法 no-op**（procDone 无条件调用——非 SSR 客户端
-     *  渲染未 begin——end 无意义——不报错）；consuming 时 = 正常收尾 */
+     *  渲染未 begin——end 无意义——不报错——reducer 无迁移）；consuming 时 =
+     *  正常收尾（remaining=0 → inactive / >0 → failed 事件） */
     end(): void;
     /** 重置（回退重建后——恢复非吸收态） */
     reset(): void;

package/dist/client/vdom/core/transform/index.d.ts

@@ -22,8 +22,10 @@ export type NodeState = 'text' | 'hole' | 'element' | 'component' | 'fragment' |
 export interface TransformContext {
     /** 命令发射（旧侧让位：remove/unmountComp——diff 生成的命令序列） */
     emit(cmd: unknown): void;
-    /** 新侧渲染（sink——共享分发器——转换函数内部完成完整转换） */
-    emitNode(v: VNodeChild, parent: string, index: number, ref: string | null): Promise<void>;
+    /** **新侧渲染（记录——不构造）**（2027-09 流化：延迟构造归 transformV2
+     *  ——订阅时构造——C1 fuzz seed=11 的顺序语义结构性保证——旧段 dispose
+     *  在前——不再有 await 时序不保的 pendingSink hack） */
+    emitNode(v: VNodeChild, parent: string, index: number, ref: string | null): void;
     /** 旧节点锚/元素 id（旧树 id——diff 的 oldId 空间） */
     oldId: string;
     /** 新节点 id（新树 id——diff 的 newId 空间） */
@@ -39,8 +41,6 @@ export interface TransformContext {
     /** 组件实例注册表（区间清理查 lastOutput——组件多根完整移除——G2） */
     registry?: ComponentRegistry | null;
 }
-/** 新侧渲染 sink（与 build 的 RenderSink 同形——transform 不依赖 build） */
-export type TransformSink = (v: VNodeChild, parent: string, index: number, ref: string | null) => Promise<void>;
 /** 转换策略函数（各状态文件实现——**完整转换**：旧侧让位命令 + ctx.emitNode
- *  新侧渲染——返回 Promise 支持异步组件） */
-export type TransitionFn = (oldNode: unknown, nextNode: VNodeChild, ctx: TransformContext) => Promise<void> | void;
+ *  新侧记录——同步执行——新侧构造由 transformV2 延迟（订阅时）） */
+export type TransitionFn = (oldNode: unknown, nextNode: VNodeChild, ctx: TransformContext) => void | Promise<void>;

package/dist/client/vdom/core/v2/cycle.d.ts

@@ -0,0 +1,54 @@
+/**
+ * vdom v2 — 渲染周期（applyV2Inner 管线化——波次 1：渲染全链路流视图）
+ *
+ * VDOM-OBSERVABLE-COMPLETE 波次 1：
+ * - **管线形态**：build/diff → cmds$ → toArray（原子性——生成完成才应用——
+ *   错误 → 零 DOM 变更）→ tap(apply) → tap(cleanup) → currentTree →
+ *   applied$（sink 可观测）→ complete$
+ * - **度量流化**：三轴（builds/diffs/applies/unmounts）在周期计数——
+ *   删除 applyV2 手写 vt.builds/diffs（serve 同步到 __wfV2——兼容）
+ * - **sserve 解耦**：周期不含 DOM/applier——依赖注入（boot/resetRoot/
+ *   build/diff/apply/dispose/active）——契约层可注入假依赖直测管线
+ */
+import type { VNode } from '../vnode.ts';
+import type { Command } from '../command/index.ts';
+import { Observable } from '../../observable/index.ts';
+/** 周期三轴度量（渲染健康——流上取数——RENDER-HEALTH-PLAN 接管点） */
+export interface CycleMetrics {
+    builds: number;
+    diffs: number;
+    applies: number;
+    unmounts: number;
+}
+/** 渲染周期依赖（serve 注入 DOM/引擎——周期纯管线） */
+export interface RenderCycleDeps {
+    /** 首帧一次性（SSR 吸收 begin / root 清空——周期内 booted 标记） */
+    boot(): void;
+    /** root 整树替换前清空（innerHTML='' + 旧段全量 dispose——serve 实现） */
+    resetRoot(): void;
+    /** 全量构建（首帧 / 根替换 / 影子树重置后——currentTree null 时） */
+    build(vnode: VNode): Observable<Command>;
+    /** 增量 diff（currentTree 与 vnode 同型） */
+    diff(oldTree: VNode, nextTree: VNode): Observable<Command>;
+    /** 命令应用（applier.apply——副作用终态） */
+    apply(cmd: Command): void;
+    /** unmount 命令 → 段销毁（返回是否实际销毁——幂等防御） */
+    dispose(compId: string): boolean;
+    /** serve 活性（unmount 后周期零副作用） */
+    active(): boolean;
+}
+export interface RenderCycle {
+    /** 应用 vnode（首帧 build / 后续 diff / 异型根替换）——生成原子性 */
+    apply(vnode: VNode): Promise<void>;
+    /** 影子树重置（错误自愈 / R1 熔断 fallback 前置）——下次 apply 全量 */
+    reset(): void;
+    /** 三轴度量（builds/diffs/applies/unmounts） */
+    metrics(): CycleMetrics;
+    /** **应用后命令重发射**（sink 可观测——dev/度量订阅点——每周期一值） */
+    applied$: Observable<Command[]>;
+    /** **周期完成**（applied 后——afterRender 冲刷点——每周期一事件） */
+    complete$: Observable<void>;
+}
+/** 创建渲染周期（**原子性纪律**：命令生成完整（toArray）→ 应用——生成
+ *  错误 → 零 DOM 变更 + currentTree 重置（下次全量自愈——R1 语境界面）） */
+export declare function createRenderCycle(deps: RenderCycleDeps): RenderCycle;

package/dist/client/vdom/core/v2/diff.d.ts

@@ -0,0 +1,80 @@
+import type { VNode, VNodeChild } from '../vnode.ts';
+import type { Component, RenderFn } from '../vnode.ts';
+import type { Command } from '../command/index.ts';
+import type { UIContext } from '../../context/UIContext.ts';
+import { Observable } from '../../observable/index.ts';
+import { type CompOutput } from '../node/component.ts';
+/** v2 组件流段（实例复用载体——**工厂执行一次——后续复用**） */
+export interface Segment {
+    factory: Component;
+    renderFn: RenderFn;
+    lastOutput: CompOutput | undefined;
+    hookSeq: {
+        n: number;
+    };
+    /** 渲染 hook 基准（mount 后计数——v1 renderBase 等价——**每次 renderFn 前
+     *  重置——渲染期 hook 索引跨渲染稳定——useOpen 状态保留（2027-08
+     *  漂移实证——Popover 点后 open 复位）**） */
+    renderBase: number;
+    instData: Map<unknown, unknown>;
+    /** **destroy$（2027-08——段级卸载信号——单信号全停）**：卸载时 next——
+     *  **单轨清理（2027-09——onUnmounts 字段删除）**：订阅者（onUnmount
+     *  闭包栈 LIFO + 外部 takeUntil 流清理）统一由本信号驱动——不再有
+     *  平行数组 */
+    destroy$: import('../../observable/index.ts').Subject<void>;
+    disposed: boolean;
+}
+export type SegmentMap = Map<string, Segment>;
+/** 创建段（mount——工厂执行——hooks 环境已注入 ctx.ui） */
+export declare function createSegment(factory: Component, props: Record<string, unknown>, ctx: UIContext, compId: string, requestSegmentRender?: () => void): Segment;
+/** **段重渲染（单一实现源）**：hookSeq 重置（v1 renderBase 语义——渲染期
+ *  hook 索引跨渲染稳定）→ renderFn 重调（props 最新）——工厂不重跑 */
+export declare function rerenderSegment(seg: Segment, props: Record<string, unknown>): VNodeChild;
+/** 段销毁（unmount——destroy$ 单信号全停——onUnmount 闭包栈 LIFO + 订阅
+ *  者清理统一由信号驱动）——段接口无平行数组（单轨清理） */
+export declare function disposeSegment(id: string, segments: SegmentMap): void;
+/**
+ * **段输出根枚举（VDOM-CORE-EXCELLENCE KEYED-MOVE M1——单一实现源）**：
+ * keyed 组件输出的物理节点 id 清单——顺移物理 move 的命令目标。
+ * **形态映射（四形态探针实证——2027-10）**：
+ * - 单 vnode 元素/文本输出 → **槽位 id**（pathId——C2 锚点法——P 契约
+ *   槽位 remap 有效实证）
+ * - 数组输出 → **compId.i 平铺**（root.0.kk1.0/.1——与兄弟槽位隔离）
+ * - null/空洞输出 → **compId.0 锚**（G11 修正——null 锚也挂子空间）
+ * - 嵌套组件输出 → **compId.0**（单 vnode 组件输出——防冲突——HoverCard
+ *   事故实证；嵌套段在 compId.0.0 递归子空间）
+ */
+export declare function outputRootIds(seg: Segment | undefined, kid: string, parent: string, index: number): string[];
+/** 任意子节点的物理输出根 id（M2 ref 链——新位置左邻定位）：
+ *  元素/文本 → 槽位 id；keyed 组件 → 输出根[0]（compId.0/槽位） */
+export declare function outputRootIdOf(c: VNodeChild, parent: string, index: number, segments?: SegmentMap): string;
+/** 节点对照（old vs new——流式增量命令） */
+export declare function diffV2Node(oldC: VNodeChild, newC: VNodeChild, parent: string, index: number, ref: string | null, ctx: UIContext, segments: SegmentMap, registry: import('../node/component.ts').ComponentRegistry, requestRender?: () => void): Observable<Command>;
+/** 组件 id（keyedId/pathId——单一点——v1 双实现收敛） */
+export declare function v2CompId(vn: VNode, parent: string, index: number): string;
+/** 根对照（v2 diff——diffStream 的 Observable 等价） */
+export declare function diffV2(oldTree: VNode, newTree: VNode, ctx: UIContext, segments: SegmentMap, registry: import('../node/component.ts').ComponentRegistry, requestRender?: () => void): Observable<Command>;
+/** keyed 列表对照（流式——顺移 move / 冲突重建 / key 映射对照——v1 语义等价） */
+export declare function diffKeyedV2(oldCs: VNodeChild[], newCs: VNodeChild[], parent: string, ctx: UIContext, segments: SegmentMap, registry: import('../node/component.ts').ComponentRegistry, requestRender?: () => void): Observable<Command>;
+/** 完整区间移除（v1 removeVNodeTree 等价——子树全部节点 remove——先子后父）
+ *  **组件项 unmount 信号**：v1 removeVNodeTree 同语义（compId——消费端
+ *  applier 的 registry 清理）
+ *  **段 dispose 生成期（2027-08——段表是 v2 权威——同 compId 重渲染碰撞
+ *  实证：列表→编辑器切换——旧按钮内 Icon 段残留 root.0.1.0.0——新 Button
+ *  落同槽——段错配崩溃）**：段清理必须在 diff 生成期完成（命令流生产端
+ *  完整自足——不依赖消费端时序——消费端 apply 循环的 dispose 是幂等兜底 */
+export declare function removeTreeV2(v: VNodeChild, parent: string, index: number, segments?: SegmentMap, opts?: {
+    keepSegments?: boolean;
+}): Command[];
+/** 列表含 keyed 项检测（v2——keyOf 桥） */
+export declare function hasKeyedId(items: VNodeChild[]): boolean;
+/**
+ * v2 转换（异态——v1 transitionOf 表语义单源——流式适配）
+ * - 转换表同步执行（emit 收集让位命令 + emitNode 记录新侧）——**不 await**
+ * - **顺序纪律三段流（2027-09——C1 fuzz seed=11 结构化修复）**：
+ *   concatObs([disposeOp → removeCmds → 新侧渲染])——按序订阅：① 旧段
+ *   dispose（段表权威更新）② 旧侧让位命令发射 ③ 新侧渲染构造（**订阅时**
+ *   ——createSegment 在 dispose 后——同 id 命中旧段/工厂错配结构性不可能）
+ *   ——pendingSink 时序 hack 删除（旧实现 Promise.resolve().then 时序不保）
+ */
+export declare function transformV2(oldC: VNodeChild, newC: VNodeChild, parent: string, index: number, ref: string | null, ctx: UIContext, registry: import('../node/component.ts').ComponentRegistry, oldCompId?: string, segments?: SegmentMap, requestRender?: () => void): Observable<Command>;

package/dist/client/vdom/core/v2/integrate.d.ts

@@ -0,0 +1,24 @@
+/**
+ * vdom v2 — 集成（v2 引擎 → 消费端链路）
+ *
+ * VDOM-V2-BLUEPRINT 阶段 2A：
+ * - **命令流同构 → 消费端复用**：renderV2/diffV2 产出 Observable<Command>
+ *   ——commandToHtml / CommandApplier 直接消费（命令语义 v1 相同——零改动）
+ * - v2ToHtml：v2 渲染 → HTML（SSR 路径——契约层无 DOM 验证）
+ * - 阶段 2A 验证点：v2 HTML ≡ v1 HTML（多种子——SSR 等价）
+ */
+import type { VNode } from '../vnode.ts';
+import type { Command } from '../command/index.ts';
+import type { UIContext } from '../../context/UIContext.ts';
+import { type ComponentRegistry } from '../node/component.ts';
+import { Observable } from '../../observable/index.ts';
+/** Observable<Command> → 命令数组（同步流收集——订阅到 complete） */
+export declare function collectCommands(obs: Observable<Command>): Promise<Command[]>;
+/** **v2 diff → ReadableStream<Command>（v1 diffStream 兼容桥——测试迁移）** */
+export declare function diffToStreamV2(oldT: VNode, newT: VNode, ctx?: UIContext, registry?: ComponentRegistry, segments?: Map<string, import('./diff.ts').Segment>, requestRender?: () => void): ReadableStream<Command>;
+/** **v2 渲染 → ReadableStream<Command>（v1 renderToStream 兼容桥——v1 退役迁移）**
+ *  命令式组件（toast/Confirm/Notification——独立 applier 消费——pipeTo/
+ *  读取流形态不变）——v2 引擎 + 段表（跨渲染复用） */
+export declare function renderToStreamV2(vnode: VNode, ctx?: UIContext, registry?: ComponentRegistry, segments?: Map<string, import('./diff.ts').Segment>, requestRender?: () => void): ReadableStream<Command>;
+/** v2 渲染 → HTML（SSR 路径——commandToHtml 复用——命令流同构） */
+export declare function v2ToHtml(root: VNode, ctx?: UIContext, registry?: ComponentRegistry): Promise<string>;

package/dist/client/vdom/core/v2/render.d.ts

@@ -0,0 +1,28 @@
+import type { VNode, VNodeChild } from '../vnode.ts';
+import type { Command } from '../command/index.ts';
+import type { UIContext } from '../../context/UIContext.ts';
+import { type ComponentRegistry } from '../node/component.ts';
+import { Observable } from '../../observable/index.ts';
+import type { OperatorFn } from '../../observable/index.ts';
+/** **输出位置单一实现源**（v1 outputBase 语义——组件输出挂哪）：
+ *  - 组件输出组件/数组/空洞 → compId 子空间（compId.0 起——与兄弟隔离）
+ *  - 单元素/文本 → 槽位（parent/index——v1 C2 规则）
+ *  v2 的渲染（段化）与 diff（输出对照）共用——**单一实现——防漂移** */
+export declare function v2OutputPos(out: VNodeChild, compId: string, parent: string, index: number): {
+    parent: string;
+    index: number;
+};
+/** 节点展开（vnode → 命令流——惰性——订阅驱动） */
+export declare function renderV2Node(v: VNodeChild, parent: string, index: number, ref: string | null, ctx: UIContext, registry: ComponentRegistry, segments?: Map<string, import('./diff.ts').Segment>, requestRender?: () => void): Observable<Command>;
+/** 根渲染（v2）——renderToStream 的 Observable 等价 */
+export declare function renderV2(root: VNode, ctx?: UIContext, registry?: ComponentRegistry, segments?: Map<string, import('./diff.ts').Segment>, requestRender?: () => void): Observable<Command>;
+/** 数组 → 同步 Observable（逐项发射 + complete） */
+export declare function fromArray<T>(items: T[]): Observable<T>;
+/** 顺序拼接（流串联——命令序号保持）
+ *  **同步完成迭代化（2027-08——大 flat 列表栈溢出实证——QRCode 页）**：
+ *  旧实现 complete → nextStream() 递归——N 个同步完成流 = N 层调用栈——
+ *  数百 rect/svg 链即溢出。新实现：同步完成由 while 循环推进（迭代——
+ *  零深栈）；异步完成仍由回调驱动（新调用栈——深度 1）。 */
+export declare function concatObs<T>(streams: Array<Observable<T>>): Observable<T>;
+/** append 算子（concat 语义——合成尾部流） */
+export declare function concatWith<T>(tail: Observable<T>): OperatorFn<T, T>;