weifuwu 0.18.0 → 0.18.1

package/README.md

@@ -88,26 +88,49 @@ app.get('/admin', mw, handler)       // route-level
 
 ## Module Patterns
 
-All modules follow one of 6 patterns. The pattern letter is marked in each module's heading.
+All modules follow one of **2 patterns** — learn these and you know every module.
 
 | Pattern | How to mount | Example |
 |---------|-------------|---------|
-| `[A]` | `app.use(mod())` | `compress()`, `preferences()` |
-| `[B]` | `app.use(mod())` + call `.stop()` / `.close()` etc. | `rateLimit({...})` |
-| `[C]` | `app.use(mod.middleware())` + `app.use('/', mod.router())` | `analytics()`, `user()` |
-| `[D]` | `app.use(mod().handler())` | `health()`, `seo()` |
-| `[E]` | `app.use('/', g.router().handler())` | `graphql(handler)` |
+| `[α]` | `app.use(mod())` | `compress()`, `preferences()`, `postgres()` |
+| `[β]` | `app.use('/path', mod())` | `health()`, `graphql(handler)`, `user()` |
+
+### Pattern α — Middleware
+
+```ts
+app.use(compress())           // basic
+const pg = postgres()         // with extras: .sql, .table, .migrate(), .close()
+app.use(pg)
+app.use(rateLimit({ max: 100 }))  // with .stop()
+```
+
+### Pattern β — Router
+
+```ts
+app.use('/health', health())                                    // no extras
+app.use('/graphql', graphql(handler))
+app.use('/logs', logdb({ pg }))                                 // with .log(), .migrate()
+app.use('/auth', user({ pg, jwtSecret }))                       // with .middleware(), .register()
+app.ws('/ws', messager({ pg }).wsHandler())
+```
+
+β modules that need **separate middleware** use `.middleware()`:
+```ts
+const a = analytics()
+app.use(a.middleware())   // tracking
+app.use('/', a)           // dashboard
+```
 
 ---
 
 ## Module Reference
 
-### agent [C]
+### agent [β]
 
 ```ts
 const a = agent({ pg, model: openai('gpt-4o'), embeddingModel: openai.embedding('text-embedding-3-small') })
 await a.migrate()
-app.use('/api', a.router())
+app.use('/api', a)
 await a.addKnowledge(agentId, 'Title', 'some knowledge content')
 a.run(agentId, { input: 'summarize the data', stream: true })
 ```
@@ -124,24 +147,30 @@ a.run(agentId, { input: 'summarize the data', stream: true })
 |--------|-------------|
 | `.run(agentId, { input, stream?, messages? })` | Execute agent with input |
 | `.addKnowledge(agentId, title, content)` | Add knowledge document |
-| `.router()` | REST + WS API |
+| `.migrate()` | DB setup |
 | `.close()` | Cleanup |
 
-### aiStream [E]
+### aiStream [β]
+
+Creates an AI streaming chat endpoint using the Vercel AI SDK.
 
 ```ts
 const chat = await aiStream(async (req) => ({ model: openai('gpt-4o'), messages: (await req.json()).messages }))
-app.use('/chat', chat.router().handler())
+app.use('/chat', chat)
 ```
 
-### analytics [C]
+| Param | Type | Description |
+|-------|------|-------------|
+| `handler` | `(req, ctx) => AIStreamOptions \| Promise<AIStreamOptions>` | Returns AI SDK options (model, messages, schema, etc.) |
+
+### analytics [β]
 
 In-memory or PostgreSQL page view tracking with built-in dashboard.
 
 ```ts
 const a = analytics()
 app.use(a.middleware())
-app.use('/', a.router())       // GET /__analytics (dashboard), GET /__analytics/data?days=7 (JSON)
+app.use('/', a)       // GET /__analytics (dashboard), GET /__analytics/data?days=7 (JSON)
 ```
 
 | Option | Type | Default | Description |
@@ -154,10 +183,10 @@ app.use('/', a.router())       // GET /__analytics (dashboard), GET /__analytics
 const a = analytics({ pg })
 await a.migrate()
 app.use(a.middleware())
-app.use('/', a.router())
+app.use('/', a)            // dashboard routes
 ```
 
-### auth [A]
+### auth [α]
 
 ```ts
 app.use(auth({ token: 'sk-123' }))                              // static token
@@ -173,7 +202,7 @@ app.get('/protected', auth({ proxy: 'http://auth:3000/validate' }), handler)
 | `verify` | `(token, req) => object\|null` | — | Verify function, return value sets `ctx.user` |
 | `proxy` | `string` | — | Auth service URL to proxy requests to |
 
-### compress [A]
+### compress [α]
 
 ```ts
 app.use(compress())                         // brotli > gzip > deflate (min 1KB)
@@ -185,7 +214,7 @@ app.use(compress({ threshold: 2048, level: 4 }))      // custom threshold and le
 | `threshold` | `number` | `1024` | Minimum byte size to compress |
 | `level` | `number` | `6` | Compression level (zlib) |
 
-### cors [A]
+### cors [α]
 
 ```ts
 app.use(cors())                                            // allow all
@@ -203,7 +232,7 @@ app.use(cors({ credentials: true, maxAge: 3600 }))
 | `credentials` | `boolean` | `false` | Allow cookies/credentials |
 | `maxAge` | `number` | — | Preflight cache duration (seconds) |
 
-### csrf [A]
+### csrf [α]
 
 ```ts
 app.use(csrf())
@@ -234,10 +263,10 @@ const server = await deploy(config)
 // server.apps.list(), server.apps.status(name), server.apps.deploy(name)
 ```
 
-### health [D]
+### health [β]
 
 ```ts
-app.use(health({ path: '/health' }))
+app.use('/health', health())
 // Returns 200 on success, 503 when check throws
 ```
 
@@ -246,7 +275,7 @@ app.use(health({ path: '/health' }))
 | `path` | `string` | `'/health'` | Health check endpoint |
 | `check` | `() => Promise<void>` | — | Async function; throws → 503 |
 
