weifuwu 0.28.2 → 0.30.1

package/README.md

@@ -0,0 +1,394 @@
+# weifuwu
+
+Web-standard HTTP microframework for Node.js — `(req, ctx) => Response`.
+
+## Usage
+
+```bash
+npm install weifuwu
+```
+
+```ts
+import { serve, Router } from 'weifuwu'
+
+const app = new Router()
+app.get('/', () => new Response('Hello'))
+serve(app, { port: 3000 })
+```
+
+## Exports
+
+Everything is exported from `'weifuwu'`:
+
+### Core
+
+| Export | Kind | Description |
+|---|---|---|
+| `serve(app, opts?)` | function | Start HTTP server. Takes a `Router`. Returns `Server`. |
+| `Router` | class | Trie-based HTTP router with WebSocket support. |
+| `loadEnv(path?)` | function | Load `.env` file into `process.env`. |
+| `isDev()` | function | `true` unless `NODE_ENV` is `production` or `test`. |
+| `isProd()` | function | `true` if `NODE_ENV` is `production`. |
+| `isBundled()` | function | `true` when running the esbuild bundle (checks `__WFW_BUNDLED__`). |
+| `getPublicEnv()` | function | Returns all `process.env` keys prefixed with `WEIFUWU_PUBLIC_`. |
+| `DEFAULT_MAX_BODY` | const | `10 * 1024 * 1024` (10MB). |
+
+### Router
+
+```ts
+const app = new Router()
+
+// HTTP methods
+app.get(path, ...handlers)
+app.post(path, ...handlers)
+app.put(path, ...handlers)
+app.delete(path, ...handlers)
+app.patch(path, ...handlers)
+app.head(path, ...handlers)
+app.options(path, ...handlers)
+app.all(path, ...handlers)    // match any method
+
+// WebSocket
+app.ws(path, ...middlewares, handler)
+// handler: { open?, message?, close?, error? }
+
+// Middleware & mounting
+app.use(middleware)           // global middleware
+app.mount(prefix, router)     // mount sub-router at prefix
+app.onError(handler)          // global error handler
+app.routes()                  // debug: string[] of all registered routes
+
+// Path params
+app.get('/users/:id', (req, ctx) => {
+  const id = ctx.params.id   // string
+  const q = ctx.query.search // from ?search=...
+})
+```
+
+### Middleware
+
+| Export | Kind | Description |
+|---|---|---|
+| `cors(opts?)` | middleware | CORS headers. `origin`, `methods`, `headers`, `credentials`, `maxAge`. |
+| `helmet(opts?)` | middleware | Security headers (CSP, HSTS, X-Frame-Options, etc). |
+| `compress(opts?)` | middleware | gzip / brotli / deflate response compression. |
+| `rateLimit(opts?)` | middleware | Sliding-window rate limiter. `windowMs`, `max`, `keyGenerator`. |
+| `requestId(opts?)` | middleware | Generates `X-Request-ID` header. `header`, `generator`. |
+| `logger(opts?)` | middleware | Structured request logging. `format`, `level`, `stream`. |
+| `validate(schemas?)` | middleware | Zod-based request validation. `{ body?, query?, params?, headers? }`. |
+| `upload(opts?)` | middleware | Multipart file upload. `maxSize`, `dest`, `preservePath`. |
+| `health(opts?)` | function→Router | Health check router. Mount at `/_health` or custom path. |
+| `env()` | middleware | Injects `WEIFUWU_PUBLIC_*` env vars into `ctx.env`. |
+| `trace(opts?)` | middleware | Injects trace context into `ctx.trace` (requestId, traceId, startTime, elapsed). |
+
+### Route-level tools
+
+| Export | Kind | Description |
+|---|---|---|
+| `serveStatic(root, opts?)` | handler | Serve static files. `cacheControl`, `index`, `dotfiles`. |
+| `graphql(options)` | function→Router | GraphQL endpoint. Pass a `GraphQLHandler` function `({ query, variables, ctx })`. |
+
+### HTML rendering
+
+| Export | Kind | Description |
+|---|---|---|
+| `html(template, ...values)` | tagged template | Auto-escaped HTML builder. Signal/Computed-aware. |
+| `raw(content)` | function | Raw unescaped HTML string (use with caution). |
+
+### SSE (Server-Sent Events)
+
+| Export | Kind | Description |
+|---|---|---|
+| `createSSEStream()` | function | Create an SSE stream controller for `text/event-stream` responses. |
+| `formatSSE(event, data)` | function | Format a single SSE event string. |
+| `formatSSEData(data)` | function | Format SSE data string. |
+
+### Cookies
+
+| Export | Kind | Description |
+|---|---|---|
+| `getCookies(req)` | function | Parse cookies from `Request`. Returns `Record<string, string>`. |
+| `setCookie(headers, name, value, opts?)` | function | Set `Set-Cookie` header. `path`, `domain`, `maxAge`, `httpOnly`, `secure`, `sameSite`, `partitioned`. |
+| `deleteCookie(headers, name, opts?)` | function | Delete a cookie (Max-Age=0). |
+
+### Postgres
+
+| Export | Kind | Description |
+|---|---|---|
+| `postgres(opts?)` | middleware+client | Create a Postgres client. `url`, `host`, `port`, `database`, `user`, `password`, `max`. |
+| `MIGRATIONS_TABLE` | const | Migration table name: `_weifuwu_migrations`. |
+
+```ts
+const sql = postgres({ url: process.env.DATABASE_URL })
+
+// As middleware — injects ctx.sql
+app.use(sql)
+// As query client
+const rows = await sql.client`SELECT * FROM users WHERE id = ${id}`
+
+// Migrations
+await sql.migrate({
+  '001_init': async (s) => {
+    await s`CREATE TABLE users (id SERIAL PRIMARY KEY, name TEXT)`
+  },
+})
+```
+
+### Redis
+
+| Export | Kind | Description |
+|---|---|---|
+| `redis(opts?)` | middleware+client | Create a Redis client (ioredis). `url`, `host`, `port`, `password`, `db`. |
+
+```ts
+const r = redis({ url: process.env.REDIS_URL })
+app.use(r)  // injects ctx.redis
+await r.client.set('key', 'value')
+```
+
+### Queue & Cron
+
+| Export | Kind | Description |
+|---|---|---|
+| `queue(opts?)` | middleware+instance | In-process job queue with cron support. `concurrency`. |
+
+```ts
+const q = queue({ concurrency: 3 })
+app.use(q)  // injects ctx.queue
+
+q.process('send-email', async (job) => {
+  await sendEmail(job.data.to)
+})
+
+q.cron('cleanup', '0 3 * * *', async () => {
+  await cleanupOldSessions()
+})
+
+await q.add('send-email', { to: 'user@example.com' })
+```
+
+### WebSocket Hub
+
+| Export | Kind | Description |
+|---|---|---|
+| `createHub(opts?)` | function | Pub/Sub hub for cross-connection broadcast. Supports Redis adapter for multi-process. |
+
+```ts
+const hub = createHub()
+app.ws('/chat', {
+  open(ws, ctx) {
+    ctx.ws.join('lobby')
+    ctx.ws.json({ type: 'join', room: 'lobby' })
+  },
+  message(ws, ctx, data) {
+    ctx.ws.sendRoom('lobby', { type: 'chat', text: data.toString() })
+  },
+})
+```
+
+### Theme & I18n
+
+| Export | Kind | Description |
+|---|---|---|
+| `theme(opts?)` | middleware+Router | Theme middleware. Injects `ctx.theme` with `get()`, `set(theme)`, `toggle()`. Routes: `/__theme/:theme`. |
+| `i18n(opts?)` | middleware+Router | I18n middleware. Injects `ctx.i18n` with `locale`, `t(key, params?)`, `set(locale)`. `dir` for locale JSON files. Routes: `/__lang/:locale`. |
+| `flash()` | middleware | Flash messages. Injects `ctx.flash` with `set(msg)`, `get()`. One-time messages across redirects. |
+| `csrf()` | middleware | CSRF protection. Injects `ctx.csrf` with `token`. Auto-validates on `POST`/`PUT`/`PATCH`/`DELETE`. |
+
+### Tracing
+
+| Export | Kind | Description |
+|---|---|---|
+| `currentTraceId()` | function | Get current request's trace ID (from AsyncLocalStorage). |
+| `currentTrace()` | function | Get current trace context `{ traceId, startTime }`. |
+| `runWithTrace(id, fn)` | function | Run `fn` with a trace context. Auto-generates ID if null. |
+| `traceElapsed()` | function | Milliseconds since trace start. |
+
+### Error handling
+
+| Export | Kind | Description |
+|---|---|---|
+| `HttpError` | class | `new HttpError(message, status)`. Throw to return that status. |
+| `app.onError(handler)` | Router method | Global error handler: `(error, req, ctx) => Response`. |
+
+### Testing
+
+| Export | Kind | Description |
+|---|---|---|
+| `testApp(app)` | function | Create a test client for a Router. Returns `{ get, post, put, delete, patch }` for `(path, opts?)`. |
+| `createTestServer(app, opts?)` | function | Start a test server on a random port. Returns `{ server, url }`. |
+| `createTestDb()` | function | Create an ephemeral Postgres test database. |
+| `withTestDb(fn)` | function | Run `fn(sql)` with a temp database, auto-cleanup. |
+
+### Types
+
+| Export | Description |
+|---|---|
+| `Context` | `{ params, query, mountPath?, user?, loaderData?, env?, [key: string] }` |
+| `Handler<T>` | `(req: Request, ctx: T) => Response \| Promise<Response>` |
+| `Middleware<In, Out>` | `(req, ctx, next) => Response \| Promise<Response>` |
+| `WebSocketHandler` | `{ open?, message?, close?, error? }` |
+| `HttpError` | `Error` subclass with `.status: number` |
+| `Closeable` | `{ close(): Promise<void> }` |
+| `Server` | `{ stop, close, port, hostname, ready }` |
+| `ServeOptions` | `{ port, hostname, signal, maxBodySize, timeout, keepAliveTimeout, headersTimeout, shutdown }` |
+
+## Handler / Middleware patterns
+
+```ts
+// Handler — standard Web API
+app.get('/api/data', (req, ctx) => {
+  const { q } = ctx.query
+  const id = ctx.params.id
+  return Response.json({ q, id })
+})
+
+// Async
+app.get('/db/users', async (req, ctx) => {
+  const rows = await sql`SELECT * FROM users`
+  return Response.json(rows)
+})
+
+// Throwing HttpError
+app.get('/item/:id', (req, ctx) => {
+  const item = db.get(ctx.params.id)
+  if (!item) throw new HttpError('Not found', 404)
+  return Response.json(item)
+})
+
+// Middleware
+app.use(async (req, ctx, next) => {
+  const start = Date.now()
+  const res = await next(req, ctx)
+  console.log(`${req.method} ${req.url} ${Date.now() - start}ms`)
+  return res
+})
+
+// Route-level middleware (before handler)
+app.get('/admin', validate(bodySchema), authCheck, adminHandler)
+
+// Error handler
+app.onError((err, req, ctx) => {
+  if (err instanceof HttpError) {
+    return Response.json({ error: err.message }, { status: err.status })
+  }
+  console.error(err)
+  return new Response('Internal error', { status: 500 })
+})
+```
+
+## Complete example
+
+```ts
+import { serve, Router, loadEnv, cors, helmet, compress, logger, requestId, rateLimit, postgres, redis, queue, HttpError, html } from 'weifuwu'
+
+loadEnv()
+
+const app = new Router()
+
+// Global middleware
+app.use(requestId())
+app.use(logger())
+app.use(cors())
+app.use(helmet())
+app.use(compress())
+app.use(rateLimit({ windowMs: 60_000, max: 100 }))
+
+// Database & services
+const sql = postgres({ url: process.env.DATABASE_URL })
+const cache = redis({ url: process.env.REDIS_URL })
+const jobs = queue()
+
+app.use(sql)
+app.use(cache)
+app.use(jobs)
+
+// Routes
+app.get('/', () => html`<h1>weifuwu</h1><p>Running on ${process.version}</p>`)
+
+app.get('/api/users', async (req, ctx) => {
+  const users = await ctx.sql`SELECT id, name, email FROM users ORDER BY id`
+  return Response.json(users)
+})
+
+app.get('/api/users/:id', async (req, ctx) => {
+  const [user] = await ctx.sql`SELECT * FROM users WHERE id = ${ctx.params.id}`
+  if (!user) throw new HttpError('User not found', 404)
+  return Response.json(user)
+})
+
+app.post('/api/users', async (req, ctx) => {
+  const { name, email } = await req.json()
+  const [user] = await ctx.sql`INSERT INTO users (name, email) VALUES (${name}, ${email}) RETURNING *`
+  return Response.json(user, { status: 201 })
+})
+
+// Background job
+jobs.process('welcome-email', async (job) => {
+  const { userId } = job.data
+  const [user] = await sql.client`SELECT * FROM users WHERE id = ${userId}`
+  await sendWelcomeEmail(user.email)
+})
+
+app.post('/api/register', async (req, ctx) => {
+  const { name, email } = await req.json()
+  const [user] = await ctx.sql`INSERT INTO users (name, email) VALUES (${name}, ${email}) RETURNING *`
+  await ctx.queue.add('welcome-email', { userId: user.id })
+  return Response.json(user, { status: 201 })
+})
+
+// WebSocket chat
+app.ws('/chat', {
+  open(ws, ctx) {
+    ctx.ws.join('lobby')
+  },
+  message(ws, ctx, data) {
+    ctx.ws.sendRoom('lobby', { text: data.toString() })
+  },
+})
+
+// Error handling
+app.onError((err, req, ctx) => {
+  if (err instanceof HttpError) {
+    return Response.json({ error: err.message }, { status: err.status })
+  }
+  return Response.json({ error: 'Internal error' }, { status: 500 })
+})
+
+// Health check
+import { health } from 'weifuwu'
+app.mount('/_health', health())
+
+serve(app, { port: 3000 })
+```
+
+## Project Structure
+
+```
+weifuwu/
+├── package.json
+├── tsconfig.json
+├── scripts/
+│   ├── build.mjs
+│   └── release.mjs
+├── src/
+│   ├── index.ts              ← all exports
+│   ├── types.ts              ← Context, Handler, Middleware, HttpError
+├── core/                 ← serve, router, trace, env, logger, cookie, sse, html
+│   ├── middleware/        ← cors, compress, helmet, rate-limit, static, validate, upload, health, theme, i18n, flash, csrf, request-id
+├── postgres/             ← postgres client, migrations, module injection
+│   ├── redis/                ← redis client
+│   ├── queue/                ← job queue, cron
+│   ├── graphql.ts            ← schema-first GraphQL handler
+│   ├── hub.ts                ← pub/sub hub (WebSocket rooms)
+│   └── test/                 ← 324 tests
+└── dist/
+```
+
+## Development
+
+```bash
+npm run build          # esbuild bundle → dist/index.js
+npm run typecheck      # tsc --noEmit
+npm test              # node --test (324 tests, 0 failures)
+```

