weifuwu 0.33.11 → 0.35.0

package/README.md

@@ -6,7 +6,7 @@
 npm install weifuwu
 ```
 
-一个包，无上游依赖。后端提供 HTTP 路由、数据库、中间件；前端提供信号驱动的无 VDOM 响应式框架。
+一个包，无上游依赖。后端提供 HTTP 路由、数据库、中间件；前端提供 VDOM + Proxy 驱动的前端框架。
 
 ---
 
@@ -22,21 +22,19 @@ npm install weifuwu
 | **redis** | `redis` | Redis 客户端 → `ctx.redis` | `Router` |
 | **ui** | `ui` | SSR 渲染 + 动态 JS 编译 → `ctx.ui.html/css/js` | `Router` |
 | **graphql** | `router.graphql()` | GraphQL 端点 | `Router` |
-| **client** | 28 个导出 | 前端响应式框架（见下方表格） | — |
+| **client** | — | 前端 VDOM + Proxy 框架 | — |
 
 **前端 `weifuwu/client` 模块总览：**
 
 | 类别 | 导出 | 用途 |
 |------|------|------|
-| **信号系统** | `signal`, `computed`, `effect`, `batch`, `untrack`, `isSignal` | 响应式状态 |
-| **JSX 运行时** | `jsx`/`jsxs`/`jsxDEV`, `Fragment` | TSX 编译目标 |
-| **控制流** | `Show`, `For` | 条件/列表渲染 |
-| **生命周期** | `onMount`, `onCleanup` | 组件挂载/卸载 |
-| **应用** | `createApp` | 中间件链 + 挂载 |
-| **路由** | `router`, `RouteView`, `lazy` | 嵌套布局 + 代码分割 + 滚动恢复 |
-| **中间件** | `ws`, `api`, `auth` | WebSocket / HTTP 客户端 / 认证状态 |
-| **工具** | `createResource`, `useForm`, `ErrorBoundary`, `createPortal`, `wrap`, `createContext`, `extendCtx`, `domMount` | 异步数据 / 表单 / 错误边界 / Portal |
-| **类型 (19)** | `Signal`, `Component`, `WfuiContext`, `AppMiddleware`, `RouteDef`, `ApiClient`, `AuthClient`, `ResourceState`, `FormReturn`, 等 | — |
+| **渲染引擎** | `VNode`, `Component` | 虚拟 DOM 节点与组件类型 | — |
+| **JSX 运行时** | `jsx`/`jsxs`/`jsxDEV`, `Fragment` | TSX 编译目标 | — |
+| **应用** | `createApp` | 中间件链 + 挂载 | — |
+| **路由** | `router`, `RouteView` | 嵌套布局路由 | — |
+| **中间件** | `ws`, `api`, `auth` | WebSocket / HTTP 客户端 / 认证状态 | — |
+| **工具** | `extendCtx` | ctx 扩展 | — |
+| **类型** | `WfuiContext`, `AppMiddleware`, `RouteDef`, `VNodeType`, `Component`, `ApiClient`, `AuthClient` | — | — |
 
 ---
 
@@ -94,13 +92,16 @@ serve(app, { port: 3000 })
 
 ```tsx
 // src/main.tsx — 前端
-import {
-  signal, computed, Show, For, ErrorBoundary, createPortal, wrap,
-  createApp, router, RouteView, lazy,
-  ws, api, auth, useForm, createResource,
-} from 'weifuwu/client'
+import { createApp, router, RouteView, ws, api, auth } from 'weifuwu/client'
 import type { WfuiContext, RouteDef } from 'weifuwu/client'
 
+// 组件 = (props, ctx) => VNode
+function Home(_props: {}, ctx: WfuiContext) {
+  const $ = ctx.ui.$
+  if (!ctx.ui.ready) { $.items = [{ id: 1, text: 'hello' }] }
+  return <div>{$.items.map((i: any) => <div key={i.id}>{i.text}</div>)}</div>
+}
+
 const app = createApp()
 app.use(api({ baseURL: '' }))
 app.use(auth())
