weifuwu 0.74.0 → 0.76.0

package/docs/frontend.md

@@ -1,6 +1,6 @@
 # 前端 API 核心（weifuwu/ui-dom）
 
-> ⚠️ **`weifuwu/client` 已删除**——本页为历史文档。前端运行时唯一入口是 **`weifuwu/ui-dom`**（UIRouter 纯路由 + uiServe 渲染运行时 + SSR/hydration），权威参考见 **[docs/frontend-ui-dom.md](frontend-ui-dom.md)**。本页的 createApp/router/RouteView 用法已失效，对应新 API 为 `uiServe` / `UIRouter`。
+> ⚠️ **`weifuwu/client` 已并入 `weifuwu/ui-dom`**（`src/client/` 已删除）——本页 import 均用 `weifuwu/ui-dom`。前端运行时唯一入口是 **`weifuwu/ui-dom`**（UIRouter 纯路由 + uiServe 渲染运行时 + SSR/hydration），权威参考见 **[docs/frontend-ui-dom.md](frontend-ui-dom.md)**。
 
 > 以下为完整 API 参考，按需查阅。新手建议先阅读 README 的「核心概念」和「快速开始」。
 
@@ -13,40 +13,37 @@
 ```js
 esbuild.build({
   jsx: 'automatic',
-  jsxImportSource: 'weifuwu/client',
+  jsxImportSource: 'weifuwu/ui-dom',
   bundle: true,
 })
 ```
 
 ---
 
-## createApp — 应用引导
+## 应用引导（UIRouter + uiServe）
 
 ```tsx
-import { createApp } from 'weifuwu/client'
+import { UIRouter, uiServe } from 'weifuwu/ui-dom'
 
-const app = createApp()
+const app = new UIRouter()
 
-// 注册中间件
+// 注册中间件（ctx 注入）
 app.use(middleware1)
 app.use(middleware2)
 
-// 挂载到 DOM
-app.mount('#root', RootComponent)
+// 页面路由（handler = 异步组件）
+app.get('/', () => h(Home, {}))
 
-// 获取当前 ctx
-console.log(app.ctx)
-
-// 销毁
-app.destroy()
+// 落地：客户端渲染（hydrate: true 收养 SSR HTML）
+const handle = uiServe(app, { root: '#root' })
 ```
 
-| 方法 | 说明 |
+| API | 说明 |
 |------|------|
-| `createApp()` | 创建应用实例 |
-| `app.use(mw)` | 注册 AppMiddleware |
-| `app.mount(selector, RootComponent)` | 挂载到 DOM |
-| `app.destroy()` | 卸载应用 |
+| `new UIRouter()` | 创建路由实例 |
+| `app.use(mw)` | 注册中间件（AppMiddleware / UIMiddleware） |
+| `app.get(path, handler)` / `use(prefix, sub)` / `notFound(handler)` | 页面路由 / 子路由树 / 404 |
+| `uiServe(app, { root, hydrate })` | 客户端落地（返回 handle，`handle.close()` 卸载） |
 | `app.ctx` | 当前 WfuiContext |
 
 ---
@@ -54,7 +51,7 @@ app.destroy()
 ## 组件模型
 
 ```tsx
-import type { Component, WfuiContext } from 'weifuwu/client'
+import type { Component, WfuiContext } from 'weifuwu/ui-dom'
 
 // 两阶段组件：mount（只一次）→ render（每次 dirty/props 变化）
 const Counter: Component = (_init, ctx) => {
@@ -74,8 +71,8 @@ const Badge: Component = () =>
 ### 类型流（props 泛型 + ctx 注入）
 
 ```tsx
-import type { Component } from 'weifuwu/client'
-import type { ApiInjected, RouteInjected } from 'weifuwu/client'
+import type { Component } from 'weifuwu/ui-dom'
+import type { ApiInjected, RouteInjected } from 'weifuwu/ui-dom'
 
 // ① props 泛型：JSX 使用时自动类型检查（传错类型编译期报错）
 interface DeckCardProps { title: string; pages: number }
@@ -92,13 +89,13 @@ const Home: Component<{}, ApiInjected & RouteInjected> = (_init, ctx) => {
 }
 // 未声明的注入字段编译期报错——注入从"文档约定"变成"类型保证"
 
-createApp()
+const app = new UIRouter<{}>()
   .use(api())                    // 注入 ctx.api