package/dist/core/cookie.d.ts

@@ -0,0 +1,36 @@
+/** Options for setting a cookie. All fields map to standard Set-Cookie attributes. */
+export interface CookieOptions {
+    domain?: string;
+    path?: string;
+    maxAge?: number;
+    expires?: Date;
+    httpOnly?: boolean;
+    secure?: boolean;
+    sameSite?: 'strict' | 'lax' | 'none';
+}
+/** Parse cookies from a Request's `Cookie` header.
+ *
+ * @example
+ * ```ts
+ * const cookies = getCookies(req)
+ * console.log(cookies.session_id) // value or undefined
+ * ``` */
+export declare function getCookies(req: Request): Record<string, string>;
+/** Set a cookie on a Response.
+ *
+ * Appends a `Set-Cookie` header to the existing response headers.
+ * Returns a new Response with the added header.
+ *
+ * @example
+ * ```ts
+ * const res = new Response('ok')
+ * return setCookie(res, 'session', token, { httpOnly: true, path: '/' })
+ * ``` */
+export declare function setCookie(res: Response, name: string, value: string, options?: CookieOptions): Response;
+/** Delete a cookie by setting `Max-Age=0`.
+ *
+ * @example
+ * ```ts
+ * return deleteCookie(res, 'session')
+ * ``` */
+export declare function deleteCookie(res: Response, name: string, options?: Omit<CookieOptions, 'maxAge'>): Response;

