weifuwu 0.83.0 → 0.85.0

package/docs/realtime.md

@@ -128,44 +128,44 @@ app.get('/blog/:slug', async (req, ctx) => {
 - `ctx.ui.ssrData(data)` 输出 `<script>window.__DATA__=...</script>`（JSON `<` 转义防 XSS）
 - 服务端 ctx shim：`$`（dirty no-op）、`ctx.data` 预取去重、`selfId` 请求级隔离
 
-### Hydration — 客户端收养服务端 HTML
+### Hydration — 客户端收养服务端 HTML（事件流形态）
 
-服务端 HTML + `window.__DATA__`（ctx.data 种子）到达客户端后，`mount(..., { hydrate: true })` **收养现有 DOM**（不重建、不闪跳），只接线事件/ref/$：
+服务端将 vnode 构建为**事件流**（`renderToEvents`）→ `eventsToHtml` 输出完整 HTML + `serializeEvents` 序列化进 `__DATA__`，客户端 `deserializeEvents` + `replay` **收养**（DOM = fold(事件流)——零 DOM 猜测、不重建、无闪跳）：
 
 ```ts
-import { UIRouter, uiServe } from 'weifuwu/ui-dom'
+import { createRouter, deserializeEvents, replay } from 'weifuwu/ui-dom'
 
-const app = new UIRouter()
-app.get('/blog/:slug', (loc, ctx) => h(BlogPage, { slug: ctx.params.slug }))
-uiServe(app, { root: '#root', hydrate: true })   // 容器已有服务端 HTML → 收养
+const root = document.querySelector('#root')!
+replay(deserializeEvents((window as any).__DATA__), root)  // 收养服务端 HTML（同构）
+createRouter(routes, root)                                  // 之后正常交互渲染
 ```
 
-- **游标收养**：元素/文本按位置匹配现有 DOM；tag 不匹配 → 局部替换；文本不一致 → 就地修正；服务端多余节点 → 收尾清理
-- **async 工厂 hydration**：工厂 `ctx.data.get` 从 `__DATA__` 同步命中（不重跑请求）→ 渲染与服务端一致 → 收养
-- hydration 后 `$`/dirty/事件全量可用（与纯 SPA 无差别）
+- **DOM = fold(事件流)**：初始 DOM + 事件序列 = 任意时刻 DOM——收养即回放（与服务端渲染完全同构）
+- **async 工厂 hydration**：工厂 `ctx.data.get` 从 `__DATA__` 同步命中（不重跑请求）→ 渲染与服务端一致
+- 收养后事件流全量可用（与纯 SPA 无差别）
 - 诚实裁剪：Portal 内容就地收养（不移动到 `#__wf_portal`）；渲染期非确定性（Date/random）会导致 mismatch（dev 警告）
 
-### 路由级 SSR（UIRouter 两端共享）
+### 路由级 SSR（routes 两端共享）
 
-同一份 UIRouter 路由定义，后端匹配即自动 SSR，无需手写 handler/模板/序列化：
+同一份 RouteDef[] 路由定义，后端构建事件流即自动 SSR，无需手写 handler/模板/序列化：
 
 ```tsx
-// router.ts —— 前后端共用
-import { UIRouter, h } from 'weifuwu/ui-dom'
+// routes.ts —— 前后端共用
+import { h } from 'weifuwu/ui-dom'
 
-export const app = new UIRouter()
-app.get('/blog/:slug', (loc, ctx) => h(BlogPage, { slug: ctx.params.slug }))
+export const routes = [{ path: '/blog/:slug', render: (params) => h(BlogPage, { slug: params.slug }) }]
 
-// server.ts —— ssrPage 服务端落地：完整 HTML + __DATA__ + styles
-import { ssrPage } from 'weifuwu/ui-dom'
-const { page } = await ssrPage(app, { url: '/blog/hello', styles: ['/components.css'] })
+// server.ts —— renderToEvents → eventsToHtml + serializeEvents（完整 HTML + __DATA__ + styles）
+import { renderToEvents, eventsToHtml, serializeEvents } from 'weifuwu/ui-dom'
+const events = await renderToEvents(routes[0].render({ slug: 'hello' }))
+const page = eventsToHtml(events)
 
-// client.ts —— uiServe 客户端收养（hydrate: true）
-uiServe(app, { root: '#root', hydrate: true })
+// client.ts —— deserializeEvents + replay 收养
+replay(deserializeEvents((window as any).__DATA__), root)
 ```
 
 - 组件工厂读 `ctx.params`（`/blog/:slug` → `ctx.params.slug`）——两端同源注入
-- `ssrPage` 选项：`styles`（stylesheet link）/ `title` / `lang` / `rootId`
+- SSR（事件流形态）：`renderToEvents` → `eventsToHtml` + `serializeEvents`——styles/title 由页面模板控制
 
 ### weifuwu/dev — 服务端直接跑 .tsx
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "weifuwu",
   "type": "module",
-  "version": "0.83.0",
+  "version": "0.85.0",
   "description": "AI SaaS framework — (req, ctx) => Response",
   "exports": {
     ".": {

package/dist/test/client/setup.d.ts

@@ -1,12 +0,0 @@
-/**
- * weifuwu/ui-dom 测试环境 setup
- *
- * 在每个测试文件开头调用：
- * ```ts
- * import { setupJsdom } from './setup.ts'
- * setupJsdom()
- * ```
- *
- * 提供 JSDOM 浏览器全局环境，供 jsx-runtime / signal 等模块使用。
- */
-export declare function setupJsdom(): void;

package/dist/ui-dom/context.d.ts

@@ -1,32 +0,0 @@
-/**
- * ui-dom/context — ctx 组装层（vdom2 纯引擎之上）
- *
- * 分层（vdom2 方案）：vdom2/ = 纯渲染引擎（改 vdom 不影响其他）；
- * 本文件 = **context/hooks/中间件的组装**（改 hooks/ctx 不动 vdom 引擎）：
- * - createVdomContext：组装完整 ctx.ui（render/selfId/onUnmount/bumpCtxVersion +
- *   hooks 薄转发 + popup tracker + media registry）
- * - mountRoot：组装入口（context + vdom2 纯引擎挂载）
- *
- * hooks 实现已在 src/ui-dom/hooks/（独立模块）——此处仅组装 HookEnv + 转发。
- */
-import { type Registry, type Renderer, type MountHandle } from './vdom2/mount.ts';
-import type { BrowserEnv } from './types.ts';
-export interface MountOptions {
-    browser: BrowserEnv;
-    root: HTMLElement;
-    registry?: Registry;
-    renderer?: Renderer;
-    onError?: (e: unknown) => void;
-}
-export interface VdomContext {
-    ctx: any;
-    registry: Registry;
-    renderer: Renderer;
-    rootUi: any;
-    destroyPopupListeners: () => void;
-}
-/** 组装 vdom 渲染上下文（ctx.ui 完整能力 + hooks 转发 + popup tracker） */
-export declare function createVdomContext(opts: MountOptions): VdomContext;
-/** 组装入口：createVdomContext + vdom2 纯引擎挂载 */
-export declare function mountRoot(opts: MountOptions): MountHandle;
-export { mountCommand, unmountCommand, createCommandContainer } from './vdom2/mount.ts';

package/dist/ui-dom/hooks/test/hooks.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/ui-dom/middleware/serve.d.ts

@@ -1,27 +0,0 @@
-/**
- * ui-dom/middleware/serve — uiServe（UIRouter + vdom2 引擎）前端中间件
- *
- * 渲染管线（vdom2）：buildVNode（async 预构建 await 全部）→ renderValue/patchValue（同步落地）
- * 分层：vdom2/ 纯引擎 + ui-dom/context.ts 组装 ctx（hooks/popup/data/route）——
- * 本文件只做「路由 → 渲染」接线（不触碰 vdom 引擎内部）。
- */
-import type { UIRouter } from '../router.ts';
-import type { WfuiContext } from '../types.ts';
-/** uiServe 选项 */
-export interface UIServeOptions {
-    root: string | Element;
-    hydrate?: boolean;
-    /** loading 模式：不清空 root（信任调用方预置骨架屏 HTML）——首帧原子替换 */
-    loading?: boolean;
-}
-/** serve 句柄 */
-export interface UIServeHandle<C extends object = {}> {
-    /** 释放全部资源（监听/渲染状态/注册表） */
-    close(): void;
-    /** 首帧完成 Promise：await 全部工厂 + DOM 落地后 resolve */
-    ready: Promise<void>;
-    /** 当前 ctx（调试/测试用）——含 UIRouter ctx 注入的类型扩展 */
-    ctx: WfuiContext & C;
-}
-/** uiServe — 绑定唯一根节点 + URL 驱动渲染（vdom2 引擎） */
-export declare function uiServe<RC extends object = {}>(router: UIRouter<RC>, options: UIServeOptions): UIServeHandle<RC>;

package/dist/ui-dom/router.d.ts

@@ -1,73 +0,0 @@
-/**
- * weifuwu/ui-dom UIRouter — 纯路由（无渲染状态）
- *
- * 定稿架构职责划分：
- *   UIRouter = 路由表 + 匹配 + 中间件链（产 VNode）——不碰 DOM/渲染/状态
- *   serveUI   = 渲染运行时（VDOM 落地：registry/createUi/renderValue/patchValue）
- *
- * req = window.location，res = VNode，params/query 在 ctx（serve 组装 ctx 时注入）
- * handler = 异步组件：async (location, ctx) => vnode（$ 有效）
- * middleware = 两阶段 async：(location, ctx, children) => async (location, ctx) => vnode
- * layout 与 SSR 都是中间件
- */
-import type { UIHandler, UIMiddleware } from './types.ts';
-import type { VNode, UIContext, AppMiddleware } from './types.ts';
-/** UIRouter 选项 */
-export interface UIRouterOptions {
-    mode?: 'hash' | 'history';
-}
-/** 匹配结果（serve 用它执行中间件链 + handler） */
-export interface RouteMatch {
-    handler: UIHandler;
-    params: Record<string, string>;
-    title?: string;
-}
-/**
- * 前端路由应用 — new UIRouter()（纯路由）
- */
-export declare class UIRouter<C extends object = {}> {
-    private _routes;
-    private _middlewares;
-    /** ctx 注入中间件链（toast/confirm/notification 等——对齐后端 app.use 注入 ctx.xxx） */
-    private _injections;
-    /** 注入已完成标记（应用级 ctx——首次渲染时执行一次） */
-    private _injected;
-    private _mode;
-    private _notFound?;
-    /** 子路由挂载（use(prefix, sub)——dumpRoutes 遍历用） */
-    private _children;
-    constructor(options?: UIRouterOptions);
-    get mode(): 'hash' | 'history';
-    /** ctx 注入中间件（toast/confirm 等——(ctx) => ctx，对齐后端 app.use 注入 ctx.xxx） */
-    use<O extends object>(mw: AppMiddleware<any, O>): UIRouter<C & O>;
-    /** 渲染中间件（layout/SSR 等）——包装 children 产 vnode */
-    use<I extends object, O extends object>(mw: UIMiddleware<I, O>): UIRouter<C & O>;
-    /** 子路由挂载（= 后端 mount(path, subRouter)）——独立路由树：sub 的中间件/notFound/嵌套均生效 */
-    use(prefix: string, sub: UIRouter): this;
-    /** 执行 ctx 注入链（首次渲染时一次——应用级 ctx，对齐 createApp.use 链） */
-    private _ensureInjected;
-    /** 页面路由（对齐后端 get(path, handler)）——handler = 异步组件 */
-    get(path: string, handler: UIHandler<C>, opts?: {
-        title?: string;
-    }): this;
-    /** 404 */
-    notFound(handler: UIHandler): this;
-    /** 当前 URL 路径（serve 调用——mode 由 UIRouter 决定） */
-    getPath(): string;
-    /** 路由清单（debug 打印/测试用）——含嵌套子路由（use(prefix, sub) 递归展开） */
-    dumpRoutes(prefix?: string): Array<{
-        path: string;
-        title?: string;
-    }>;
-    private _getPath;
-    /** 匹配 URL → { handler, params, title }（serve 执行渲染） */
-    match(path: string): RouteMatch;
-    /**
-     * 子路由树处理（供 use(prefix, sub) 调用）：
-     * 相对路径匹配 + sub 的中间件链 + sub 的 notFound——支持任意嵌套。
-     * 返回 VNode（无渲染——serve 落地）。
-     */
-    _handle(relPath: string, location: Location, ctx: UIContext): Promise<VNode | null>;
-    /** 顶层执行：中间件链 + handler → VNode（serve 调用，URL 变化时） */
-    execute(location: Location, ctx: UIContext, path: string): Promise<VNode | null>;
-}

package/dist/ui-dom/vdom2/audit.d.ts

@@ -1,28 +0,0 @@
-/**
- * vdom2/audit — 结构一致性运行时校验（design 归档 阶段 C）
- *
- * 把「用户的想法 = vnode = DOM」变成每次 patch 的断言——错位即报错（dev），
- * 不静默传播（提交按钮消失事故的根治）。vdom2 版：vnode2 强类型 + 类型守卫。
- *
- * 开关：`__WF_VDOM_AUDIT`（dev/测试全开，生产默认关——O(n) 递归零生产开销）。
- * 校验项：
- *   A1 数组数量：childNodes.length === children 数组长度（无 fragment/数组项展开时）
- *   A2 占位位置：数组占位项（false/null）⟷ childNodes 对应位置是注释（wf-hole）
- *   A3 元素类型：native vnode.type === DOM tagName
- *   A4 锚点：组件 _refNode 指向的节点仍在父 DOM 中
- */
-import type { VNodeChild } from '../vnode.ts';
-import { type VKind } from './kind.ts';
-/** audit 开关（默认开——正确性优先；显式关：__WF_VDOM_AUDIT=0/生产优化时）。
- *  此前默认关 → 事故发生时无运行时校验（三层一致性/挂载不变量全靠事后手动排查）。
- *  默认开的代价：每次 doRenderOne/renderPath 后 O(n) 结构校验（页面树几百节点——
- *  毫秒级，可接受） */
-export declare function auditEnabled(): boolean;
-/** 安装挂载不变量 audit（uiServe 初始化时调用一次——订阅事件流而非遍历 DOM） */
-export declare function installMountInvariantAudit(): void;
-/** 数组级校验：childNodes 与 children 数组对齐（A1/A2——占位错位/数量错位） */
-export declare function auditChildren(parent: Node, children: VNodeChild[] | null, report: (msg: string) => void): void;
-/** 树级校验：vnode 树 ↔ DOM 树递归对照（A3/A4）——入口分派 AUDITERS[classifyKind(child)] 查表 */
-export declare function auditTree(parent: Node, child: VNodeChild, report: (msg: string) => void): void;
-/** 审计状态机表（kind → 校验行为——portal 远程单独容器跳过；native 含非法 type 诊断跳过） */
-export declare const AUDITERS: Record<VKind, (parent: Node, child: VNodeChild, report: (msg: string) => void) => void>;

package/dist/ui-dom/vdom2/build.d.ts

@@ -1,53 +0,0 @@
-/**
- * vdom/build — async 预构建（阶段 1）
- *
- * 核心不变量：
- * - 组件 vnode 构建后 `_render` 已设（工厂只跑一次）
- * - 旧树同位置同类型复用 `_render`（工厂不重跑——组件跨渲染保持内部状态）
- * - 剪枝：已构建 + props 同 + 旧 _child 有值 → 复用旧 _child（renderFn 不重跑）
- * - 兄弟组件并行（工厂同步执行到第一个 await 后并发等待）
- * - **纯函数无 DOM**——构建产物只含 vnode 树
- *
- * V3-2（同步快路径）：buildVNode 非 async——返回 `VNodeChild | Promise<VNodeChild>`。
- * **红线（用户确认）：组件两阶段异步定义不可改动**——组件 vnode 分支仍 await 工厂 +
- * renderFn（renderFn 强制异步契约不变）；仅「无需 await 的路径」（剪枝复用/文本/null/
- * 已构建 native）同步返回——零微任务。调用方统一 await 吸收（同步值 await 仅 1 微任务）。
- */
-import type { VNode, VNodeChild } from '../vnode.ts';
-import { type VdomCtx } from './ctx.ts';
-import { type Registry } from './registry.ts';
-import { type VKind } from './kind.ts';
-/** 组件 props 浅比较（三态 skip 判定） */
-export declare function componentPropsEqual(a: Record<string, any>, b: Record<string, any>): boolean;
-/** 挂载 async 组件：await 工厂（两阶段：外层 mount 一次）→ 设 _render + 分配 id + childCtx */
-export declare function mountAsyncComponent(vnode: VNode, ctx: VdomCtx, reg: Registry, opts?: {
-    reuse?: VNode | null;
-}): Promise<{
-    renderFn: (props: VNode['props']) => Promise<VNode | null>;
-    childCtx: VdomCtx;
-}>;
-/**
- * 递归展开组件树：await 工厂 → renderFn → 递归子树。**零 DOM**。
- *
- * - 组件节点保留在树上（挂 `_render` + `_child`）——$ dirty 精准刷新锚点不丢
- * - 兄弟组件 Promise.all 并行
- * - 旧树对照（oldInput）：同位置同类型组件复用旧 `_render`；同 props + 旧 _child 有值
- *   复用旧 `_child`（renderFn 不重跑——三态 skip 语义前置）
- * - 原地 mutate vnode（_render/_child）——引用保持
- * - V3-2：非 async——剪枝/文本/null/已构建 native 同步返回（零微任务）；
- *   组件路径（工厂 + renderFn await）返回 Promise（异步契约不变）
- */
-/** 构建器签名（BUILDERS[kind]——kind 分派查表，无 if/else 类型链） */
-type BuildFn = (input: VNodeChild, ctx: VdomCtx, oldInput: VNodeChild | undefined, reg: Registry | undefined, opts: {
-    force?: boolean;
-} | undefined) => VNodeChild | Promise<VNodeChild>;
-/**
- * buildVNode — 构建分派入口（状态机查表：BUILDERS[classifyKind(input)]）。
- * hole/text 同步原样；arr 逐项递归；comp 异步工厂；frag/native/portal 同步递归 children。
- */
-export declare function buildVNode(input: VNodeChild, ctx: VdomCtx, oldInput?: VNodeChild, reg?: Registry, opts?: {
-    force?: boolean;
-}): VNodeChild | Promise<VNodeChild>;
-/** 构建状态机表（kind → 构建行为——与 render RENDERERS / ssr TO_HTML / hydrate HYDRATERS 同构） */
-export declare const BUILDERS: Record<VKind, BuildFn>;
-export {};

package/dist/ui-dom/vdom2/ctx.d.ts

@@ -1,32 +0,0 @@
-/**
- * vdom2 ctx — 类型化渲染上下文（强类型——替代散落的 `ctx as any`/WfuiContext 宽松类型）
- *
- * ctx 是开放扩展（中间件/组件注入任意字段如 data/route）——本接口定义 vdom 引擎
- * 依赖的已知字段；扩展字段由注入方 cast 到具体接口。
- */
-import type { BrowserEnv } from '../types.ts';
-import type { Registry } from './registry.ts';
-/** ctx.ui（组装层 ui-dom/context.ts 提供完整能力——引擎只依赖以下字段） */
-export interface VdomUi {
-    _ctxVersion?: number;
-    _mounting?: boolean;
-    _rootVNodeId: string | null;
-    setMounting?(v: boolean): void;
-    endMounting?(): void;
-    render(ids?: string[]): Promise<void>;
-}
-/** vdom2 渲染上下文（build/render/patch/mount 依赖的已知字段）——ui 必填（由组装层 ui-dom/context.ts 创建） */
-export interface VdomCtx {
-    browser: BrowserEnv;
-    __registry: Registry;
-    ui: VdomUi;
-    [key: string]: unknown;
-}
-/** 组件名提取（强类型——替代 `(type as any).name`） */
-export declare function componentName(type: unknown): string;
-/** ctx.ui 版本号（三态 skip 基准） */
-export declare function ctxVersion(ctx: VdomCtx): number;
-/** ctx.ui.render（组件内部 render 转发——闭包绑定 id 由组装层 childCtx 处理） */
-export declare function ctxRender(ctx: VdomCtx, ids?: string[]): Promise<void>;
-/** 挂载保护期开关（工厂执行期间跳过渲染请求） */
-export declare function setMounting(ctx: VdomCtx, v: boolean): void;

package/dist/ui-dom/vdom2/dom-trace.d.ts

@@ -1,4 +0,0 @@
-/** DOM 写追踪开关（__WF_DOM_TRACE——audit 开启时自动安装；独立可开） */
-export declare function domTraceEnabled(): boolean;
-/** 安装 DOM 写追踪（幂等——audit/uiServe 初始化时调用；返回卸载函数） */
-export declare function installDomTrace(): () => void;

package/dist/ui-dom/vdom2/events.d.ts

@@ -1,65 +0,0 @@
-/**
- * vdom/events — 统一状态机事件总线
- *
- * 状态机管"转换"（route/lifecycle/x2y/keys/pos），事件总线管"观测"：
- * 所有状态转换统一发射结构化 VdomEvent，多路 sink 消费——
- * - console sink：人类可读（复用 trace 阶段开关，格式兼容旧 trace 输出）
- * - ring buffer sink：内存最近 N 条（__vdom_events(n) 查询——事故现场可追溯）
- * - collect sink：测试断言（makeEventCollector——事件序列断言，过程级而非结果级）
- * - audit sink：不变量校验器（订阅事件流而非事后遍历 DOM——阶段 2）
- *
- * 事件 = "决策记录"（同步、纯，不执行 DOM）；执行层（appendChild/坐标计算）不进事件流。
- * 性能：emit 首行检查——无观测者或 trace 关闭时仅一次布尔比较；payload 支持惰性函数
- * （高频 diff 事件只在有消费者需要时才求值，避免 vnDesc/nodeDesc 的字符串成本）。
- */
-import { type VdomLevel, type VdomStage } from './trace.ts';
-/** 状态机名（事件来源）——含执行细节摘要通道（build/render/diff/mount——trace 包装） */
-export type VdomMachine = 'route' | 'lifecycle' | 'x2y' | 'keys' | 'pos' | 'render' | 'audit' | 'build' | 'mount' | 'diff' | 'dom';
-export declare function machineToStage(m: VdomMachine): VdomStage;
-/** 统一状态机事件（一次渲染会话的全部转换通过 session 关联） */
-export interface VdomEvent {
-    /** 渲染会话 id（R{n}——同一渲染的 build/render/diff 事件共享；阶段 2 接入贯穿） */
-    session: string;
-    machine: VdomMachine;
-    /** 关联 vnode id（_id——按实例过滤/追溯） */
-    nodeId: string | null;
-    /** 组件名/类型名（尽力） */
-    component: string | null;
-    from: string;
-    event: string;
-    to: string;
-    /** 附加数据（key/i/path 等）——可传函数惰性求值（高频路径零字符串成本） */
-    payload?: unknown;
-    /** 输出级别（console sink 门控；默认 debug） */
-    level?: VdomLevel;
-    ts: number;
-}
-export type EventSink = (ev: VdomEvent) => void;
-/** 注册事件 sink（返回退订函数） */
-export declare function onVdomEvent(sink: EventSink): () => void;
-/** 开始渲染会话（renderOne/renderPath 入口调用）——期间所有 emit 共享 session */
-export declare function beginSession(tag?: string): string;
-/** 结束渲染会话（renderOne/renderPath 出口调用） */
-export declare function endSession(): void;
-/** 当前会话 id（空 = 无会话——事件流外直接 emit） */
-export declare function currentSession(): string;
-/** payload 惰性求值 + 分发（sink 错误隔离——不中断渲染管线）
- *  session：事件显式传入优先，否则继承当前渲染会话（一次渲染 = 一棵事件树） */
-export declare function emit(ev: VdomEvent): void;
-/** 是否存在「console 之外」的观测 sink（ring/collect）——trace() 包装的 emit 门槛：
- *  trace 关闭但测试收集/调试 ring 存在时，执行细节事件仍要发射（供断言/追溯） */
-export declare function hasObservingSinks(): boolean;
-/** 注册 ring buffer sink（uiServe 初始化时调用——页面生命周期内事件全程可追溯） */
-export declare function installEventRing(): void;
-/** 调试 API：查询最近事件（可按 machine/nodeId/event 过滤）——__vdom_events(50, { machine: 'lifecycle' }) */
-export declare function __vdom_events(n?: number, filter?: Partial<VdomEvent>): VdomEvent[];
-/** 渲染请求追踪（__vdom_render_trace(n?)——页面存续期所有渲染入口统一视图：
- *  uiServe 首帧/导航 + 组件 ctx.ui.render()（含调用者组件名/id） + 外部系统
- *  输出：`[t=ms] source(component:id) → ids / detail`——按事件顺序 */
-export declare function __vdom_render_trace(n?: number): string[];
-/** 重置 ring buffer（测试隔离用） */
-export declare function __resetVdomEvents(): void;
-export declare function makeEventCollector(): {
-    events: VdomEvent[];
-    unsubscribe: () => void;
-};

package/dist/ui-dom/vdom2/hydrate.d.ts

@@ -1,21 +0,0 @@
-/**
- * vdom2/hydrate — 游标收养（SSR HTML → 客户端，不重建 DOM）
- *
- * 流程：buildVNode 预构建（await 工厂——组件已 resolve、_child 已展开）→ 游标收养
- * （只接线属性/事件/ref——不重跑 renderFn）。vdom2 版：vnode2 强类型 + 类型守卫。
- *
- * 游标不变量：元素/文本 VNode 恰好消耗一个游标节点；组件/Fragment/数组透明；
- * null 消耗零；创建时 insertBefore(游标) 且游标不动；收养/替换时游标前进。
- */
-import type { VNode, VNodeChild } from '../vnode.ts';
-import { type VKind } from './kind.ts';
-import { type VdomCtx } from './ctx.ts';
-interface HydrationCursor {
-    parent: Node;
-    node: Node | null;
-}
-/** 水合状态机表（kind → 收养行为——与 render RENDERERS / ssr TO_HTML 同构） */
-export declare const HYDRATERS: Record<VKind, (v: VNodeChild, ctx: VdomCtx, c: HydrationCursor) => Node | null>;
-/** Hydration 入口：buildVNode 预构建（await 工厂）→ 游标收养 */
-export declare function hydrateVNode(container: Element, vnode: VNode, ctx: VdomCtx): Promise<void>;
-export {};

package/dist/ui-dom/vdom2/index.d.ts

@@ -1,13 +0,0 @@
-/**
- * vdom2 引擎入口（TDD 实施中——测试见 src/test/vdom2-matrix.test.ts）
- */
-export { mountRoot, createRenderer, type MountHandle, type Renderer } from './mount.ts';
-export { buildVNode } from './build.ts';
-export { renderValue } from './render.ts';
-export { patchValue } from './patch.ts';
-export { x2y, TRANSITIONS } from './transitions.ts';
-export { x2html } from './x2html.ts';
-export { auditEnabled, auditTree, auditChildren } from './audit.ts';
-export { hydrateVNode } from './hydrate.ts';
-export { classifyKind, getOutputRange } from './kind.ts';
-export { h, jsx, jsxs, createPortal, Fragment, Portal, isNative, isFrag, isComp, isPortal } from '../vnode.ts';

package/dist/ui-dom/vdom2/kind.d.ts

@@ -1,44 +0,0 @@
-/**
- * vdom 类型分类与输出范围（vdom-matrix 方案 2026-12）
- *
- * - classifyKind：children 值类型分类（单一判定源——替代散落的 typeof/Array.isArray/type=== 判断）
- * - getOutputRange：输出 DOM 范围统一获取（多节点完整边界；单节点 null）——
- *   范围定位用节点引用（Fragment._childNodes / 组件 _outputChild 递归 / 数组 fragment-start..end 标记），
- *   不依赖外部下标。x2y 转换（transitions.ts）/ removeOldOutput 统一用它。
- *
- * 类型分类与 VNode 类层次见 vnode.ts（NativeVNode/FragVNode/CompVNode/PortalVNode 继承 VNode 基类）；
- * 文本/数组/占位是 JSX 原生值（string/Array/boolean/null）——classifyKind 分类后走同一转换表。
- */
-import type { VNodeChild } from '../vnode.ts';
-import { Fragment, Portal } from '../vnode.ts';
-/** children 值类型分类（vdom 状态机状态） */
-export type VKind = 'text' | 'native' | 'frag' | 'comp' | 'arr' | 'hole' | 'portal';
-/** patchValue 分派上下文 */
-export interface PatchState {
-    parent: Node;
-    oldNode: Node | null;
-    oldInput: VNodeChild;
-    newInput: VNodeChild;
-    ctx: {
-        browser: any;
-        registry: import('./registry.ts').Registry;
-        ctxVersion?: number;
-        force?: boolean;
-    };
-}
-/** 输出范围统一获取（多节点输出完整边界；单节点/未知 → null）——类型守卫收窄，无散落 cast
- *  统一协议（2026-12）：Fragment 与数组项同构——多节点输出 = fragment-start/end 标记包裹，
- *  范围由标记推导（anchor = start 标记，DOM 持久化——随移动/移除天然同步）；组件经 _outputChild 递归 */
-export declare function getOutputRange(input: VNodeChild, anchor: Node | null): Node[] | null;
-/** 值分类（单一判定源——替代散落的 typeof/Array.isArray/type=== 判断） */
-export declare function classifyKind(v: VNodeChild): VKind;
-/** 数组 key 模式：diff 策略状态机的状态 */
-export type KeyMode = 'unkeyed' | 'keyed' | 'mixed';
-/** 数组 key 模式判定（单一判定源——替代 patch 散落的 hasUserKey/allUnkeyed 计算）：
- *  - unkeyed：无用户 key（位置身份——按位置 patch）
- *  - keyed  ：全部用户 key（内容身份——按 key 匹配）
- *  - mixed  ：部分 key（无 key 项由 prepPos 分配 pos:{i} 后降级 keyed）
- *  豁免：占位/文本（无 key 协议豁免）；数组项（隐式 Fragment，位置语义）；
- *  portal（portalKey 不算用户 keyed——C1：[input(无key), portal] 按位置复用） */
-export declare function keyModeOf(children: VNodeChild[]): KeyMode;
-export { Fragment, Portal };

package/dist/ui-dom/vdom2/lifecycle.d.ts

@@ -1,54 +0,0 @@
-/**
- * vdom2 lifecycle — 节点生命周期状态机（2026-12）
- *
- * 与 x2y（diff 转换状态机）/ KEY_DIFFERS（key 模式状态机）同构的第三个状态机：
- * 节点的构建/清理由**显式状态**管理——根治「dispose 掏空旧树但 build 剪枝按引用误判可用」
- * 的不一致（demo 搜索序列：Section null→恢复后剪枝复用半残旧树 → diff 遇未构建组件 →
- * renderComp 抛「not built」）。
- *
- * 状态：
- *   fresh    —— JSX 刚创建（未构建：无 _id/_render/_child）
- *   building —— buildVNode 处理中（异步工厂 await 中）
- *   built    —— 已构建（_render/_child 已设——diff 可渲染）
- *   pruned   —— 剪枝复用（_child 复用旧树——状态保持）
- *   disposed —— 已清理（diff 移除 → 掏空 _render/_child）
- *
- * 关键不变量（由 dispose 整树递归保证）：组件非 disposed ⟹ 子树全部非 disposed——
- * 剪枝只检查自身生命周期即可，无需深度验证 _child 内部（O(n) 太贵）。
- */
-/** 节点生命周期状态 */
-export type Lifecycle = 'fresh' | 'building' | 'built' | 'pruned' | 'disposed';
-/** 生命周期事件（状态转换触发点） */
-export type LifecycleEvent = 'BUILD_START' | 'BUILD_DONE' | 'PRUNE' | 'DISPOSE';
-/** 生命周期 trace 上下文（组件视角可观测——组件名 + 实例 id + 深度） */
-export interface LifecycleTraceCtx {
-    name?: string;
-    id?: string | null;
-    depth?: number;
-}
-/** 从 vnode 提取 trace 上下文（组件名 + 实例 id + _parentVNode 链深度——尽力，链可能不完整） */
-export declare function vnodeTraceCtx(vnode: {
-    type: unknown;
-    _id?: string | null;
-    _parentVNode?: unknown;
-}): LifecycleTraceCtx;
-/** 查询生命周期时间线（全组件或单组件）——__vdom_lc(id?) */
-export declare function dumpTimeline(id?: string): string;
-/** 状态转换执行（非法转换 → 保留原状态 + 事件/trace warn——不静默吞掉）
- *  tctx：trace 上下文（组件名/id/深度——事件携带结构化字段，trace 输出 `Name(id)[d0] from --event--> to`）
- *  事件流：所有转换统一 emit（machine=lifecycle）——过程级可观测/可断言 */
-export declare function transition(from: Lifecycle, event: LifecycleEvent, tctx?: LifecycleTraceCtx): Lifecycle;
-/** 旧树复用有效性（I3——所有复用路径统一检查）：
- *  - 生命周期非 disposed（dispose 显式标记——根治「引用还在但内容被掏空」的误判）
- *  - 旧 _child 非 null（有可复用输出）
- *  - _child 树无 disposed（深检查——portal 内容独立 dispose（remoteEl 移除）会打破
- *    「父非 disposed ⟹ 子树全非 disposed」：DemoDrawer 剪枝复用含 disposed Button/Drawer
- *    的输出——demo 搜索序列实测；正确性优先，性能后续用 dirty 标记优化） */
-export declare function canReuse(oldV: {
-    _lifecycle?: Lifecycle;
-    _child?: unknown;
-} | null | undefined): boolean;
-/** 递归检查子树是否含 disposed vnode（_child 树——不含 props.children 原始 JSX）
- *  导出：compToComp 并发剪枝缓存失效检测复用（build 剪枝后另一渲染会话 dispose 共享
- *  旧树——childNew 树含 disposed = 旧树被当新树，禁止 diff） */
-export declare function treeHasDisposed(child: unknown): boolean;

package/dist/ui-dom/vdom2/mount.d.ts

@@ -1,77 +0,0 @@
-/**
- * vdom2 mount — 纯引擎挂载核心（无 ctx 组装、无 hooks——那些在 ui-dom/context.ts 组装层）
- *
- * 分层（vdom2 方案）：
- * - vdom2/ = 纯渲染引擎（vnode/kind/render/patch/build/mount 核心——改 vdom 不影响其他）
- * - ui-dom/context.ts = 组装层（createVdomContext：ctx.ui 完整能力 + hooks 转发 + popup tracker）
- * - ui-dom/middleware/ = 中间件（uiServe 等——后续迁移）
- *
- * 渲染管线：buildVNode（async 预构建——await 全部工厂）→ renderValue（同步落地）
- * ctx.ui.render：render-only（design 归档）——唯一渲染触发。
- */
-import type { VNode, VNodeChild } from '../vnode.ts';
-import { createRegistry, type Registry } from './registry.ts';
-import { type VdomCtx } from './ctx.ts';
-import type { BrowserEnv } from '../types.ts';
-export interface MountOptions {
-    browser: BrowserEnv;
-    root: HTMLElement;
-    /** 完整 ctx（ui-dom/context.ts createVdomContext 组装——ui 必填） */
-    ctx: VdomCtx;
-    registry?: Registry;
-    renderer?: Renderer;
-    onError?: (e: unknown) => void;
-}
-export interface MountHandle {
-    ctx: any;
-    registry: Registry;
-    renderer: Renderer;
-    mount(comp: VNodeChild): Promise<void>;
-    rerender(): Promise<void>;
-    unmount(): void;
-    close?(): void;
-}
-export interface Renderer {
-    render(ids?: string[], req?: RenderRequestInfo): Promise<void>;
-    /** 补跑构建期被跳过的渲染请求（renderPath/渲染链落地后调用——导航期间状态更新不丢失） */
-    flushPending(): Promise<void>;
-}
-export interface VdomContext {
-    ctx: any;
-    registry: Registry;
-    renderer: Renderer;
-    rootUi: any;
-}
-/** 渲染请求来源（render 调用追踪——页面存续期所有渲染入口统一可追溯） */
-export interface RenderRequestInfo {
-    /** 调用来源分类 */
-    source: 'component' | 'uiServe' | 'external' | 'root';
-    /** 调用者组件名（source=component 时） */
-    component: string | null;
-    /** 调用者组件 id（childUi 绑定的 _id） */
-    nodeId: string | null;
-    /** 附加信息（uiServe: initial/nav；external: popup-tracker/hook 名等） */
-    detail?: string;
-}
-/** 渲染执行器（render-only 唯一渲染入口——per-id 串行链：并发触发排队补跑，
- *  同一组件渲染中再次触发 → 排队等前一个完成后补跑最新状态（合并语义）） */
-export declare function createRenderer(opts: {
-    registry: Registry;
-    ctx: any;
-    rootEl?: HTMLElement | null;
-    onError?: (e: unknown) => void;
-}): Renderer;
-/** 纯引擎挂载（接受已组装 ctx——ui-dom/context.ts 提供便捷入口） */
-export declare function mountRoot(opts: MountOptions): MountHandle;
-export { createRegistry };
-export type { Registry };
-/** vdom2 命令式挂载（toast/notification 等——buildVNode await 工厂 → renderValue → append） */
-export declare function mountCommand(container: HTMLElement, vnode: VNode, ctx: VdomCtx | import('../types.ts').WfuiContext, opts?: {
-    onMounted?: () => void;
-}): {
-    id: string;
-};
-/** vdom2 命令式卸载：ref 清理 + 卸载钩子 + 容器移除 */
-export declare function unmountCommand(container: HTMLElement, vnode: VNode | null, ctx: VdomCtx | import('../types.ts').WfuiContext): void;
-/** 命令式挂载容器（toast 等——body 下） */
-export declare function createCommandContainer(): HTMLDivElement | null;