@@ -111,9 +112,6 @@ app.use(router({
     {
       path: '/dashboard',
       layout: DashboardLayout,
-      children: [
-        { path: '/overview', component: lazy(() => import('./Overview')) },
-        { path: '/settings', component: lazy(() => import('./Settings')) },
       ],
     },
   ],
@@ -317,25 +315,34 @@ esbuild.build({
 })
 ```
 
-### 信号系统
+### 状态管理 — 深度 Proxy
+
+`ctx.ui.$` 是**深度 Proxy**：任何属性/数组/对象层面的写入自动触发渲染，无需手动调用。
 
 ```tsx
-const count = signal(0)                    // 创建
-const doubled = computed(() => count.value * 2)  // 衍生
-effect(() => console.log('count:', count.value))  // 副作用
-batch(() => { a.value = 1; b.value = 2 })         // 批量更新
-untrack(() => theme.value)                // 不追踪依赖
-isSignal(value)                           // 类型判断
+const $ = ctx.ui.$
+
+// 顶层属性赋值
+$.count = 0                                // → 自动渲染
+$.user = { name: 'alice' }                 // → 新值自动深度包装
+
+// 数组突变
+$.items.push(newItem)                      // → 自动渲染
+$.items.pop()                              // → 自动渲染
+$.items.splice(i, 1)                       // → 自动渲染
+
+// 对象属性突变（数组内部也支持）
+$.items[0].done = true                     // → 自动渲染
+$.msgs[idx].content += event.text          // → 自动渲染
+
+// 不可变更新（同样支持）
+$.items = [...$.items, newItem]
 ```
 
-| 函数 | 签名 | 说明 |
-|------|------|------|
-| `signal` | `<T>(initial: T) => Signal<T>` | 响应式数据容器 |
-| `computed` | `<T>(fn: () => T) => Signal<T>` | 衍生值，自动缓存 |
-| `effect` | `(fn: () => void) => dispose()` | 自动追踪依赖，变化时重跑 |
-| `batch` | `(fn: () => void) => void` | 合并多次写入为一次通知 |
-| `untrack` | `<T>(fn: () => T) => T` | 读取信号但不追踪依赖 |
-| `isSignal` | `(value: unknown) => value is Signal` | 判断是否为 Signal |
+| API | 说明 |
+|------|------|
+| `ctx.ui.$` | 深度 Proxy 对象，所有写入自动触发渲染 |
+| `ctx.ui.dirty()` | ⚠ 极少需要 — 仅当绕过 Proxy 直接操作底层对象时 |
 
 ### JSX 运行时
 
@@ -352,37 +359,46 @@ isSignal(value)                           // 类型判断
 
 **Signal 属性自动绑定：** `<input value={signalVal} />` — 信号变化时只更新对应 DOM 属性。
 
-### 控制流
+### 条件与列表
+
+使用原生 JS 表达式，不需要框架 API：
 
 ```tsx
-<Show when={isLoggedIn} fallback={<Login />}>
-  <Dashboard />
-</Show>
+// 条件
+{$.loading && <Loading />}
+{$.error ? <Error msg={$.error} /> : <Content />}
 
-<For each={items} keyBy="id">
-  {(item) => <div>{item.name}</div>}
-</For>
+// 列表
+{$.items.map(item => (
+  <div key={item.id}>{item.name}</div>
+))}
 ```
 
-| 组件 | 属性 | 说明 |
-|------|------|------|
-| `Show` | `when: boolean \| Signal<boolean>`, `fallback?`, `children?` | 条件渲染，Signal 响应式切换 |
-| `For` | `each: T[] \| Signal<T[]>`, `children: (item, index) => Node`, `keyBy?` | 列表渲染，支持 keyed 复用 |
+| 模式 | 说明 |
+|------|------|
+| `{cond && <A/>}` | 条件渲染（cond 为 true 时渲染 A） |
+| `{cond ? <A/> : <B/>}` | 二选一 |
+| `{arr.map(x => <div key={x.id}/>)}` | 列表渲染，必须加 `key` |
 
 ### 生命周期
 
+使用 `ref` 回调替代生命周期钩子：
+
 ```tsx
-onMount(() => {
-  init()
-  return () => cleanup()  // 自动清理
-})
-onCleanup(() => clearInterval(id))
+<div ref={el => {
+  if (el) {
+    // 挂载：el 是 DOM 元素
+    fetchData()
+    el.addEventListener('scroll', handler)
+  }
+  if (!el) {
+    // 卸载：el 为 null
+    cleanup()
+  }
+}} />
 ```
 
-| 函数 | 说明 |
-|------|------|
-| `onMount(fn)` | 组件挂载后执行，返回函数在卸载时自动清理 |
-| `onCleanup(fn)` | 组件卸载时执行 |
+`ref` 在挂载时传入 DOM 元素，卸载时传入 `null`。一个回调覆盖 mount/unmount 两个场景。
 
 ### 应用
 
@@ -491,12 +507,10 @@ const routes = [
 app.use(ws({ url: '/ws' }))
 
 // 组件中：
-onMount(() => {
-  const unsub = ctx.ws.onMessage((data) => { ... })
-  onCleanup(() => unsub())
-})
-ctx.ws.send({ type: 'chat', body: 'hello' })
-<Show when={ctx.ws.isConnected}>🟢 已连接</Show>
+const unsub = ctx.ws?.onMessage((data) => { ... })
+// 清理在 ref 中处理
+ctx.ws?.send({ type: 'chat', body: 'hello' })
+{ctx.ws?.isConnected && <span>🟢 已连接</span>}
 ```
 
 | `ctx.ws` | 类型 | 说明 |
@@ -547,10 +561,14 @@ await ctx.api.delete('/users/1')
 app.use(auth())
 
 // 组件中：
-<Show when={ctx.auth.isLoggedIn} fallback={<Login />}>
-  <span>{ctx.auth.user.value?.name}</span>
-  <button onClick={() => ctx.auth.logout()}>退出</button>
-</Show>
+{ctx.auth?.isLoggedIn ? (
+  <div>
+    <span>{ctx.auth?.user?.name}</span>
+    <button onClick={() => ctx.auth?.logout()}>退出</button>
+  </div>
+) : (
+  <Login />
+)}
 
 // 登录
 ctx.auth.login('jwt-token', { id: 1, name: 'Alice' })
@@ -687,26 +705,19 @@ function myMiddleware(): AppMiddleware {
 
 | React | weifuwu/client |
 |-------|----------------|
-| `useState(0)` | `signal(0)` |
-| `useMemo(() => a*2, [a])` | `computed(() => a.value * 2)` |
-| `useEffect(() => f, [])` | `onMount(f)` |
-| `useEffect(() => f, [dep])` | `effect(f)` |
-| `{cond && <X/>}` | `<Show when={cond}><X/></Show>` |
-| `{arr.map(i => <X/>)}` | `<For each={arr}>{(i) => <X/>}</For>` |
-| `Suspense` | `<Show when={!loading}>` |
-| `ErrorBoundary` | `<ErrorBoundary>` |
-| `createPortal` | `createPortal` |
-| `useNavigate()` | `ctx.app.navigate()` |
-| `useParams()` | `ctx.route.params` |
-| `useFormik()` | `useForm()` |
-| `axios.get()` | `ctx.api.get()` |
-| `useSWR()` | `createResource()` |
-| `React.lazy()` | `lazy()` |
-| `useContext()` | `createContext()` |
+| `useState(0)` | `$.count = 0` |
+| `useMemo(() => a*2, [a])` | `const doubled = a * 2`（render 时计算） |
+| `useEffect(() => f, [])` | `if (!ctx.ui.ready) { f() }` |
+| `{cond && <X/>}` | 相同 |
+| `{arr.map(i => <X/>)}` | 相同，加 `key` |
+| `Suspense` | `{$.loading && <Loading/>}` |
+| `useNavigate()` | `ctx.app?.navigate()` |
+| `useParams()` | `ctx.route?.params` |
+| `axios.get()` | `ctx.api?.get()` |
 
 ### 前端类型
 
-`Signal`, `Component`, `WfuiContext`, `AppMiddleware`, `RouteDef`, `ApiClient`, `ApiOptions`, `ApiRequestOptions`, `AuthClient`, `AuthUser`, `AuthOptions`, `ResourceOptions`, `ResourceState`, `FormOptions`, `FormReturn`, `FormFieldBindings`, `FormValidators`, `LazyComponentOptions`, `LazyStatus`
+`VNode`, `Component`, `WfuiContext`, `AppMiddleware`, `RouteDef`, `ApiClient`, `AuthClient`
 
 ---
 
@@ -781,7 +792,7 @@ node server.ts
 # http://localhost:3000
 ```
 
-Demo 包含：嵌套布局、signal 待办列表、useForm 表单、createResource 数据请求、api + auth 认证、WebSocket 实时通信。
+Demo 包含：嵌套布局、ctx.ui.$ 待办列表、手动表单、async fetch 数据请求、api + auth 认证、WebSocket 实时通信。
 
 ---
 
@@ -799,13 +810,10 @@ src/
 ├── graphql.ts           GraphQL
 ├── client/
 │   ├── index.ts         前端导出入口
-│   ├── signal.ts        响应式系统
-│   ├── jsx-runtime.ts   JSX → DOM, Show/For/ErrorBoundary/Portal
+│   ├── vnode.ts         VNode 类型 + JSX 工厂
+│   ├── render.ts        VDOM 渲染器（render + patchValue）
 │   ├── router.ts        路由中间件 + RouteView
 │   ├── app.ts           createApp 应用实例
-│   ├── resource.ts      createResource 异步数据
-│   ├── form.ts          useForm 表单
-│   ├── lazy.ts          组件懒加载
 │   ├── types.ts         前端类型
 │   └── middleware/
 │       ├── ws.ts        WebSocket 客户端

package/dist/client/app.d.ts

@@ -1,34 +1,25 @@
 /**
- * weifuwu/client 应用 — 创建 ctx + 中间件链 + 挂载组件
+ * weifuwu/client 应用 — createApp + ctx.ui.render
  *
- * ```tsx
- * import { createApp, ws, router } from 'weifuwu/client'
+ * createApp() → app.use(mw) → app.mount('#root', RootComponent)
  *
- * const app = createApp()
- * app.use(ws())
- * app.use(router({ routes }))
- * app.mount('#root', AppShell)
- * ```
+ * ctx.ui 在 mount 时注入：
+ *   ctx.ui.render()    触发组件重渲染
+ *   ctx.ui.$          持久化组件状态（由渲染器管理）
+ *   ctx.ui.ready       首次执行标记（由渲染器管理）
+ *
+ * ctx.ui.$ 是深度 Proxy：
+ *   $.x = val              → 自动渲染（顶层属性赋值）
+ *   $.items.push(val)      → 自动渲染（数组突变方法）
+ *   $.items[0].x = val     → 自动渲染（对象属性突变）
+ *   $.items.push({x: 1})   → 新对象自动深度包装
+ *   ctx.ui.dirty()         → 极少需要（仅当绕过 Proxy 直接操作底层对象）
  */
 import type { WfuiContext, AppMiddleware } from './types.ts';
-import type { Component } from './jsx-runtime.ts';
-/**
- * 创建 weifuwu/client 应用
- */
+import type { Component } from './vnode.ts';
 export declare function createApp(): {
-    ctx: WfuiContext;
-    use: (mw: AppMiddleware) => any;
-    mount: (rootSelector: string, RootComponent: Component) => Promise<void>;
-    /**
-     * Hydrate 一个已由 SSR 渲染的区域。
-     * 不清除目标容器内的内容，只附加组件输出。
-     *
-     * ```ts
-     * const app = createApp()
-     * app.use(api())
-     * app.use(auth())
-     * app.hydrate('#comments', CommentSection, { postId: '123' })
-     * ```
-     */
-    hydrate: (selector: string, Component: Component, props?: Record<string, unknown>) => void;
+    readonly ctx: WfuiContext;
+    use(mw: AppMiddleware): /*elided*/ any;
+    mount(rootSelector: string, RootComponent: Component): Promise<void>;
+    destroy(): void;
 };

package/dist/client/error-boundary.d.ts

@@ -0,0 +1,23 @@
+/**
+ * ErrorBoundary — 错误边界组件
+ *
+ * 捕获子组件渲染时的错误，展示 fallback 替代崩溃白屏。
+ *
+ * ```tsx
+ * <ErrorBoundary fallback={<p>出错了</p>}>
+ *   <UserProfile />
+ * </ErrorBoundary>
+ * ```
+ *
+ * 基于 ctx.ui._errorHandler 机制：在渲染子组件前注入错误处理器，
+ * 子组件 render 抛错时设置 $.error → 重新渲染 fallback。
+ */
+import type { WfuiContext } from './types.ts';
+import type { VNode } from './vnode.ts';
+export interface ErrorBoundaryProps {
+    fallback?: VNode | ((props: {
+        error: unknown;
+    }) => VNode) | null;
+    children?: any;
+}
+export declare function ErrorBoundary(props: ErrorBoundaryProps, ctx: WfuiContext): VNode | null;

package/dist/client/index.d.ts

@@ -1,239 +1,31 @@
 /**
- * weifuwu/client — 响应式前端框架，TSX + Signal
- *
- * 零虚拟 DOM，零外部依赖。组件模型：(props, ctx) => Node。
- *
- * ```tsx
- * import { signal, createApp, api, auth, ws, router, RouteView, Show, For } from 'weifuwu/client'
- * import type { WfuiContext } from 'weifuwu/client'
- *
- * const app = createApp()
- * app.use(api())
- * app.use(auth())
- * app.use(ws())
- * app.use(router({ routes }))
- * app.mount('#root', AppShell)
- * ```
- *
- * ## 核心概念
- *
- * | 导出 | 类型 | 用途 |
- * |------|------|------|
- * | `signal()` | function | 响应式数据容器 |
- * | `computed()` | function | 衍生信号 |
- * | `effect()` | function | 自动追踪依赖的副作用 |
- * | `batch()` | function | 批量更新（合并多次写入为一次通知）|
- * | `untrack()` | function | 不追踪依赖地读取信号 |
- * | `isSignal()` | function | 判断值是否为 Signal 实例 |
- * | `onMount()` | function | 组件挂载回调 |
- * | `onCleanup()` | function | 组件卸载回调 |
- * | `createApp()` | function | 应用实例（中间件链 + 挂载） |
- * | `createResource()` | function | 异步数据资源（loading/error/data）|
- * | `useForm()` | function | 表单状态管理（字段绑定/验证/提交）|
- * | `ErrorBoundary()` | component | 错误捕获边界 |
- * | `createPortal()` | function | 渲染到指定 DOM 位置 |
- * | `wrap()` | function | 封装三方库为组件 |
- * | `domMount()` | function | 低层 DOM 挂载 |
- * | `createContext()` | function | 类型安全 provide/inject |
- * | `extendCtx()` | function | 扩展上下文 |
- * | `api()` | middleware | HTTP 客户端中间件 |
- * | `auth()` | middleware | 认证状态管理中间件 |
- */
-/** 创建响应式数据容器。变化时自动通知依赖方。 */
-export { signal } from './signal.ts';
-/** 基于其他 signal 的衍生值，自动缓存。 */
-export { computed } from './signal.ts';
-/** 自动追踪 signal 依赖，变化时重跑回调。返回 dispose 函数。 */
-export { effect } from './signal.ts';
-/**
- * 批量更新 — 将多个信号写入合并为一次通知。
- *
- * ```ts
- * batch(() => {
- *   a.value = 1
- *   b.value = 2
- * })
- * // 只触发一次 effect，而非两次
- * ```
- */
-export { batch } from './signal.ts';
-/** Signal 类型。 */
-export type { Signal } from './signal.ts';
-/** 不追踪依赖地读取信号值。 */
-export { untrack } from './signal.ts';
-/** 判断值是否为 Signal 实例。 */
-export { isSignal } from './signal.ts';
-/** JSX 工厂函数 — 由 esbuild / tsc 自动调用。 */
-export { jsx, jsxs, jsxDEV } from './jsx-runtime.ts';
-/** 不产生包装元素的片段组件。 */
-export { Fragment } from './jsx-runtime.ts';
-/**
- * 条件渲染 — when 为 Signal 时响应式切换。
- *
- * ```tsx
- * <Show when={isLoggedIn} fallback={<LoginPage />}>
- *   <Dashboard />
- * </Show>
- * ```
- */
-export { Show } from './jsx-runtime.ts';
-/**
- * 列表渲染 — each 为 Signal 时响应式更新。支持 keyBy 属性复用 DOM 节点。
- *
- * ```tsx
- * <For each={items} keyBy="id">
- *   {(item) => <div>{item.name}</div>}
- * </For>
- * ```
- */
-export { For } from './jsx-runtime.ts';
-/**
- * onMount — 组件根元素挂载到 DOM 后执行的回调。
- * 返回函数在组件卸载时自动清理。
- *
- * ```tsx
- * function Chart() {
- *   onMount(() => {
- *     const chart = echarts.init(el)
- *     return () => chart.dispose()
- *   })
- *   return <div ref={el => chartEl = el} />
- * }
- * ```
- */
-export { onMount } from './jsx-runtime.ts';
-/**
- * onCleanup — 组件卸载时执行的回调（清理定时器、订阅等）。
- *
- * ```tsx
- * function Timer() {
- *   const id = setInterval(tick, 1000)
- *   onCleanup(() => clearInterval(id))
- *   return <div>...</div>
- * }
- * ```
- */
-export { onCleanup } from './jsx-runtime.ts';
-/** 组件类型签名：(props, ctx) => Node */
-export type { Component } from './jsx-runtime.ts';
-/**
- * 捕获子组件渲染时的异常并显示 fallback。
- *
- * ```tsx
- * <ErrorBoundary fallback={(e) => <p>出错了: {e.message}</p>}>
- *   {() => <Dashboard />}
- * </ErrorBoundary>
- * ```
- */
-export { ErrorBoundary } from './jsx-runtime.ts';
-/**
- * Portal — 将组件渲染到父容器之外的 DOM 位置。
- *
- * ```tsx
- * <Show when={show}>
- *   {createPortal(<div class="modal">...</div>, document.body)}
- * </Show>
- * ```
- */
-export { createPortal } from './jsx-runtime.ts';
-/**
- * wrap — 封装第三方库为组件，自动管理 mount/unmount 生命周期。
- */
-export { wrap } from './jsx-runtime.ts';
-/** 低层挂载函数，一般用 createApp().mount() */
-export { domMount } from './jsx-runtime.ts';
-/** 应用上下文 — 组件通过第二个参数 ctx 访问。 */
-export type { WfuiContext } from './types.ts';
-/** 中间件签名：(ctx) => ctx */
-export type { AppMiddleware } from './types.ts';
-/** 路由定义：path / component / auth / title / loader */
-export type { RouteDef } from './types.ts';
-/**
- * 类型安全的上下文工厂 — 创建 provide/inject 对。
- *
- * ```ts
- * const ThemeCtx = createContext<string>('theme')
- * ThemeCtx.provide(ctx, 'dark')
- * const theme = ThemeCtx.inject(ctx)
- * ```
- */
-export { createContext, extendCtx } from './types.ts';
-/**
- * 创建 weifuwu/client 应用实例。
- *
- * ```tsx
- * const app = createApp()
- * app.use(api())
- * app.use(auth())
- * app.use(router({ routes }))
- * await app.mount('#root', AppShell)
- * ```
- */
+ * weifuwu/client — VDOM 前端框架
+ *
+ * 概念：
+ *   组件 = (props, ctx) => VNode
+ *   状态 = JS 变量
+ *   更新 = ctx.ui.render()
+ *   挂载/卸载 = ref 回调
+ *
+ * 导出：
+ *   h / jsx / jsxs / jsxDEV / Fragment  → JSX 工厂
+ *   createApp                            → 应用引导
+ *   router / RouteView                   → 路由
+ *   api / auth / ws                      → 中间件
+ *   extendCtx                            → ctx 扩展
+ *   WfuiContext / AppMiddleware / RouteDef → 类型
+ */
+export { h, jsx, jsxs, jsxDEV, Fragment } from './vnode.ts';
+export type { VNode, VNodeType, Component } from './vnode.ts';
 export { createApp } from './app.ts';
-/**
- * 路由中间件 — 注入 ctx.route / ctx.app.navigate。
- * 支持 hash / history 模式，loader 数据预取，auth 守卫，嵌套布局。
- */
-export { router } from './router.ts';
-/**
- * RouteView 组件 — 渲染当前路由匹配的组件。
- * 用 `<RouteView />` 放在布局中作为路由出口。
- */
-export { RouteView } from './router.ts';
-/**
- * lazy — 组件懒加载（代码分割）。
- * 配合 esbuild code splitting 使用。
- *
- * ```tsx
- * const AdminPage = lazy(() => import('./pages/AdminPage'))
- * const routes = [{ path: '/admin', component: AdminPage }]
- * ```
- */
-export { lazy } from './lazy.ts';
-export type { LazyComponentOptions, LazyStatus } from './lazy.ts';
-/**
- * WebSocket 中间件 — 注入 ctx.ws（send / onMessage / join / leave）。
- * 自动重连，支持房间。
- */
+export { router, RouteView } from './router.ts';
 export { ws } from './middleware/ws.ts';
-/**
- * API 客户端中间件 — 注入 ctx.api（get/post/put/patch/delete）。
- * 支持 baseURL、请求/响应拦截器。
- *
- * ```ts
- * app.use(api({ baseURL: '/api' }))
- * // 组件中：ctx.api.get<User[]>('/users')
- * ```
- */
 export { api } from './middleware/api.ts';
+export { auth } from './middleware/auth.ts';
 export type { ApiClient, ApiOptions, ApiRequestOptions } from './middleware/api.ts';
 export { ApiError } from './middleware/api.ts';
-/**
- * 认证状态管理中间件 — 注入 ctx.auth（token/user/login/logout）。
- *
- * ```ts
- * app.use(auth())
- * // 组件中：ctx.auth.token, ctx.auth.isLoggedIn, ctx.auth.login()
- * ```
- */
-export { auth } from './middleware/auth.ts';
-export type { AuthClient, AuthUser, AuthOptions } from './middleware/auth.ts';
-/**
- * 异步数据资源 — 自动管理 loading/error/data 信号。
- *
- * ```ts
- * const [data, { loading, error, refetch }] = createResource(() => fetch('/api/users'))
- * ```
- */
-export { createResource } from './resource.ts';
-export type { ResourceOptions, ResourceState } from './resource.ts';
-/**
- * 表单状态管理 — 字段绑定、验证、提交、重置。
- *
- * ```ts
- * const form = useForm({ initial: { name: '' }, validate: {...}, onSubmit: async (v) => {...} })
- * // <input {...form.field('name')} />
- * ```
- */
-export { useForm } from './form.ts';
-export type { FormOptions, FormReturn, FormFieldBindings, FormValidators } from './form.ts';
+export type { AuthClient, AuthOptions } from './middleware/auth.ts';
+export { extendCtx } from './types.ts';
+export type { WfuiContext, AppMiddleware, RouteDef } from './types.ts';
+export { ErrorBoundary } from './error-boundary.ts';
+export type { ErrorBoundaryProps } from './error-boundary.ts';