package/dist/core/env.d.ts

@@ -0,0 +1,69 @@
+import type { Context, Middleware } from '../types.ts';
+/**
+ * Get all public environment variables (those prefixed with `WEIFUWU_PUBLIC_`),
+ * with the prefix stripped.
+ *
+ * ```ts
+ * const pub = getPublicEnv()
+ * // WEIFUWU_PUBLIC_API_URL=http://api.example.com → { API_URL: 'http://api.example.com' }
+ * ```
+ */
+export declare function getPublicEnv(): Record<string, string>;
+declare module '../types.ts' {
+    interface Context {
+        env?: Record<string, string>;
+    }
+}
+/**
+ * Whether this code is running from the compiled `dist/index.js` bundle.
+ * `false` when running TypeScript source directly (dev workflow in weifuwu repo).
+ *
+ * Used by modules that need to resolve package-internal files differently
+ * depending on whether they are compiled (published npm package) or raw TS.
+ */
+export declare function isBundled(): boolean;
+/**
+ * Whether `NODE_ENV` is explicitly set to `'development'`.
+ *
+ * Used for dev-only features: HMR, livereload, React `createRoot` (not hydrate).
+ * **Not** the opposite of {@link isProd} — when `NODE_ENV` is unset, both return `false`.
+ */
+export declare function isDev(): boolean;
+/**
+ * Whether `NODE_ENV` is explicitly set to `'production'`.
+ *
+ * Used for production-only behavior: plain-text 404, suppressed warnings, minified output.
+ */
+export declare function isProd(): boolean;
+/**
+ * Load environment variables from a `.env` file into `process.env`.
+ *
+ * Does **not** override existing `process.env` values.
+ * Supports quoted values and inline comments.
+ *
+ * @param path - Path to `.env` file (default: `'.env'` relative to cwd).
+ *
+ * ```ts
+ * import { loadEnv } from 'weifuwu'
+ * loadEnv()
+ * console.log(process.env.PORT)
+ * ```
+ */
+export declare function loadEnv(path?: string): void;
+/**
+ * Public env middleware.
+ *
+ * Injects `ctx.env` with all environment variables prefixed with `WEIFUWU_PUBLIC_`,
+ * with the prefix stripped. Safe to expose to the client.
+ *
+ * ```ts
+ * import { env } from 'weifuwu'
+ * app.use(env())
+ *
+ * // .env:  WEIFUWU_PUBLIC_API_URL=https://api.example.com
+ * // ctx:   ctx.env.API_URL === 'https://api.example.com'
+ * ```
+ */
+export declare function env(): Middleware<Context, Context & {
+    env: Record<string, string>;
+}>;