-  .use(router({ routes }))       // 注入 ctx.route / ctx.app
-  .mount('#root', Home)          // mount 时类型累积完整
+  .use(toast())                  // 注入 ctx.toast
+uiServe(app, { root: '#root' })  // 类型累积完整（UIRouter<C & O>）
 ```
 
-> 各中间件的注入接口：`api()` → `ApiInjected`、`auth()` → `AuthInjected`、`ws()` → `WsInjected`、`i18n()` → `I18nInjected`、`router()` → `RouteInjected`（均可从 `weifuwu/client` 导入）。
+> 各中间件的注入接口：`api()` → `ApiInjected`、`auth()` → `AuthInjected`、`ws()` → `WsInjected`、`i18n()` → `I18nInjected`、`router()` → `RouteInjected`（均可从 `weifuwu/ui-dom` 导入）。
 
 | 规则 | 说明 |
 |------|------|
@@ -113,8 +110,8 @@ createApp()
 ### JSX 工厂
 
 ```tsx
-// 由 esbuild 自动调用（jsxImportSource: 'weifuwu/client'）
-import { h, jsx, jsxs, jsxDEV, Fragment } from 'weifuwu/client'
+// 由 esbuild 自动调用（jsxImportSource: 'weifuwu/ui-dom'）
+import { h, jsx, jsxs, jsxDEV, Fragment } from 'weifuwu/ui-dom'
 
 // h 支持 variadic children
 h('div', { class: 'x' }, child1, child2)
@@ -131,7 +128,7 @@ h('div', { class: 'x' }, child1, child2)
 | `Portal` / `createPortal(children, portalKey?)` | 渲染到 `document.body#__wf_portal` 独立容器（弹层/对话框，脱离父级 overflow 裁剪） |
 
 ```tsx
-import { createPortal } from 'weifuwu/client'
+import { createPortal } from 'weifuwu/ui-dom'
 
 // 内容渲染到 body 下的独立容器（不在父组件的 DOM 树内）
 const Tooltip = (_init, ctx) =>
@@ -754,7 +751,7 @@ const UserProfile: Component = (initProps, ctx) => {
 }
 ```
 
-### async 组件（原生——无需 asyncComponent 包装）
+### async 组件（原生）
 
 组件 = 函数，async 组件 = async 函数：签名与同步组件一致 `(initProps, ctx) => renderFn`，渲染器按「返回值是 Promise」原生判别。数据经闭包注入，渲染无 loading 分支：
 
@@ -771,9 +768,9 @@ const UserProfile = async (initProps, ctx) => {
 }
 ```
 
-- **客户端**：首次渲染占位 → 工厂 resolve 后整树重渲染补全（SPA）；数据经 `ctx.data` 缓存（hydration 时从 `__DATA__` 同步命中，不重跑请求）
+- **客户端**：主路径 `buildVNode` async 预构建（await 全部工厂；兄弟并行）→ 落地零占位；动态挂载兑底占位 → 局部补全——N 处实例 = N 次工厂调用，数据走 `ctx.data` 则零成本（缓存 + 并发合并）
 - **服务端**：`ctx.ui.ssr()` 直接 await 工厂 → 数据进 HTML（无占位）
-- 工厂缓存绑定页面上下文：路由导航/登录登出时自动失效，工厂以新 ctx 重新执行
+- **占位显示**：动态挂载的 async 组件占位 = 注释节点，resolve 后局部补全（Suspense 边界已裁剪）
 - 会变的数据：初始值 seed 自服务端数据（`$.count = data.count`），交互改 `$`；初始状态必须确定性（禁止 `window.innerWidth` 直接初始化 → SSR/hydration mismatch）
 
 ---
@@ -781,15 +778,15 @@ const UserProfile = async (initProps, ctx) => {
 ## 前端类型
 
 ```tsx