-### helmet [A]
+### helmet [α]
 
 15 security headers: CSP, HSTS, X-Frame-Options, X-Content-Type-Options, etc.
 
@@ -267,12 +296,14 @@ app.use(helmet({ contentSecurityPolicy: "default-src 'self'", xFrameOptions: 'DE
 | `crossOriginOpenerPolicy` | — | COOP header |
 | `crossOriginResourcePolicy` | — | CORP header |
 
-### iii [C] — Worker / Function / Trigger
+### iii [β] — Worker / Function / Trigger
+
+Distributed function execution with WebSocket workers, triggers, and Redis streams.
 
 ```ts
 import { createWorker } from 'weifuwu'
 const engine = iii({ pg, redis })
-app.use('/iii', engine.router())
+app.use('/iii', engine)
 app.ws('/iii', engine.wsHandler())
 
 const w = createWorker('orders')
@@ -281,6 +312,12 @@ engine.addWorker(w)
 await engine.trigger({ function_id: 'orders::create', payload: { items: ['apple'] } })
 ```
 
+| Option | Type | Default | Description |
+|--------|------|---------|-------------|
+| `pg` | `object` | — | PostgreSQL client for persistent triggers |
+| `redis` | `object` | — | Redis client for streams |
+| `streamTTL` | `number` | `3600` | Redis stream key TTL (seconds, 0 = no expiry) |
+
 | Method | Description |
 |--------|-------------|
 | `.addWorker(w)` | Register a worker |
@@ -289,19 +326,18 @@ await engine.trigger({ function_id: 'orders::create', payload: { items: ['apple'
 | `.listWorkers()` | List registered workers |
 | `.listFunctions()` | List registered functions |
 | `.listTriggers()` | List registered triggers |
-| `.router()` | REST + WS API |
 | `.wsHandler()` | WebSocket handler |
 | `.migrate()` | DB setup |
 | `.shutdown()` | Clean shutdown |
 
-### logdb [C]
+### logdb [β]
 
 PostgreSQL structured event logging with monthly partitioning.
 
 ```ts
 const logger = logdb({ pg })
 await logger.migrate()
-app.use('/logs', logger.router())
+app.use('/logs', logger)
 await logger.clean(12)   // drop partitions older than 12 months
 await logger.log({ level: 'info', source: 'app', message: 'hello', metadata: { userId: 1 } })
 ```
@@ -317,13 +353,17 @@ await logger.log({ level: 'info', source: 'app', message: 'hello', metadata: { u
 | GET | `/` | Query (`?level=`, `?source=`, `?after=`, `?before=`, `?meta.*=`) |
 | GET | `/:id` | Get single entry |
 
-### logger [A]
+### logger [α]
 
 ```ts
 app.use(logger())                             // GET /hello 200 5ms
 app.use(logger({ format: 'combined' }))       // with query params
 ```
 
+| Option | Type | Default | Description |
+|--------|------|---------|-------------|
+| `format` | `'short' \| 'combined'` | `'short'` | Log format: path only, or path + query params |
+
 ### mailer
 
 ```ts
@@ -337,25 +377,32 @@ await mail.send({ to: 'user@test.com', subject: 'Hello', text: 'Body', html: '<p
 | `from` | `string` | — | Default sender address |
 | `send` | `function` | — | Custom send function (alternative to transport) |
 
-### messager [C]
+### messager [β]
 
 Real-time chat with channels, WebSocket, agent routing.
 
 ```ts
 const msg = messager({ pg, agents, redis: redis() })
 await msg.migrate()
+app.use('/api', msg)
 app.ws('/ws', msg.wsHandler())
 await msg.send(channelId, 'System message', { sender_type: 'system', sender_id: 'bot' })
 ```
 
+| Option | Type | Default | Description |
+|--------|------|---------|-------------|
+| `pg` | `object` | — | PostgreSQL client |
+| `agents` | `AgentModule` | — | Agent module for routing |
+| `webhookTimeout` | `number` | — | Webhook timeout |
+| `redis` | `object` | — | Redis client |
+
 | Method | Description |
 |--------|-------------|
 | `.wsHandler()` | WebSocket handler (channels, typing, read receipts) |
 | `.send(channel, content, opts?)` | Send message to channel |
-| `.router()` | REST API |
 | `.close()` | Cleanup |
 
-### opencode [C]
+### opencode [β]
 
 AI programming assistant.
 
@@ -367,14 +414,14 @@ const oc = await opencode({
   permissions: { bash: { allow: true }, write: { allow: false } },
 })
 await oc.migrate()
-app.use('/opencode', await oc.router())
+app.use('/opencode', oc)
 app.ws('/opencode', oc.wsHandler())
 ```
 
 | Option | Type | Default | Description |
 |--------|------|---------|-------------|
 | `pg` | `object` | — | PostgreSQL client |
-| `model` | `object` | — | AI model |
+| `model` | `string` | — | AI model name (e.g. `'gpt-4o'`, `'deepseek-v4-flash'`) |
 | `baseURL` | `string` | — | OpenAI-compatible API base URL |
 | `apiKey` | `string` | — | API key for the model |
 | `workspace` | `string` | — | Project directory |
@@ -382,7 +429,7 @@ app.ws('/opencode', oc.wsHandler())
 | `skills` | `object[]` | — | Custom skill definitions |
 | `permissions` | `object` | — | Tool permission rules |
 
-### postgres [B]
+### postgres [α]
 
 ```ts
 const pg = postgres()          // reads DATABASE_URL
@@ -413,7 +460,7 @@ await pg.transaction(async (tx) => { const users = pg.table('_users', { ... }).w
 
 Where helpers: `eq`, `ne`, `gt`, `gte`, `lt`, `lte`, `isNull`, `isNotNull`, `like`, `contains`, `in_`, `and`, `or`, `not`.
 
-### preferences [A]
+### preferences [α]
 
 Locale detection + theme + translations. `/__lang/:locale` and `/__theme/:theme` auto-routed.
 
@@ -444,7 +491,7 @@ const { theme, resolvedTheme, setTheme } = useTheme()
 // resolvedTheme resolves 'system' → 'dark'|'light' based on prefers-color-scheme
 ```
 
-### queue [B]
+### queue [α]
 
 ```ts
 const q = queue({ redis })
@@ -467,7 +514,7 @@ await q.add('send-email', { to: 'user@test.com' }, { cron: '0 8 * * *' })
 | `.stop()` | Stop processing |
 | `.close()` | Cleanup |
 
-### rateLimit [B]
+### rateLimit [α]
 
 ```ts
 app.use(rateLimit({ max: 100, window: 60_000 }))            // 100 req/min
@@ -484,7 +531,7 @@ app.use(rateLimit({ key: (req) => req.headers.get('x-api-key') ?? 'anonymous' })
 | `key` | `(req) => string` | IP-based | Key function |
 | `message` | `string` | `'Too Many Requests'` | 429 response body |
 
-### redis [B]
+### redis [α]
 
 ```ts
 const r = redis()          // reads REDIS_URL
@@ -498,7 +545,7 @@ await ctx.redis.set('key', 'value')
 | `url` | `string` | `REDIS_URL` env | Redis connection string |
 | (all ioredis options) | — | — | Passed directly to ioredis |
 
-### requestId [A]
+### requestId [α]
 
 ```ts
 app.use(requestId())
@@ -511,10 +558,10 @@ app.use(requestId({ header: 'X-Request-Id', generator: () => crypto.randomUUID()
 | `header` | `string` | `'X-Request-ID'` | Header name to read/write |
 | `generator` | `() => string` | `crypto.randomUUID()` | ID generator |
 
-### seo [D] + seoMiddleware [A]
+### seo [β] + seoMiddleware [α]
 
 ```ts
-app.use(seo({ baseUrl: 'https://example.com', robots: [{ userAgent: '*', allow: '/' }], sitemap: { urls: [{ loc: '/' }] } }))
+app.use('/', seo({ baseUrl: 'https://example.com', robots: [{ userAgent: '*', allow: '/' }], sitemap: { urls: [{ loc: '/' }] } }))
 // GET /robots.txt, GET /sitemap.xml
 
 app.use(seoMiddleware({ headers: { 'X-Robots-Tag': (path) => path.startsWith('/admin') ? 'noindex' : undefined } }))
@@ -522,7 +569,14 @@ app.use(seoMiddleware({ headers: { 'X-Robots-Tag': (path) => path.startsWith('/a
 
 Also exports `seoTags(config)` for generating meta/og/twitter tags as an HTML string.
 
-### tenant [C]
+| Option | Type | Default | Description |
+|--------|------|---------|-------------|
+| `baseUrl` | `string` | — | Base URL for sitemap URLs |
+| `robots` | `RobotsRule[]` | `[{ userAgent: '*', allow: '/' }]` | Robots.txt rules |
+| `sitemap` | `SitemapConfig` | — | Sitemap configuration (urls, resolve, cacheTTL) |
+| `headers` | `SeoHeadersConfig` | — | Response headers (e.g. `X-Robots-Tag`) |
+
+### tenant [β]
 
 Multi-tenant BaaS with dynamic table API and GraphQL.
 
@@ -530,11 +584,16 @@ Multi-tenant BaaS with dynamic table API and GraphQL.
 const t = tenant({ pg, usersTable: '_users' })
 await t.migrate()
 app.use('/api', t.middleware())   // → ctx.tenant
-app.use('/api', t.router())      // dynamic CRUD
+app.use('/api', t)      // dynamic CRUD
 app.use('/graphql', t.graphql()) // dynamic GraphQL
 ```
 
-### upload [A]
+| Option | Type | Default | Description |
+|--------|------|---------|-------------|
+| `pg` | `object` | — | PostgreSQL client |
+| `usersTable` | `string` | — | Users table name for tenant membership lookup |
+
+### upload [α]
 
 ```ts
 app.post('/upload', upload({ dir: './uploads', maxFileSize: 10_485_760, allowedTypes: ['image/jpeg', 'image/png'] }), (req, ctx) => {
@@ -550,14 +609,14 @@ app.post('/upload', upload({ dir: './uploads', maxFileSize: 10_485_760, allowedT
 | `maxFileSize` | `number` | — | Max bytes per file |
 | `allowedTypes` | `string[]` | — | Allowed MIME types |
 
-### user [C]
+### user [β]
 
 Authentication: register, login, JWT, OAuth2.
 
 ```ts
 const auth = user({ pg, jwtSecret: process.env.JWT_SECRET! })
 await auth.migrate()
-app.use('/auth', auth.router())               // POST /register, POST /login, OAuth2 routes
+app.use('/auth', auth)               // POST /register, POST /login, OAuth2 routes
 app.get('/me', auth.middleware(), (req, ctx) => Response.json(ctx.user))
 ```
 
@@ -574,10 +633,9 @@ app.get('/me', auth.middleware(), (req, ctx) => Response.json(ctx.user))
 | `.register(data)` | Register a new user programmatically |
 | `.login(data)` | Log in programmatically |
 | `.verify(token)` | Verify JWT token |
-| `.router()` | REST routes (register, login, OAuth2) |
 | `.middleware()` | JWT verify middleware — sets `ctx.user` |
 
-### validate [A]
+### validate [α]
 
 ```ts
 import { z } from 'zod'
@@ -789,21 +847,7 @@ import { openai, streamText, generateText, streamObject, generateObject, tool, e
 import { runWorkflow } from 'weifuwu'
 ```
 
-### Streaming
-
-```ts
-const chat = await aiStream(async (req) => ({ model: openai('gpt-4o'), messages: (await req.json()).messages }))
-app.use('/chat', chat.router().handler())
-```
-
-### Agents
-
-```ts
-const agents = agent({ pg })
-await agents.migrate()
-app.use('/api', agents.router())
-await agents.addKnowledge(agentId, 'Title', 'content')
-```
+For AI streaming endpoints see [`aiStream`](#aistream-β). For AI agent APIs see [`agent`](#agent-β).
 
 ### DAG Workflow
 

package/dist/agent/types.d.ts

@@ -1,3 +1,4 @@
+import type { Router } from '../router.ts';
 import type { LanguageModel, EmbeddingModel, Tool } from 'ai';
 export interface AgentConfig {
     id: number;
@@ -42,9 +43,8 @@ export interface AgentOptions {
     embeddingDimension?: number;
     tools?: Record<string, Tool>;
 }
-export interface AgentModule {
+export interface AgentModule extends Router {
     migrate: () => Promise<void>;
-    router: () => any;
     run: (agentId: number, params: RunParams) => Promise<RunResult>;
     addKnowledge: (agentId: number, title: string, content: string) => Promise<KnowledgeDoc>;
     close: () => Promise<void>;

package/dist/ai.d.ts

@@ -2,6 +2,4 @@ import type { Context } from './types.ts';
 import { Router } from './router.ts';
 export type AIHandler = (req: Request, ctx: Context) => Record<string, unknown> | Promise<Record<string, unknown>>;
 export declare const _ai: Record<string, any>;
-export declare function aiStream(handler: AIHandler): Promise<{
-    router(): Router;
-}>;
+export declare function aiStream(handler: AIHandler): Promise<Router>;

package/dist/analytics.d.ts

@@ -7,9 +7,8 @@ export interface AnalyticsOptions {
         table: (name: string, cols: any) => any;
     };
 }
-export interface AnalyticsModule {
+export interface AnalyticsModule extends Router {
     middleware: () => Middleware;
-    router: () => Router;
     migrate: () => Promise<void>;
     close: () => Promise<void>;
 }

package/dist/graphql.d.ts

@@ -9,6 +9,4 @@ export interface GraphQLOptions {
     graphiql?: boolean;
 }
 export type GraphQLHandler = (req: Request, ctx: Context) => GraphQLOptions | Promise<GraphQLOptions>;
-export declare function graphql(handler: GraphQLHandler): {
-    router(): Router;
-};
+export declare function graphql(handler: GraphQLHandler): Router;

package/dist/iii/types.d.ts

@@ -30,8 +30,7 @@ export interface TriggerOptions {
     action?: 'sync' | 'void';
     timeout_ms?: number;
 }
-export interface IIIModule {
-    router: () => Router;
+export interface IIIModule extends Router {
     wsHandler: () => any;
     addWorker: (worker: Worker) => void;
     trigger: (request: TriggerRequest) => Promise<unknown>;

package/dist/index.js

@@ -2292,7 +2292,7 @@ function graphql(handler) {
     }
     return executeQuery(schema, params, options, req, ctx);
   });
-  return { router: () => r };
+  return r;
 }
 
 // ai.ts
@@ -2319,7 +2319,7 @@ async function aiStream(handler) {
     const result = streamText4(options);
     return result.toTextStreamResponse();
   });
-  return { router: () => r };
+  return r;
 }
 
 // ai/workflow.ts
@@ -3592,8 +3592,8 @@ function user(options) {
     };
   }
   function router() {
-    const r = new Router();
-    r.post("/register", async (req) => {
+    const r2 = new Router();
+    r2.post("/register", async (req) => {
       try {
         const body = await req.json();
         const result = await register(body);
@@ -3606,7 +3606,7 @@ function user(options) {
         return Response.json({ error: err.message }, { status });
       }
     });
-    r.post("/login", async (req) => {
+    r2.post("/login", async (req) => {
       try {
         const body = await req.json();
         const result = await login(body);
@@ -3622,30 +3622,29 @@ function user(options) {
       }
     });
     if (oauth2) {
-      r.get("/oauth/authorize", (req, ctx) => oauth2.authorizeHandler(req, ctx));
-      r.post("/oauth/consent", (req) => oauth2.consentHandler(req));
-      r.post("/oauth/token", (req) => oauth2.tokenHandler(req));
-    }
-    return r;
-  }
-  const mod = {
-    router,
-    middleware,
-    migrate,
-    register,
-    login,
-    verify,
-    registerClient: oauth2 ? (data) => oauth2.registerClient(data) : async () => {
-      throw new Error("OAuth2 server is not enabled");
-    },
-    getClient: oauth2 ? (clientId) => oauth2.getClient(clientId) : async () => {
-      throw new Error("OAuth2 server is not enabled");
-    },
-    revokeClient: oauth2 ? (clientId) => oauth2.revokeClient(clientId) : async () => {
-      throw new Error("OAuth2 server is not enabled");
-    },
-    close: () => base.close()
+      r2.get("/oauth/authorize", (req, ctx) => oauth2.authorizeHandler(req, ctx));
+      r2.post("/oauth/consent", (req) => oauth2.consentHandler(req));
+      r2.post("/oauth/token", (req) => oauth2.tokenHandler(req));
+    }
+    return r2;
+  }
+  const r = router();
+  const mod = r;
+  mod.middleware = middleware;
+  mod.migrate = migrate;
+  mod.register = register;
+  mod.login = login;
+  mod.verify = verify;
+  mod.registerClient = oauth2 ? (data) => oauth2.registerClient(data) : async () => {
+    throw new Error("OAuth2 server is not enabled");
+  };
+  mod.getClient = oauth2 ? (clientId) => oauth2.getClient(clientId) : async () => {
+    throw new Error("OAuth2 server is not enabled");
   };
+  mod.revokeClient = oauth2 ? (clientId) => oauth2.revokeClient(clientId) : async () => {
+    throw new Error("OAuth2 server is not enabled");
+  };
+  mod.close = () => base.close();
   return mod;
 }
 
@@ -4724,76 +4723,78 @@ function tenant(options) {
   const sql2 = pg.sql;
   const usersTable = options.usersTable;
   const base = new PgModule(pg);
-  return {
-    migrate: async () => {
-      await sql2.unsafe(`CREATE EXTENSION IF NOT EXISTS "vector"`);
-      const tenants = pgTable("_tenants", {
-        id: text("id").primaryKey().default(sql`gen_random_uuid()`),
-        name: text("name").notNull(),
-        created_at: timestamptz("created_at").notNull().default(sql`NOW()`)
-      });
-      await tenants.create(sql2);
-      const members = pgTable("_tenant_members", {
-        id: serial("id").primaryKey(),
-        tenant_id: text("tenant_id").notNull().references("_tenants", "id", "cascade"),
-        user_id: integer("user_id").notNull(),
-        role: text("role").notNull().default("member"),
-        created_at: timestamptz("created_at").notNull().default(sql`NOW()`)
-      });
-      await members.create(sql2);
-      await members.createIndex(sql2, "user_id");
-      await sql2.unsafe(`CREATE UNIQUE INDEX IF NOT EXISTS "_tenant_members_unique_idx" ON "_tenant_members" ("tenant_id", "user_id")`);
-      const tables = pgTable("_user_tables", {
-        id: serial("id").primaryKey(),
-        tenant_id: text("tenant_id").notNull().references("_tenants", "id", "cascade"),
-        slug: text("slug").notNull(),
-        label: text("label").notNull().default(""),
-        fields: jsonb("fields").notNull().default(sql`'[]'::jsonb`),
-        created_at: timestamptz("created_at").notNull().default(sql`NOW()`)
-      });
-      await tables.create(sql2);
-      await tables.createIndex(sql2, "tenant_id");
-      await sql2.unsafe(`CREATE UNIQUE INDEX IF NOT EXISTS "_user_tables_unique_idx" ON "_user_tables" ("tenant_id", "slug")`);
-    },
-    middleware() {
-      return async (req, ctx, next) => {
-        const user2 = ctx.user;
-        if (!user2) {
-          return new Response("Unauthorized", { status: 401 });
-        }
-        const members = await sql2`
-          SELECT tm.role, t.id, t.name
-          FROM "_tenant_members" tm
-          JOIN "_tenants" t ON t.id = tm.tenant_id
-          WHERE tm.user_id = ${user2.id}
-        `;
-        if (members.length === 0) {
-          return new Response("No tenant found. Create one via POST /sys/tenants.", { status: 403 });
-        }
-        if (members.length === 1) {
-          const m = members[0];
-          ctx.tenant = { id: m.id, name: m.name, role: m.role };
-          return next(req, ctx);
-        }
-        const headerId = req.headers.get("X-Tenant-ID");
-        if (!headerId) {
-          return Response.json({
-            error: "Multiple tenants. Set X-Tenant-ID header.",
-            tenants: members.map((m) => ({ id: m.id, name: m.name, role: m.role }))
-          }, { status: 300 });
-        }
-        const member = members.find((m) => m.id === headerId);
-        if (!member) {
-          return new Response("Tenant not found", { status: 403 });
-        }
-        ctx.tenant = { id: member.id, name: member.name, role: member.role };
+  async function migrate() {
+    await sql2.unsafe(`CREATE EXTENSION IF NOT EXISTS "vector"`);
+    const tenants = pgTable("_tenants", {
+      id: text("id").primaryKey().default(sql`gen_random_uuid()`),
+      name: text("name").notNull(),
+      created_at: timestamptz("created_at").notNull().default(sql`NOW()`)
+    });
+    await tenants.create(sql2);
+    const members = pgTable("_tenant_members", {
+      id: serial("id").primaryKey(),
+      tenant_id: text("tenant_id").notNull().references("_tenants", "id", "cascade"),
+      user_id: integer("user_id").notNull(),
+      role: text("role").notNull().default("member"),
+      created_at: timestamptz("created_at").notNull().default(sql`NOW()`)
+    });
+    await members.create(sql2);
+    await members.createIndex(sql2, "user_id");
+    await sql2.unsafe(`CREATE UNIQUE INDEX IF NOT EXISTS "_tenant_members_unique_idx" ON "_tenant_members" ("tenant_id", "user_id")`);
+    const tables = pgTable("_user_tables", {
+      id: serial("id").primaryKey(),
+      tenant_id: text("tenant_id").notNull().references("_tenants", "id", "cascade"),
+      slug: text("slug").notNull(),
+      label: text("label").notNull().default(""),
+      fields: jsonb("fields").notNull().default(sql`'[]'::jsonb`),
+      created_at: timestamptz("created_at").notNull().default(sql`NOW()`)
+    });
+    await tables.create(sql2);
+    await tables.createIndex(sql2, "tenant_id");
+    await sql2.unsafe(`CREATE UNIQUE INDEX IF NOT EXISTS "_user_tables_unique_idx" ON "_user_tables" ("tenant_id", "slug")`);
+  }
+  function middleware() {
+    return async (req, ctx, next) => {
+      const user2 = ctx.user;
+      if (!user2) {
+        return new Response("Unauthorized", { status: 401 });
+      }
+      const members = await sql2`
+        SELECT tm.role, t.id, t.name
+        FROM "_tenant_members" tm
+        JOIN "_tenants" t ON t.id = tm.tenant_id
+        WHERE tm.user_id = ${user2.id}
+      `;
+      if (members.length === 0) {
+        return new Response("No tenant found. Create one via POST /sys/tenants.", { status: 403 });
+      }
+      if (members.length === 1) {
+        const m = members[0];
+        ctx.tenant = { id: m.id, name: m.name, role: m.role };
         return next(req, ctx);
-      };
-    },
-    router: () => buildRouter(sql2, usersTable),
-    graphql: () => buildGraphQLHandler(sql2),
-    close: () => base.close()
-  };
+      }
+      const headerId = req.headers.get("X-Tenant-ID");
+      if (!headerId) {
+        return Response.json({
+          error: "Multiple tenants. Set X-Tenant-ID header.",
+          tenants: members.map((m) => ({ id: m.id, name: m.name, role: m.role }))
+        }, { status: 300 });
+      }
+      const member = members.find((m) => m.id === headerId);
+      if (!member) {
+        return new Response("Tenant not found", { status: 403 });
+      }
+      ctx.tenant = { id: member.id, name: member.name, role: member.role };
+      return next(req, ctx);
+    };
+  }
+  const r = buildRouter(sql2, usersTable);
+  const mod = r;
+  mod.migrate = migrate;
+  mod.middleware = middleware;
+  mod.graphql = () => buildGraphQLHandler(sql2);
+  mod.close = () => base.close();
+  return mod;
 }
 
 // agent/client.ts
@@ -5070,18 +5071,18 @@ function agent(options) {
   });
   const runner = createRunner({ sql: sql2, agents: agentsTable, knowledge: knowledgeTable, getModel, getEmbeddingModel, userTools: options.tools });
   const base = new PgModule(pg);
-  return {
-    migrate: async () => {
-      await agentsTable.create();
-      await agentsTable.createIndex("tenant_id");
-      await knowledgeTable.create();
-      await knowledgeTable.createIndex("agent_id");
-    },
-    router: () => buildRouter2({ agents: agentsTable, knowledge: knowledgeTable, runner }),
-    run: (agentId, params) => runner.run(agentId, params),
-    addKnowledge: (agentId, title, content) => runner.addKnowledge(agentId, title, content),
-    close: () => base.close()
+  const r = buildRouter2({ agents: agentsTable, knowledge: knowledgeTable, runner });
+  const mod = r;
+  mod.migrate = async () => {
+    await agentsTable.create();
+    await agentsTable.createIndex("tenant_id");
+    await knowledgeTable.create();
+    await knowledgeTable.createIndex("agent_id");
   };
+  mod.run = (agentId, params) => runner.run(agentId, params);
+  mod.addKnowledge = (agentId, title, content) => runner.addKnowledge(agentId, title, content);
+  mod.close = () => base.close();
+  return mod;
 }
 
 // messager/agent.ts
@@ -5390,31 +5391,32 @@ function messager(options) {
     mime_type: text("mime_type"),
     created_at: timestamptz("created_at").notNull().default(sql`NOW()`)
   });
-  return {
-    migrate: async () => {
-      await channels.create();
-      await channels.createIndex("tenant_id");
-      await members.create();
-      await members.createIndex("member_id");
-      await members.createIndex(["channel_id", "member_id", "member_type"], { unique: true });
-      await messages2.create();
-      await messages2.createIndex(["channel_id", "created_at"], { desc: true });
-    },
-    router: () => buildRouter3({ sql: sql2, channels, members, messages: messages2, agents, hub }),
-    wsHandler: () => wsResult.handler,
-    async send(channelId, content, opts) {
-      const msg = await messages2.insert({
-        channel_id: channelId,
-        sender_id: opts?.sender_id ?? 0,
-        sender_type: opts?.sender_type ?? "system",
-        type: opts?.type ?? "text",
-        content
-      });
-      broadcastToChannel(hub, channelId, { type: "message", data: msg });
-      return msg;
-    },
-    close: () => base.close()
+  const r = buildRouter3({ sql: sql2, channels, members, messages: messages2, agents, hub });
+  async function send(channelId, content, opts) {
+    const msg = await messages2.insert({
+      channel_id: channelId,
+      sender_id: opts?.sender_id ?? 0,
+      sender_type: opts?.sender_type ?? "system",
+      type: opts?.type ?? "text",
+      content
+    });
+    broadcastToChannel(hub, channelId, { type: "message", data: msg });
+    return msg;
+  }
+  const mod = r;
+  mod.migrate = async () => {
+    await channels.create();
+    await channels.createIndex("tenant_id");
+    await members.create();
+    await members.createIndex("member_id");
+    await members.createIndex(["channel_id", "member_id", "member_type"], { unique: true });
+    await messages2.create();
+    await messages2.createIndex(["channel_id", "created_at"], { desc: true });
   };
+  mod.wsHandler = () => wsResult.handler;
+  mod.send = send;
+  mod.close = () => base.close();
+  return mod;
 }
 
 // deploy/index.ts
@@ -6838,47 +6840,47 @@ async function opencode(options) {
   const model = provider.chat(modelName);
   const pendingQuestions = /* @__PURE__ */ new Map();
   const base = new PgModule(pg);
-  return {
-    migrate: async () => {
-      const sessions2 = pgTable("_opencode_sessions", {
-        id: uuid("id").default(sql`gen_random_uuid()`).primaryKey(),
-        tenant_id: text("tenant_id"),
-        user_id: integer("user_id").default(0),
-        title: text("title"),
-        agent_type: text("agent_type").default("build"),
-        model: text("model").default("deepseek-v4-flash"),
-        system_prompt: text("system_prompt"),
-        workspace: text("workspace"),
-        metadata: jsonb("metadata").default(sql`'{}'::jsonb`),
-        active: boolean_("active").default(true),
-        created_at: timestamptz("created_at").default(sql`NOW()`),
-        updated_at: timestamptz("updated_at").default(sql`NOW()`)
-      });
-      await sessions2.create(sql2);
-      await sessions2.createIndex(sql2, "user_id");
-      const messages2 = pgTable("_opencode_messages", {
-        id: serial("id").primaryKey(),
-        session_id: uuid("session_id").notNull().references("_opencode_sessions", "id", "cascade"),
-        role: text("role").notNull(),
-        content: text("content"),
-        tool_calls: jsonb("tool_calls"),
-        tool_results: jsonb("tool_results"),
-        tokens_in: integer("tokens_in").default(0),
-        tokens_out: integer("tokens_out").default(0),
-        created_at: timestamptz("created_at").default(sql`NOW()`)
-      });
-      await messages2.create(sql2);
-      await messages2.createIndex(sql2, ["session_id", "created_at"]);
-    },
-    router: () => buildRouter4({ sql: sql2, model, workspace, systemPrompt, skills: manualSkills, skillsRegistry, permissions, pendingQuestions }),
-    wsHandler: () => createWSHandler2({ sql: sql2, model, workspace, systemPrompt, skills: manualSkills, skillsRegistry, permissions, pendingQuestions }),
-    close: () => base.close()
+  const r = await buildRouter4({ sql: sql2, model, workspace, systemPrompt, skills: manualSkills, skillsRegistry, permissions, pendingQuestions });
+  const mod = r;
+  mod.migrate = async () => {
+    const sessions2 = pgTable("_opencode_sessions", {
+      id: uuid("id").default(sql`gen_random_uuid()`).primaryKey(),
+      tenant_id: text("tenant_id"),
+      user_id: integer("user_id").default(0),
+      title: text("title"),
+      agent_type: text("agent_type").default("build"),
+      model: text("model").default("deepseek-v4-flash"),
+      system_prompt: text("system_prompt"),
+      workspace: text("workspace"),
+      metadata: jsonb("metadata").default(sql`'{}'::jsonb`),
+      active: boolean_("active").default(true),
+      created_at: timestamptz("created_at").default(sql`NOW()`),
+      updated_at: timestamptz("updated_at").default(sql`NOW()`)
+    });
+    await sessions2.create(sql2);
+    await sessions2.createIndex(sql2, "user_id");
+    const messages2 = pgTable("_opencode_messages", {
+      id: serial("id").primaryKey(),
+      session_id: uuid("session_id").notNull().references("_opencode_sessions", "id", "cascade"),
+      role: text("role").notNull(),
+      content: text("content"),
+      tool_calls: jsonb("tool_calls"),
+      tool_results: jsonb("tool_results"),
+      tokens_in: integer("tokens_in").default(0),
+      tokens_out: integer("tokens_out").default(0),
+      created_at: timestamptz("created_at").default(sql`NOW()`)
+    });
+    await messages2.create(sql2);
+    await messages2.createIndex(sql2, ["session_id", "created_at"]);
   };
+  mod.wsHandler = () => createWSHandler2({ sql: sql2, model, workspace, systemPrompt, skills: manualSkills, skillsRegistry, permissions, pendingQuestions });
+  mod.close = () => base.close();
+  return mod;
 }
 
 // health.ts
 function health(options) {
-  const path2 = options?.path ?? "/health";
+  const path2 = options?.path ?? "/";
   const r = new Router();
   const handler = async () => {
     try {
@@ -7099,18 +7101,19 @@ function analytics(options) {
       headers: { "content-type": "text/html; charset=utf-8" }
     });
   };
-  const router = () => {
-    const r = new Router();
-    r.get("/__analytics/data", handler);
-    r.get("/__analytics", handler);
-    return r;
-  };
+  const r = new Router();
+  r.get("/__analytics/data", handler);
+  r.get("/__analytics", handler);
   const migrate = async () => {
     if (pg) await migratePg(pg.sql, pg.table);
   };
   const close = async () => {
   };
-  return { middleware, router, migrate, close };
+  const mod = r;
+  mod.middleware = middleware;
+  mod.migrate = migrate;
+  mod.close = close;
+  return mod;
 }
 
 // preferences.ts
@@ -7585,11 +7588,11 @@ function logdb(options) {
     return row;
   }
   function router() {
-    const r = new Router();
-    r.post("/", createHandler(entries));
-    r.get("/", listHandler(entries));
-    r.get("/:id", getHandler(entries));
-    return r;
+    const r2 = new Router();
+    r2.post("/", createHandler(entries));
+    r2.get("/", listHandler(entries));
+    r2.get("/:id", getHandler(entries));
+    return r2;
   }
   async function clean(retentionMonths) {
     const cutoff = /* @__PURE__ */ new Date();
@@ -7611,21 +7614,22 @@ function logdb(options) {
     }
     return dropped;
   }
-  return {
-    log,
-    router,
-    migrate: async () => {
-      await entries.create({ partitionBy: partitionBy("range", "created_at") });
-      await entries.createIndex(["created_at", "id"]);
-      await entries.createIndex(["level"]);
-      await entries.createIndex(["source"]);
-      await entries.createIndex(["level", "created_at"]);
-      await ensurePartitions(sql2, tableName);
-    },
-    clean,
-    close: async () => {
-    }
+  async function migrate() {
+    await entries.create({ partitionBy: partitionBy("range", "created_at") });
+    await entries.createIndex(["created_at", "id"]);
+    await entries.createIndex(["level"]);
+    await entries.createIndex(["source"]);
+    await entries.createIndex(["level", "created_at"]);
+    await ensurePartitions(sql2, tableName);
+  }
+  const r = router();
+  const mod = r;
+  mod.log = log;
+  mod.migrate = migrate;
+  mod.clean = clean;
+  mod.close = async () => {
   };
+  return mod;
 }
 
 // iii/client.ts
@@ -8234,6 +8238,7 @@ function iii(opts = {}) {
     for (const t of reg.triggers) triggers.delete(t.id);
     workers.delete(workerId);
   }
+  let engineRef = null;
   const wsHandler = createWsHandler({
     registerRemoteWorker(ws, name) {
       const id2 = crypto6.randomUUID();
@@ -8304,7 +8309,7 @@ function iii(opts = {}) {
         }));
         return;
       }
-      const ctx = { engine: module, functionId, workerName: fn.workerName };
+      const ctx = { engine: engineRef, functionId, workerName: fn.workerName };
       Promise.resolve(fn.handler(payload, ctx)).then((result) => {
         ws.send(JSON.stringify({ type: "invoke_result", invocation_id: invocationId, result }));
       }).catch((err) => {
@@ -8312,70 +8317,78 @@ function iii(opts = {}) {
       });
     }
   });
-  const module = {
-    router: () => {
-      const r = buildRouter5(module, wsHandler);
-      module.router = () => r;
-      return r;
-    },
-    wsHandler: () => wsHandler,
-    addWorker: addLocalWorker,
-    removeWorker: (worker) => {
-      for (const [wid, reg] of workers) {
-        if (reg.name === worker.name) {
-          removeWorker(wid);
-          return;
-        }
+  function removeWorkerByName(worker) {
+    for (const [wid, reg] of workers) {
+      if (reg.name === worker.name) {
+        removeWorker(wid);
+        return;
       }
-    },
-    trigger(request) {
-      const fn = functions.get(request.function_id);
-      if (!fn) throw new Error(`Function "${request.function_id}" not found`);
-      const ctx = { engine: module, functionId: request.function_id, workerName: fn.workerName };
-      if (request.action === "void") {
-        queueMicrotask(() => fn.handler(request.payload, ctx));
-        return Promise.resolve(void 0);
-      }
-      return Promise.resolve(fn.handler(request.payload, ctx));
-    },
-    listWorkers: () => Array.from(workers.values()).map((w) => ({
+    }
+  }
+  function trigger(request) {
+    const fn = functions.get(request.function_id);
+    if (!fn) throw new Error(`Function "${request.function_id}" not found`);
+    const ctx = { engine: engineRef, functionId: request.function_id, workerName: fn.workerName };
+    if (request.action === "void") {
+      queueMicrotask(() => fn.handler(request.payload, ctx));
+      return Promise.resolve(void 0);
+    }
+    return Promise.resolve(fn.handler(request.payload, ctx));
+  }
+  function listWorkers() {
+    return Array.from(workers.values()).map((w) => ({
       id: w.id,
       name: w.name,
       status: "connected",
       connectedAt: Date.now(),
       functionCount: w.functions.length,
       triggerCount: w.triggers.length
-    })),
-    listFunctions: () => Array.from(functions.values()).map((f) => ({
+    }));
+  }
+  function listFunctions() {
+    return Array.from(functions.values()).map((f) => ({
       id: f.id,
       workerId: f.workerId,
       workerName: f.workerName,
       triggers: f.triggers
-    })),
-    listTriggers: () => Array.from(triggers.values()).map((t) => ({
+    }));
+  }
+  function listTriggers() {
+    return Array.from(triggers.values()).map((t) => ({
       id: t.id,
       type: t.type,
       function_id: t.function_id,
       config: t.config,
       workerId: t.workerId
-    })),
-    migrate: async () => {
-      await stream.migrate();
-    },
-    shutdown: async () => {
-      for (const [, p] of pending) {
-        clearTimeout(p.timer);
-        p.reject(new Error("Engine shutting down"));
-      }
-      pending.clear();
-      for (const [, reg] of workers) reg.ws?.close();
-      workers.clear();
-      functions.clear();
-      triggers.clear();
-      await stream.close();
-    }
+    }));
+  }
+  const routerMethods = { listWorkers, listFunctions, listTriggers, trigger };
+  const r = buildRouter5(routerMethods, wsHandler);
+  engineRef = r;
+  const mod = r;
+  mod.wsHandler = () => wsHandler;
+  mod.addWorker = addLocalWorker;
+  mod.removeWorker = removeWorkerByName;
+  mod.trigger = trigger;
+  mod.listWorkers = listWorkers;
+  mod.listFunctions = listFunctions;
+  mod.listTriggers = listTriggers;
+  mod.migrate = async () => {
+    await stream.migrate();
   };
-  return module;
+  mod.shutdown = async () => {
+    for (const [, p] of pending) {
+      clearTimeout(p.timer);
+      p.reject(new Error("Engine shutting down"));
+    }
+    pending.clear();
+    for (const [, reg] of workers) reg.ws?.close();
+    workers.clear();
+    functions.clear();
+    triggers.clear();
+    await stream.close();
+  };
+  return mod;
 }
 
 // iii/worker.ts

package/dist/logdb/types.d.ts

@@ -18,9 +18,8 @@ export interface LogEntryInput {
     message: string;
     metadata?: Record<string, unknown>;
 }
-export interface LogdbModule {
+export interface LogdbModule extends Router {
     log(input: LogEntryInput): Promise<LogEntry>;
-    router(): Router;
     migrate(): Promise<void>;
     clean(retentionMonths: number): Promise<number>;
     close(): Promise<void>;

package/dist/messager/types.d.ts

@@ -1,3 +1,4 @@
+import type { Router } from '../router.ts';
 import type { AgentModule } from '../agent/types.ts';
 import type { PostgresClient } from '../postgres/types.ts';
 import type { Redis } from '../vendor.ts';
@@ -36,9 +37,8 @@ export interface Message {
     mime_type: string | null;
     created_at: string;
 }
-export interface MessagerModule {
+export interface MessagerModule extends Router {
     migrate: () => Promise<void>;
-    router: () => any;
     wsHandler: () => any;
     send: (channelId: number, content: string, opts?: {
         sender_type?: string;

package/dist/opencode/types.d.ts

@@ -74,9 +74,8 @@ export interface OpencodeOptions {
     skills?: SkillDef[];
     permissions?: OpencodePermissions;
 }
-export interface OpencodeModule {
+export interface OpencodeModule extends Router {
     migrate: () => Promise<void>;
-    router: () => Router | Promise<Router>;
     wsHandler: () => any;
     close: () => Promise<void>;
 }

package/dist/tenant/types.d.ts

@@ -1,4 +1,5 @@
 import type { Context } from '../types.ts';
+import type { Router } from '../router.ts';
 import type { PostgresClient } from '../postgres/types.ts';
 declare module '../types.ts' {
     interface Context {
@@ -39,10 +40,9 @@ export interface TenantOptions {
     pg: PostgresClient;
     usersTable: string;
 }
-export interface TenantModule {
+export interface TenantModule extends Router {
     migrate: () => Promise<void>;
     middleware: () => (req: Request, ctx: Context, next: any) => Promise<Response>;
-    router: () => any;
     graphql: () => any;
     close: () => Promise<void>;
 }

package/dist/user/types.d.ts

@@ -31,8 +31,7 @@ export interface UserOptions {
     expiresIn?: string | number;
     oauth2?: OAuth2ServerOptions;
 }
-export interface UserModule {
-    router: () => Router;
+export interface UserModule extends Router {
     middleware: () => Middleware;
     migrate: () => Promise<void>;
     register: (data: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "weifuwu",
-  "version": "0.18.0",
+  "version": "0.18.1",
   "description": "Web-standard HTTP framework for Node.js — (req, ctx) => Response",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",