package/dist/core/html.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Safe HTML rendering via tagged template literals.
+ *
+ * Auto-escapes interpolated values to prevent XSS.
+ * Use `raw()` for trusted HTML that should not be escaped.
+ *
+ * ```ts
+ * import { html, raw } from '@weifuwujs/core'
+ *
+ * html`<h1>${title}</h1>`               // auto-escaped
+ * html`<div>${raw(trustedHtml)}</div>`   // unescaped
+ * html`<ul>${items.map(i => html`<li>${i}</li>`)}</ul>`  // arrays
+ * html`${isAdmin && html`<button>Admin</button>`}`        // conditionals
+ * html`<div>${html`<span>nested</span>`}</div>`           // nested (safe)
+ * ```
+ */
+interface RawHtml {
+    _raw: string;
+}
+export type HtmlValue = string | number | boolean | null | undefined | HtmlValue[] | RawHtml;
+/**
+ * Tagged template literal for safe HTML.
+ *
+ * Interpolated values are auto-escaped. Use {@link raw} to bypass escaping
+ * for trusted HTML. Nested `html` calls are safe (not double-escaped).
+ */
+export declare function html(strings: TemplateStringsArray, ...values: HtmlValue[]): string;
+/**
+ * Bypass HTML escaping for trusted content.
+ *
+ * Can be used standalone or inside {@link html} tagged templates.
+ */
+export declare function raw(content: string): HtmlValue;
+export {};