-import type { VNode, VNodeType, Component, WfuiContext, AppMiddleware, RouteDef } from 'weifuwu/client'
-import type { ApiClient, ApiOptions, ApiRequestOptions, ApiError } from 'weifuwu/client'
-import type { AuthClient, AuthOptions } from 'weifuwu/client'
-import type { ErrorBoundaryProps } from 'weifuwu/client'
-import type { I18nOptions, I18nState, LocalePackage } from 'weifuwu/client'
-import type { PopupPositionOptions, PopupPosition } from 'weifuwu/client'
+import type { VNode, VNodeType, Component, WfuiContext, AppMiddleware, RouteDef } from 'weifuwu/ui-dom'
+import type { ApiClient, ApiOptions, ApiRequestOptions, ApiError } from 'weifuwu/ui-dom'
+import type { AuthClient, AuthOptions } from 'weifuwu/ui-dom'
+import type { ErrorBoundaryProps } from 'weifuwu/ui-dom'
+import type { I18nOptions, I18nState, LocalePackage } from 'weifuwu/ui-dom'
+import type { PopupPositionOptions, PopupPosition } from 'weifuwu/ui-dom'
 import type { ConfirmProps, ConfirmOptions } from 'weifuwu/components'
 import type { ToastOptions, ToastPosition } from 'weifuwu/components'
-import type { RouterOptions } from 'weifuwu/client'
+import type { RouterOptions } from 'weifuwu/ui-dom'
 ```
 
 | 类型 | 说明 |

package/docs/layout.md

@@ -2,7 +2,7 @@
 
 > 本页为 weifuwu 官方文档拆分页 · [返回 README](../README.md)
 
-纯 CSS 57 个布局原语 + 136 个工具类 + 167 个主题 Token。不绑定任何 JS 框架。
+纯 CSS 58 个布局原语 + 136 个工具类 + 167 个主题 Token。不绑定任何 JS 框架。
 
 > **学习路径与命名规范**：见 [`design/style-guide.md`](../design/style-guide.md)——统一语法 `wf-<域>-<名>`、三档学习（组件 → 10 核心原语 → 完整速查）、场景速查、变量定制。
 
@@ -25,7 +25,7 @@ app.get('/layout.css', (req, ctx) => ctx.ui.css('weifuwu/layout'))
 
 也支持相对路径：`ctx.ui.css('./src/style.css')`。
 
-## 57 个布局原语
+## 58 个布局原语
 
 | 类别 | 原语 | 效果 |
 |------|------|------|

package/docs/realtime.md

@@ -70,13 +70,12 @@ app.get('/page', (req, ctx) => ctx.ui.html`
 ```ts
 app.get('/app.js', (req, ctx) => ctx.ui.js('./src/main.tsx'))   // 相对路径
 
-> ⚠️ **weifuwu/client 已删除**——前端运行时唯一入口为 `weifuwu/ui-dom`，见 [frontend-ui-dom.md](frontend-ui-dom.md)。
-app.get('/app.js', (req, ctx) => ctx.ui.js('weifuwu/client'))   // 或包名
+app.get('/app.js', (req, ctx) => ctx.ui.js('weifuwu/ui-dom'))   // 或包名（exports map 解析）
 ```
 
 使用 esbuild 编译：
 - `bundle: true`, `format: 'esm'`, `platform: 'browser'`
-- `jsx: 'automatic'`, `jsxImportSource: 'weifuwu/client'`
+- `jsx: 'automatic'`, `jsxImportSource: 'weifuwu/ui-dom'`
 - 带 mtime 缓存验证（开发时编辑文件后自动失效）
 
 ### ctx.ui.css — CSS 编译