package/dist/core/logger.d.ts

@@ -0,0 +1,16 @@
+import type { Middleware, Context } from '../types.ts';
+export interface LoggerOptions {
+    /** 'short' = method + path + status + ms, 'combined' = short + query string, 'json' = structured stderr JSON */
+    format?: 'short' | 'combined' | 'json';
+}
+export interface LogEvent {
+    level: 'info' | 'warn' | 'error';
+    message: string;
+    method?: string;
+    path?: string;
+    status?: number;
+    elapsed_ms?: number;
+    traceId?: string;
+    timestamp?: string;
+}
+export declare function logger(options?: LoggerOptions): Middleware<Context, Context>;

package/dist/core/router.d.ts

@@ -0,0 +1,95 @@
+import type { WebSocket, Context, Handler, Middleware, ErrorHandler } from '../types.ts';
+import { type IncomingMessage } from 'node:http';
+import type { Duplex } from 'node:stream';
+import { type Hub } from '../hub.ts';
+declare module '../types.ts' {
+    interface Context {
+        ws: {
+            /** Per-connection state object */
+            state: Record<string, unknown>;
+            /** Send JSON to this connection */
+            json(data: unknown): void;
+            /** Join a room */
+            join(room: string): void;
+            /** Leave a room */
+            leave(room: string): void;
+            /** Broadcast to a room */
+            sendRoom(room: string, data: unknown): void;
+        };
+    }
+}
+export type WebSocketHandler = {
+    open?: (ws: WebSocket, ctx: Context) => void | Promise<void>;
+    message?: (ws: WebSocket, ctx: Context, data: string | Buffer) => void | Promise<void>;
+    close?: (ws: WebSocket, ctx: Context) => void | Promise<void>;
+    error?: (ws: WebSocket, ctx: Context, error: Error) => void | Promise<void>;
+};
+type WsUpgradeHandler = (req: IncomingMessage, socket: Duplex, head: Buffer) => void;
+export declare class Router<T extends Context = Context> {
+    private root;
+    private wsRoot;
+    private globalMws;
+    private errorHandler?;
+    private _hasWildcard;
+    private _hub?;
+    private _wss?;
+    /** Track which ctx fields have been injected so far (for dependency checking). */
+    private _ctxFields;
+    private get wss();
+    private get hub();
+    /** Inject a custom hub (e.g. with Redis for cross-process broadcast). */
+    wsHub(hub: Hub): this;
+    /** Global middleware — accumulates types into Router<T>. */
+    use<Out extends Context>(mw: Middleware<Context, Out>): Router<T & Out>;
+    /**
+     * Mount a sub-router at the given path prefix.
+     * All routes from the sub-router are registered with the prefix.
+     *
+     * ```ts
+     * const admin = new Router()
+     * admin.get('/dashboard', handler)
+     * app.mount('/admin', admin)  // → GET /admin/dashboard
+     * ```
+     */
+    mount(path: string, router: Router<Context>): Router<T>;
+    /**
+     * Check a middleware's dependency metadata and emit warnings if
+     * required fields haven't been injected yet.
+     * Attach __meta to a middleware function:
+     *
+     * ```ts
+     * mw.__meta = { injects: ['sql'], depends: ['session'] }
+     * ```
+     */
+    private _checkMiddlewareMeta;
+    get(path: string, ...args: [...Middleware<T, T>[], Handler<T> | Router<Context>]): Router<T>;
+    post(path: string, ...args: [...Middleware<T, T>[], Handler<T> | Router<Context>]): Router<T>;
+    put(path: string, ...args: [...Middleware<T, T>[], Handler<T> | Router<Context>]): Router<T>;
+    delete(path: string, ...args: [...Middleware<T, T>[], Handler<T> | Router<Context>]): Router<T>;
+    patch(path: string, ...args: [...Middleware<T, T>[], Handler<T> | Router<Context>]): Router<T>;
+    head(path: string, ...args: [...Middleware<T, T>[], Handler<T> | Router<Context>]): Router<T>;
+    options(path: string, ...args: [...Middleware<T, T>[], Handler<T> | Router<Context>]): Router<T>;
+    all(path: string, ...args: [...Middleware<T, T>[], Handler<T> | Router<Context>]): Router<T>;
+    onError(handler: ErrorHandler<T>): Router<T>;
+    private _route;
+    /** Internal route registration — no type constraints (used by _mountRouter). */
+    private _routeImpl;
+    ws(path: string, ...args: [...Middleware<T, T>[], WebSocketHandler]): Router<T>;
+    handler(): Handler<T>;
+    /** Returns a human-readable list of all registered routes. Useful for debugging. */
+    routes(): string[];
+    private _collectRoutes;
+    private _collectWsRoutes;
+    websocketHandler(): WsUpgradeHandler;
+    private _mountRouter;
+    private _collect;
+    private _collectWs;
+    private splitPath;
+    private matchTrie;
+    private matchWsTrie;
+    private handleError;
+    private _notFoundResponse;
+    private handle;
+    private runChain;
+}
+export {};