@@ -129,10 +128,11 @@ app.get('/blog/:slug', async (req, ctx) => {
 服务端 HTML + `window.__DATA__`（ctx.data 种子）到达客户端后，`mount(..., { hydrate: true })` **收养现有 DOM**（不重建、不闪跳），只接线事件/ref/$：
 
 ```ts
-import { createApp } from 'weifuwu/client'
+import { UIRouter, uiServe } from 'weifuwu/ui-dom'
 
-createApp()
-  .mount('#root', BlogPage, { hydrate: true })   // 容器已有服务端 HTML
+const app = new UIRouter()
+app.get('/blog/:slug', (loc, ctx) => h(BlogPage, { slug: ctx.params.slug }))
+uiServe(app, { root: '#root', hydrate: true })   // 容器已有服务端 HTML → 收养
 ```
 
 - **游标收养**：元素/文本按位置匹配现有 DOM；tag 不匹配 → 局部替换；文本不一致 → 就地修正；服务端多余节点 → 收尾清理
@@ -140,32 +140,27 @@ createApp()
 - hydration 后 `$`/dirty/事件全量可用（与纯 SPA 无差别）
 - 诚实裁剪：Portal 内容就地收养（不移动到 `#__wf_portal`）；渲染期非确定性（Date/random）会导致 mismatch（dev 警告）
 
-### uiSsr — 路由级 SSR（声明即渲染）
+### 路由级 SSR（UIRouter 两端共享）
 
-共享路由定义，前后端同一份声明——后端匹配即自动 SSR，无需手写 handler/模板/序列化：
+同一份 UIRouter 路由定义，后端匹配即自动 SSR，无需手写 handler/模板/序列化：
 
 ```tsx
-// routes.tsx —— 前后端共用
-import type { RouteDef } from 'weifuwu/client'
-import { BlogPage } from './pages/BlogPage.tsx'
-
-export const routes: RouteDef[] = [
-  { path: '/blog/:slug', component: BlogPage, title: '博客' },
-]
-
-// server.ts —— 一行中间件：GET 匹配 → 注入 ctx.route.params → await 组件工厂 → 完整 HTML + __DATA__ + bundle
-import { uiSsr } from 'weifuwu'
-app.use(uiSsr({ routes, bundle: '/static/blog.js' }))
-
-// blog-hydrate.ts —— 客户端：同一份 routes，router() 注入 ctx.route.params（两端同源）
-createApp()
-  .use(router({ routes }))
-  .mount('#root', routes[0].component, { hydrate: true })
+// router.ts —— 前后端共用
+import { UIRouter, h } from 'weifuwu/ui-dom'
+
+export const app = new UIRouter()
+app.get('/blog/:slug', (loc, ctx) => h(BlogPage, { slug: ctx.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'] })
+
+// client.ts —— uiServe 客户端收养（hydrate: true）
+uiServe(app, { root: '#root', hydrate: true })
 ```
 
-- 组件工厂读 `ctx.route.params`（`/blog/:slug` → `ctx.route.params.slug`）——后端 uiSsr / 前端 router **同源注入**
-- 未匹配 → next()（交给 API/静态/404）；非 GET → next()
-- 可自定义 `title` / `template`
+- 组件工厂读 `ctx.params`（`/blog/:slug` → `ctx.params.slug`）——两端同源注入
+- `ssrPage` 选项：`styles`（stylesheet link）/ `title` / `lang` / `rootId`
 
 ### weifuwu/dev — 服务端直接跑 .tsx
 
@@ -180,7 +175,7 @@ Node 原生 TS 只剥离类型（不支持 JSX）。`weifuwu/dev` 注册 esbuild
 }
 ```
 
-- 前后端同一 JSX 运行时（`jsxImportSource: weifuwu/client`）→ 两端 VNode 一致 → hydration 可靠
+- 前后端同一 JSX 运行时（`jsxImportSource: weifuwu/ui-dom`）→ 两端 VNode 一致 → hydration 可靠
 - 与 `ctx.ui.js` 前端动态编译同一理念：无构建、无产物、改代码即生效
 
 ---

package/docs/saas.md

@@ -12,8 +12,9 @@
 ```ts
 import { rateLimit } from 'weifuwu'
 
-app.use(redis())                                        // 依赖 ctx.redis
-app.use(rateLimit({ windowMs: 60_000, max: 100 }))      // 全局限流（默认固定窗口）
+const r = redis()                                      // 注意：REDIS_URL 缺 env 构造抛错
+app.use(r)                                             // 依赖 ctx.redis
+app.use(rateLimit({ redis: r.redis, windowMs: 60_000, max: 100 }))   // redis 必传（模式 A 显式注入）
 
 app.get('/api/search', async (req, ctx) => {
   await ctx.limit('search', { max: 30, windowMs: 60_000 })  // 手动限流，超限抛 429
@@ -77,7 +78,7 @@ app.post('/secure', (req, ctx) => { ctx.auth.requireAuth(); ... })
 
 
 > ⚠️ **weifuwu/client 已删除**——前端运行时唯一入口为 `weifuwu/ui-dom`，见 [frontend-ui-dom.md](frontend-ui-dom.md)。
-- **安全基线**：scrypt 密码哈希（per-user salt + timing-safe，异步不阻塞）；access token = HMAC-SHA256 JWT（与 `weifuwu/client` 的 `auth()` 天然配对）；refresh token = 不透明随机串，DB 只存哈希，logout/轮换即撤销
+- **安全基线**：scrypt 密码哈希（per-user salt + timing-safe，异步不阻塞）；access token = HMAC-SHA256 JWT（与 `weifuwu/ui-dom` 的 `auth()` 天然配对）；refresh token = 不透明随机串，DB 只存哈希，logout/轮换即撤销
 - **防枚举**：登录失败统一 401（不泄露邮箱是否存在）
 - **`ctx.auth` 方法面**：`register` / `login` / `logout` / `requireAuth` / `setPassword(userId, newPwd)` / `createToken(type, payload, { ttlSeconds })`（邮箱验证/密码重置自接）
 - **多租户感知**：`issueSession` 的 token payload 携带 `tenantId`（来自 `user.tenant`）——中间件自动注入 `ctx.tenantId`，并将会话字段（userId/tenantId/email/name/role）合并到 `ctx.auth`，多租户应用免写 token 解码/租户中间件（数据隔离 SQL 是应用职责）
@@ -117,7 +118,8 @@ ctx.msg.sendTo('u2', { type: 'mention' })       // 用户维度点对点
 ```ts
 import { queue } from 'weifuwu'
 
-const q = queue()              // 默认 REDIS_URL
+const r = redis(); app.use(r)  // Redis 中间件（注入 ctx.redis）
+const q = queue({ redis: r.redis })   // queue 必传 Redis（池命令走轮询连接）
 app.use(q)                     // 注入 ctx.queue
 
 app.post('/api/generate', async (req, ctx) => {
@@ -184,10 +186,10 @@ app.post('/api/approve', async (req, ctx) => {
 })
 ```
 
-前端解码（`weifuwu/client`）：
+前端解码（`weifuwu/ui-dom`）：
 
 ```ts
-import { aiStream } from 'weifuwu/client'
+import { aiStream } from 'weifuwu/ui-dom'
 
 const handle = aiStream('/api/chat', { messages }, {
   onToken: (text) => { /* 增量 append 到消息 */ },

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "weifuwu",
   "type": "module",
-  "version": "0.74.0",
+  "version": "0.76.0",
   "description": "AI SaaS framework — (req, ctx) => Response",
   "exports": {
     ".": {
@@ -16,6 +16,10 @@
       "types": "./dist/ui-dom/index.d.ts",
       "default": "./dist/ui-dom/jsx-runtime.js"
     },
+    "./ui-dom/testing": {
+      "types": "./dist/ui-dom/testing.d.ts",
+      "default": "./dist/ui-dom/testing.js"
+    },
     "./layout": "./dist/layout/weifuwu-layout.css",
     "./layout/style.css": "./dist/layout/weifuwu-layout.css",
     "./components": {

package/dist/ui/ssr-page.d.ts

@@ -1,41 +0,0 @@
-/**
- * uiSsr — 路由级 SSR 中间件：前端路由表驱动的自动服务端渲染
- *
- * 开发者只声明路由（path + component），GET 匹配即自动 SSR：
- *   匹配 → 注入 params → ctx.ui.ssr 渲染组件（async 工厂 await）→ 页面模板 + __DATA__
- *   未匹配 → next()（交给后续 API/静态/404）
- *
- * 与客户端 router() 共用同一份路由定义（route-match.ts），SPA/SSR 一个声明。
- */
-import type { Middleware } from '../types.ts';
-import type { RouteDef } from '../ui-dom/types.ts';
-export interface UiSsrOptions {
-    /** 前端路由定义（与 router() 共享同一份） */
-    routes: RouteDef[];
-    /** 客户端 bundle 路径（自动注入 <script src>，如 '/static/app.js'） */
-    bundle?: string;
-    /** CSS 路径数组（自动注入 <link rel="stylesheet">，如 ['/static/style.css']） */
-    styles?: string[];
-    /** 自定义 title（默认取路由定义 title 或 'weifuwu'） */
-    title?: (ctx: {
-        params: Record<string, string>;
-        def: RouteDef;
-    }) => string;
-    /** 自定义页面模板：返回完整 HTML（默认内置，含 head/root/__DATA__/styles/bundle） */
-    template?: (parts: {
-        html: string;
-        dataScript: string;
-        title: string;
-        bundle?: string;
-        styles?: string[];
-    }) => string;
-}
-/**
- * 路由级 SSR 中间件：
- *
- * ```ts
- * const app = new Router()
- * app.use(uiSsr({ routes, bundle: '/static/app.js' }))
- * ```
- */
-export declare function uiSsr(opts: UiSsrOptions): Middleware;

package/dist/ui/ssr.d.ts

@@ -1,35 +0,0 @@
-/**
- * 服务端 SSR 字符串遍历器 — async 工厂组件（形态 C）的 HTML 序列化
- *
- * 支持：
- *   - 同步组件（mount → render → VNode → HTML）
- *   - async 工厂组件（await 工厂 → 数据进 HTML；服务端不缓存定义，数据 per-request）
- *   - Fragment / Portal（内联子节点）
- *   - innerHTML prop（原样输出）、class/style 对象序列化
- *   - 事件处理器 / ref 剥离、文本自动转义（XSS）
- *   - 服务端 ctx shim（$ no-op dirty、ctx.data 预取、selfId 隔离）
- *
- * 产物为 HtmlSafe 标记的安全 HTML 片段，可直接内联进 ctx.ui.html 模板。
- */
-import type { Component, AsyncComponent } from '../ui-dom/vnode.ts';
-import { HtmlSafe } from './html-safe.ts';
-export { HtmlSafe } from './html-safe.ts';
-export interface SsrOptions {
-    /** 服务端数据存储：ctx.data 预取结果写入此处，调用方序列化进 __DATA__ */
-    data?: Map<string, unknown>;
-}
-/**
- * SSR 渲染组件 → HTML 片段（HtmlSafe 标记，可直接内联进 ctx.ui.html 模板，不二次转义）。
- *
- * ```ts
- * const data = new Map()
- * const html = await ctx.ui.ssr(BlogPage, { slug }, { data })
- * return ctx.ui.html`
- *   <div id="root">${html}</div>
- *   ${ctx.ui.ssrData(data)}
- * `
- * ```
- */
-export declare function ssrToString(Comp: Component | AsyncComponent, props: Record<string, any>, serverCtx: any, opts?: SsrOptions): Promise<HtmlSafe>;
-/** 序列化数据存储 → window.__DATA__ 脚本（防 XSS：转义 <） */
-export declare function serializeData(data: Map<string, unknown>): string;

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

@@ -1,28 +0,0 @@
-/**
- * weifuwu/client 增量 diff — patchValue 及全部 diff 辅助
- *
- * 从 render.ts 拆出（P2 结构拆分）。依赖方向：
- *   diff.ts → render.ts（renderValue/mountComponent/patchPortal/renderPortal）
- *   diff.ts → registry.ts（callRefCleanup）
- *   render.ts 不依赖 diff.ts（单向，无环）
- */
-import type { VNodeChild } from './vnode.ts';
-import type { WfuiContext } from './types.ts';
-export declare function patchValue(parent: Node, oldNode: Node | null, oldInput: VNodeChild, newInput: VNodeChild, ctx: WfuiContext): Node | null;
-export declare function patchProps(el: Element, oldProps: Record<string, unknown> | null, newProps: Record<string, unknown>): void;
-/** 为无 key 的子节点自动分配位置 key，确保 keyed diff 正确性 */
-export declare function ensureKeys(oldChildren: VNodeChild[], newChildren: VNodeChild[]): void;
-/**
- * 将 children 映射到它们实际产生的 DOM 节点（每个 child 一个 Node[]）。
- *
- * 1 VNode ≠ 1 DOM 节点：Fragment 展开成多个直属节点（_childNodes），
- * null/boolean/Portal 产生 0 个。explicitNodes 提供限定范围（Fragment 子项
- * 用其自身 _childNodes），否则从 source（parent.childNodes 或给定快照）按计数游标分配。
- */
-export declare function mapChildDomNodes(source: Node[], children: VNodeChild[]): (Node[] | null)[];
-export declare function normalize(children: VNodeChild): VNodeChild[];
-/**
- * keyed 子节点 diff。返回每个 new child 的 DOM 节点范围（newNodes，可为空）。
- * oldNodes：old children → 实际 DOM 节点（mapChildDomNodes 结果）。
- */
-export declare function patchKeyedChildren(parent: Node, oldChildren: VNodeChild[], newChildren: VNodeChild[], ctx: WfuiContext, oldNodes?: (Node[] | null)[], rangeStart?: Node | null): (Node[] | null)[];

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

@@ -1,13 +0,0 @@
-/**
- * weifuwu/client Hydration（游标收养）— 收养服务端 HTML，不重建 DOM
- *
- * 从 render.ts 拆出（P2 结构拆分）。依赖：render.ts（flattenChildren/SVG 常量）、
- * diff.ts（patchProps）、registry.ts（idRegistry/nextComponentId/resolveAsyncFactory）。
- */
-import type { VNode } from './vnode.ts';
-import type { WfuiContext } from './types.ts';
-/**
- * Hydration 挂载入口：收养 container 内现有服务端 HTML。
- * 渲染完收尾：删除服务端有、客户端没有的残留 DOM。
- */
-export declare function hydrateVNode(container: Element, vnode: VNode, ctx: WfuiContext): Promise<void>;

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

@@ -1,6 +0,0 @@
-/**
- * 创建响应式状态容器：深度 Proxy，任意层级属性赋值自动触发 dirty。
- *
- * 纯 JS（无 DOM），客户端（ctx.ui.$()）与服务端（SSR ctx shim）共用。
- */
-export declare function createReactiveState(dirty: () => void): Record<string, any>;

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

@@ -1,39 +0,0 @@
-/**
- * weifuwu/ui-dom 注册表 — 工厂版（serve 创建局部实例，隔离于 createApp 的模块级状态）
- *
- * 复制自 client/registry.ts（算法相同），但**无模块级单例**——uiServe 创建实例
- * 注入 ctx.__registry，render/diff/ui 经 getRegistry(ctx) 读取，与 createApp 零交叉。
- */
-import type { VNode, Component, AsyncComponent } from './vnode.ts';
-import type { WfuiContext } from './types.ts';
-type UnmountHook = (id: string) => void;
-interface FactoryEntry {
-    promise: Promise<Component<any, any>>;
-    resolved?: Component<any, any>;
-}
-/** 注册表实例状态 */
-export interface Registry {
-    idCounter: number;
-    idRegistry: Map<string, VNode>;
-    unmountHooks: UnmountHook[];
-    asyncFactoryCache: WeakMap<AsyncComponent<any, any>, FactoryEntry>;
-}
-/** 创建局部注册表（uiServe 每实例一个——组件 id/dirty/卸载钩子与 createApp 隔离） */
-export declare function createRegistry(): Registry;
-/** 从 ctx 取注入的注册表（render/diff/ui 统一入口；serve 注入 __registry） */
-export declare function getRegistry(ctx: any): Registry;
-/** 指定实例生成组件 ID */
-export declare function nextComponentIdFor(reg: Registry): string;
-/** 指定实例注册卸载钩子（组件从 idRegistry 注销时触发） */
-export declare function onComponentUnmountFor(reg: Registry, hook: UnmountHook): () => void;
-/** 启动 async 工厂（幂等，缓存） */
-export declare function startAsyncFactory(reg: Registry, Comp: AsyncComponent, ctx: WfuiContext): FactoryEntry;
-/** async 模式：await 工厂定义 */
-export declare function resolveAsyncFactory(reg: Registry, Comp: AsyncComponent, ctx: WfuiContext): Promise<Component>;
-/** sync 模式：工厂已解析 → 定义；未解析 → undefined */
-export declare function resolveAsyncFactorySync(reg: Registry, Comp: AsyncComponent): Component | undefined;
-/** 包裹 ref 回调调用——用户 ref 逻辑抛错时不中断渲染/卸载管线 */
-export declare function safeCallRef(ref: Function, arg: any, phase: 'mount' | 'cleanup', name?: string): void;
-/** 通知 ref 清理 + Portal 子容器清理（指定实例） */
-export declare function callRefCleanupFor(input: any, reg: Registry): void;
-export {};

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

@@ -1,46 +0,0 @@
-/**
- * weifuwu/client 渲染器 — VNode → DOM + patchValue diff
- *
- * render(vnode, ctx)      → 首次渲染，返回 DOM
- * patchValue(el, old, new, ctx) → 增量更新
- *
- * 支持：
- *   - key 属性（keyed diff）
- *   - ref / keyed diff
- *
- * 状态管理：组件使用闭包变量 + ctx.ui.render() 手动触发重渲染。
- */
-import type { VNode, VNodeChild, Component, AsyncComponent } from './vnode.ts';
-import type { WfuiContext } from './types.ts';
-export declare const SVG_NS = "http://www.w3.org/2000/svg";
-export declare const SVG_TAGS: Set<string>;
-export declare function render(input: VNodeChild, ctx: WfuiContext): Node | null;
-export declare function renderValue(v: VNodeChild, ctx: WfuiContext): Node | null;
-/**
- * 异步组件工厂缓存：同一工厂只执行一次，多实例/多渲染共享。
- * resolved 记录已解析的定义（同步快速路径用）。
- * （缓存本体在 registry.ts，本文件仅保留依赖 render 的调度函数）
- */
-/**
- * 占位完成后整树重渲染（async 工厂已解析，diff 收敛到目标位置）。
- * 优先走 serve 的调度（重新执行 handler → 新树 → diff 传递 _asyncDef）；
- * 无 serve 注入（SSR/独立渲染）时回退 ui.render(['_wf_root'])。
- */
-export declare function scheduleFullReRender(ctx: WfuiContext): void;
-/**
- * 同步 mount 组件（async 工厂占位策略）：
- *   - 同步组件 → def(props, ctx) → render fn → 输出 VNode
- *   - async 工厂已解析 → 同同步组件
- *   - async 工厂未解析 → 占位（返回 null）+ 启动工厂 + 完成后整树重渲染
- */
-export declare function mountComponent(Comp: Component | AsyncComponent, props: VNode['props'], vnode: VNode, ctx: WfuiContext): VNode | null;
-/** 首次渲染 Portal：创建远程容器、渲染子节点（不返回占位节点） */
-export declare function renderPortal(vnode: VNode, ctx: WfuiContext): void;
-/** 更新 Portal：复用远程容器，patch 子节点（不操作父 DOM） */
-export declare function patchPortal(oldV: VNode | null, newV: VNode, ctx: WfuiContext): void;
-/** 展平嵌套数组 */
-export declare function flattenChildren(children: VNodeChild): VNodeChild[];
-export declare function mountVNode(container: Element, vnode: VNode, ctx: WfuiContext): void;
-export { patchValue } from './diff.ts';
-/** 模块级兼容（无 ctx 场景——独立清理，不影响活跃 registry） */
-export declare function callRefCleanup(input: any): void;

package/dist/ui-dom/route-match.d.ts

@@ -1,22 +0,0 @@
-/**
- * 路由匹配纯函数 — 客户端 router 与服务端 uiSsr 共用（无 DOM 依赖）
- *
- * 支持路径参数 :id、通配符 *、嵌套路由（children → chain）。
- * 与后端 Router（Trie）独立——本模块服务于"前端路由表驱动的页面"。
- */
-import type { RouteDef } from './types.ts';
-export interface FlattenedRoute {
-    re: RegExp;
-    keys: string[];
-    def: RouteDef;
-    chain: RouteDef[];
-}
-export declare function joinPaths(a: string, b: string): string;
-export declare function compilePath(path: string): {
-    re: RegExp;
-    keys: string[];
-};
-export declare function flattenRoutes(routes: RouteDef[], basePath?: string, chain?: RouteDef[]): FlattenedRoute[];
-export declare function matchRoute(path: string, routes: FlattenedRoute[]): FlattenedRoute | null;
-/** 从匹配结果提取路径参数 */
-export declare function extractParams(path: string, match: FlattenedRoute): Record<string, string>;

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

@@ -1,28 +0,0 @@
-/**
- * weifuwu/ui-dom serve — 渲染运行时（VDOM 落地机制）
- *
- * 定稿架构：serveUI = VDOM（落地，对齐后端 serve(router) = HTTP 传输）。
- *
- * uiServe(router, { root }) 调用时路由已全部注册——serve 负责：
- *   1. 创建渲染运行时：局部 registry + createUi（19 原语）+ popup-tracker + ctx.data/browser
- *   2. 监听 popstate/hashchange → router.match（params 注入）→ 中间件链 → handler → vnode
- *   3. renderValue / patchValue diff/patch DOM；组件 $ dirty → renderByIds（局部 registry）
- *
- * 与 createApp 隔离：registry/popup-tracker/dirty 集合全部局部实例（client 零改动）。
- */
-import type { UIRouter } from './router.ts';
-import type { WfuiContext } from './types.ts';
-/** uiServe 选项 */
-export interface UIServeOptions {
-    root: string | Element;
-    hydrate?: boolean;
-}
-/** serve 句柄 */
-export interface UIServeHandle<C extends object = {}> {
-    /** 释放全部资源（监听/渲染状态/注册表） */
-    close(): void;
-    /** 当前 ctx（调试/测试用）——含 UIRouter ctx 注入的类型扩展 */
-    ctx: WfuiContext & C;
-}
-/** uiServe — 绑定唯一根节点 + URL 驱动渲染（= VDOM 落地，对齐 serve(router)） */
-export declare function uiServe<RC extends object = {}>(router: UIRouter<RC>, options: UIServeOptions): UIServeHandle<RC>;