package/dist/core/serve.d.ts

@@ -0,0 +1,36 @@
+import { type IncomingMessage, type ServerResponse } from 'node:http';
+import { Router } from './router.ts';
+export interface ServeOptions {
+    port?: number;
+    hostname?: string;
+    signal?: AbortSignal;
+    /** Max request body size in bytes. Default: 10MB. Set to 0 for unlimited. */
+    maxBodySize?: number;
+    /** Socket timeout in ms (inactivity). Default: 30_000. */
+    timeout?: number;
+    /** Keep-Alive idle timeout in ms. Default: 5_000. */
+    keepAliveTimeout?: number;
+    /** Headers timeout in ms (must be > keepAliveTimeout). Default: 6_000. */
+    headersTimeout?: number;
+    shutdown?: boolean;
+}
+export interface Server {
+    stop: (timeoutMs?: number) => Promise<void>;
+    /** Alias for `stop()`. Prefer this for consistency with other modules. */
+    close: (timeoutMs?: number) => Promise<void>;
+    readonly port: number;
+    readonly hostname: string;
+    ready: Promise<void>;
+}
+/** Default max body size: 10MB. Set maxBodySize: 0 for unlimited. */
+export declare const DEFAULT_MAX_BODY: number;
+export declare function readBody(req: IncomingMessage, maxSize?: number): Promise<Buffer>;
+export declare function createRequest(req: IncomingMessage, body: Buffer): [Request, Record<string, string>];
+export declare function sendResponse(res: ServerResponse, response: Response, opts?: {
+    traceId?: string | null;
+}): Promise<void>;
+export declare function createTestServer(router: Router, options?: ServeOptions): Promise<{
+    server: Server;
+    url: string;
+}>;
+export declare function serve(router: Router, options?: ServeOptions): Server;