weifuwu 0.23.4 → 0.24.1

package/dist/kb/types.d.ts

@@ -41,6 +41,14 @@ export interface KBListEntry {
     title: string;
     chunks: number;
 }
+export interface KBInjected {
+    search(query: string, searchOptions?: KBSearchOptions): Promise<KBSearchResult[]>;
+}
+declare module '../types.ts' {
+    interface Context {
+        kb?: KBInjected;
+    }
+}
 export interface KBModule {
     /**
      * Ingest a document: chunk → embed → store.

package/dist/logdb/types.d.ts

@@ -1,5 +1,6 @@
 import type { PostgresClient } from '../postgres/types.ts';
 import type { Router } from '../router.ts';
+import type { Closeable } from '../types.ts';
 export interface LogdbOptions {
     pg: PostgresClient;
     table?: string;
@@ -18,7 +19,7 @@ export interface LogEntryInput {
     message: string;
     metadata?: Record<string, unknown>;
 }
-export interface LogdbModule extends Router {
+export interface LogdbModule extends Router, Closeable {
     log(input: LogEntryInput): Promise<LogEntry>;
     migrate(): Promise<void>;
     clean(retentionMonths: number): Promise<number>;

package/dist/mailer.d.ts

@@ -1,4 +1,5 @@
 import type { Transporter } from 'nodemailer';
+import type { Closeable } from './types.ts';
 /** Options for sending an email. */
 export interface MailOptions {
     /** Recipient address(es). */
@@ -26,7 +27,7 @@ export interface MailerOptions {
     send?: (opts: MailOptions) => Promise<void>;
 }
 /** Mailer instance returned by {@link mailer}. */
-export interface Mailer {
+export interface Mailer extends Closeable {
     /** Send an email. */
     send: (opts: MailOptions) => Promise<void>;
     /** Close the nodemailer transport. */

package/dist/messager/types.d.ts

@@ -2,6 +2,7 @@ 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';
+import type { Closeable } from '../types.ts';
 export interface MessagerOptions {
     pg: PostgresClient;
     agents?: AgentModule;
@@ -37,7 +38,7 @@ export interface Message {
     mime_type: string | null;
     created_at: string;
 }
-export interface MessagerModule extends Router {
+export interface MessagerModule extends Router, Closeable {
     migrate: () => Promise<void>;
     wsHandler: () => any;
     send: (channelId: number, content: string, opts?: {

package/dist/opencode/types.d.ts

@@ -1,5 +1,6 @@
 import type { Router } from '../router.ts';
 import type { PostgresClient } from '../postgres/types.ts';
+import type { Closeable } from '../types.ts';
 export interface Session {
     id: string;
     tenant_id: string | null;
@@ -74,7 +75,7 @@ export interface OpencodeOptions {
     skills?: SkillDef[];
     permissions?: OpencodePermissions;
 }
-export interface OpencodeModule extends Router {
+export interface OpencodeModule extends Router, Closeable {
     migrate: () => Promise<void>;
     wsHandler: () => any;
     close: () => Promise<void>;

package/dist/permissions.d.ts

@@ -39,12 +39,12 @@ export interface PermissionsModule extends Middleware {
      * Middleware that rejects the request if the user does not have any of the specified roles.
      * Must be placed after `permissions()` middleware (which injects ctx.permissions.roles).
      */
-    requireRole(...roles: string[]): Middleware;
+    requireRole(...roles: string[]): Middleware<Context, Context>;
     /**
      * Middleware that rejects the request if the user does not have all specified permissions.
      * Must be placed after `permissions()` middleware (which injects ctx.permissions.permissions).
      */
-    requirePermission(...permissions: string[]): Middleware;
+    requirePermission(...permissions: string[]): Middleware<Context, Context>;
     /** Create the underlying tables. Safe to call multiple times. */
     migrate(): Promise<void>;
 }

package/dist/postgres/module.d.ts

@@ -1,7 +1,8 @@
 import type { PostgresClient } from './types.ts';
 import type { Sql } from '../vendor.ts';
 import type { ColumnBuilder, BoundTable, Table } from './schema/index.ts';
-export declare class PgModule {
+import type { Closeable } from '../types.ts';
+export declare class PgModule implements Closeable {
     protected sql: Sql<{}>;
     protected pg: PostgresClient;
     constructor(pg: PostgresClient);

package/dist/postgres/types.d.ts

@@ -1,5 +1,5 @@
 import type { Sql } from '../vendor.ts';
-import type { Context, Middleware } from '../types.ts';
+import type { Context, Middleware, Closeable } from '../types.ts';
 import type { ColumnBuilder, BoundTable, Table } from './schema/index.ts';
 declare module '../types.ts' {
     interface Context {
@@ -22,7 +22,7 @@ export interface PostgresOptions {
     /** Called after every query completes. Receives query text, duration in ms, and row count. */
     onQuery?: (query: string, durationMs: number, rowCount: number) => void;
 }
-export interface PostgresClient extends Middleware<Context, Context & PostgresInjected> {
+export interface PostgresClient extends Middleware<Context, Context & PostgresInjected>, Closeable {
     sql: Sql<{}>;
     /** Creates the migration tracking table (_weifuwu_migrations). Called once at startup. */
     migrate: () => Promise<void>;

package/dist/queue/types.d.ts

@@ -1,5 +1,5 @@
 import type { Redis } from '../vendor.ts';
-import type { Context, Middleware } from '../types.ts';
+import type { Context, Middleware, Closeable } from '../types.ts';
 declare module '../types.ts' {
     interface Context {
         queue: Queue;
@@ -32,7 +32,7 @@ export interface QueueJobWithError<T = unknown> extends QueueJob<T> {
     error: string;
     failedAt: number;
 }
-export interface Queue extends Middleware<Context, Context & QueueInjected> {
+export interface Queue extends Middleware<Context, Context & QueueInjected>, Closeable {
     /** Register a cron job. Uses queue's backend (memory/pg/redis) for execution. */
     cron(pattern: string, handler: () => void | Promise<void>): {
         stop: () => void;

package/dist/rate-limit.d.ts

@@ -34,6 +34,7 @@ export interface RateLimitOptions {
  * app.use(rateLimit({ store: 'redis', redis: new Redis(), max: 100 }))
  * ```
  */
-export declare function rateLimit(options?: RateLimitOptions): Middleware & {
-    stop: () => void;
+export declare function rateLimit(options?: RateLimitOptions): Middleware<Context, Context> & {
+    close: () => void;
+    stop?: () => void;
 };

package/dist/react.js

@@ -629,9 +629,10 @@ function useFlashMessage() {
 // use-agent-stream.ts
 import { useState as useState6, useCallback as useCallback5, useRef as useRef4 } from "react";
 function useAgentStream(opts) {
-  const { wsPath, channelId, onStreamEnd, onError } = opts;
+  const { wsPath, onStreamEnd, onError } = opts;
   const [streams, setStreams] = useState6({});
   const activeRef = useRef4(/* @__PURE__ */ new Set());
+  const streamsRef = useRef4({});
   const getAgentText = useCallback5(
     (agentId) => streams[agentId] || "",
     [streams]
@@ -652,20 +653,19 @@ function useAgentStream(opts) {
           case "agent_stream": {
             activeRef.current.add(agentId);
             const token = msg.data?.token || "";
-            setStreams((prev) => {
-              const current = prev[agentId] || "";
-              return { ...prev, [agentId]: current + token };
-            });
+            streamsRef.current[agentId] = (streamsRef.current[agentId] || "") + token;
+            setStreams({ ...streamsRef.current });
             break;
           }
           case "agent_stream_end": {
             activeRef.current.delete(agentId);
-            const fullText = streams[agentId] || "";
+            const fullText = streamsRef.current[agentId] || "";
             onStreamEnd?.(agentId, fullText);
             break;
           }
           case "agent_error": {
             activeRef.current.delete(agentId);
+            delete streamsRef.current[agentId];
             onError?.(agentId, msg.data?.error || "Unknown error");
             break;
           }

package/dist/redis/types.d.ts

@@ -1,5 +1,5 @@
 import type { Redis, RedisOptions as IORedisOptions } from '../vendor.ts';
-import type { Context, Middleware } from '../types.ts';
+import type { Context, Middleware, Closeable } from '../types.ts';
 declare module '../types.ts' {
     interface Context {
         redis: Redis;
@@ -12,7 +12,7 @@ export type RedisOptions = IORedisOptions & {
 export interface RedisInjected {
     redis: Redis;
 }
-export interface RedisClient extends Middleware<Context, Context & RedisInjected> {
+export interface RedisClient extends Middleware<Context, Context & RedisInjected>, Closeable {
     redis: Redis;
     close: () => Promise<void>;
 }

package/dist/request-id.d.ts

@@ -1,4 +1,9 @@
 import type { Context, Middleware } from './types.ts';
+declare module './types.ts' {
+    interface Context {
+        requestId: string;
+    }
+}
 /** Options for {@link requestId}. */
 export interface RequestIdOptions {
     /** Header name for request ID (default: `'X-Request-ID'`). */
@@ -9,18 +14,22 @@ export interface RequestIdOptions {
 /**
  * Request ID middleware.
  *
- * Reads an incoming `X-Request-ID` header (or custom header name) from the
- * request. If absent, generates a new UUID. Sets the response header and
- * injects `ctx.requestId`.
+ * @deprecated Use `trace()` from 'weifuwu' instead — it injects `ctx.trace.requestId`
+ * along with `traceId` and `elapsed()` in a single middleware.
  *
  * ```ts
- * import { requestId } from 'weifuwu'
+ * // Old:
  * app.use(requestId())
+ * ctx.requestId
  *
- * app.get('/', (req, ctx) => {
- *   console.log('request ID:', ctx.requestId)
- * })
+ * // New:
+ * app.use(trace())
+ * ctx.trace.requestId
  * ```
+ *
+ * Reads an incoming `X-Request-ID` header (or custom header name) from the
+ * request. If absent, generates a new UUID. Sets the response header and
+ * injects `ctx.requestId`.
  */
 export declare function requestId(options?: RequestIdOptions): Middleware<Context, Context & {
     requestId: string;

package/dist/router.d.ts

@@ -25,6 +25,9 @@ export declare class Router<T extends Context = Context> {
     use<Out extends Context>(mw: Middleware<Context, Out>): Router<T & Out>;
     use(path: string, mw: Middleware<T, T>): Router<T>;
     use(path: string, router: Router<any>): Router<T>;
+    use(mod: Router & {
+        middleware: () => Middleware;
+    }): Router<T>;
     get(path: string, ...args: [...Middleware<T, T>[], Handler<T> | Router<any>]): Router<T>;
     post(path: string, ...args: [...Middleware<T, T>[], Handler<T> | Router<any>]): Router<T>;
     put(path: string, ...args: [...Middleware<T, T>[], Handler<T> | Router<any>]): Router<T>;

package/dist/seo.d.ts

@@ -1,4 +1,4 @@
-import type { Middleware } from './types.ts';
+import type { Middleware, Context } from './types.ts';
 import { Router } from './router.ts';
 /** A rule in `robots.txt`. */
 export interface RobotsRule {
@@ -54,7 +54,7 @@ export interface SeoOptions {
  * }))
  * ```
  */
-export declare function seoMiddleware(options?: SeoOptions): Middleware;
+export declare function seoMiddleware(options?: SeoOptions): Middleware<Context, Context>;
 /**
  * SEO module — serves `robots.txt` and `sitemap.xml`.
  *

package/dist/serve.d.ts

@@ -29,7 +29,7 @@ export declare function createRequest(req: IncomingMessage, body: Buffer): [Requ
 export declare function sendResponse(res: ServerResponse, response: Response, opts?: {
     traceId?: string | null;
 }): Promise<void>;
-export declare function createTestServer(handler: Handler): Promise<{
+export declare function createTestServer(handler: Handler, options?: ServeOptions): Promise<{
     server: Server;
     url: string;
 }>;

package/dist/session.d.ts

@@ -1,5 +1,6 @@
-import type { Middleware } from './types.ts';
+import type { Context, Middleware } from './types.ts';
 import type { Redis } from './vendor.ts';
+import type { Closeable } from './types.ts';
 declare module './types.ts' {
     interface Context {
         session: Session;
@@ -27,10 +28,12 @@ export interface Session extends SessionData {
     [kStore]: SessionStore;
     [kTtl]: number;
 }
-export interface SessionStore {
+export interface SessionStore extends Closeable {
     get(sid: string): Promise<Record<string, unknown> | null>;
     set(sid: string, data: Record<string, unknown>, ttl: number): Promise<void>;
     destroy(sid: string): Promise<void>;
+    /** Release resources. Default no-op. */
+    close(): Promise<void>;
 }
 export interface SessionOptions {
     /** Session store. 'memory' (default) or 'redis'. */
@@ -74,7 +77,7 @@ export declare class MemoryStore implements SessionStore {
     set(sid: string, data: Record<string, unknown>, ttl: number): Promise<void>;
     destroy(sid: string): Promise<void>;
     private cleanup;
-    close(): void;
+    close(): Promise<void>;
     /** Testing only: return approximate count. */
     get size(): number;
 }
@@ -86,9 +89,10 @@ export declare class RedisStore implements SessionStore {
     get(sid: string): Promise<Record<string, unknown> | null>;
     set(sid: string, data: Record<string, unknown>, ttl: number): Promise<void>;
     destroy(sid: string): Promise<void>;
+    close(): Promise<void>;
 }
-export declare function session(options?: SessionOptions): Middleware & {
-    close: () => void;
+export declare function session(options?: SessionOptions): Middleware<Context, Context & SessionInjected> & {
+    close: () => Promise<void>;
     store: SessionStore;
 };
 export {};

package/dist/tailwind.d.ts

@@ -1,5 +1,14 @@
 import { Router } from './router.ts';
 import type { Middleware } from './types.ts';
+export interface TailwindInjected {
+    css: string;
+    url: string;
+}
+declare module './types.ts' {
+    interface Context {
+        tailwind?: TailwindInjected;
+    }
+}
 export declare function addTailwindSource(dir: string): void;
 export declare function tailwindContext(dir: string): Middleware;
 export declare function tailwindRouter(dir: string): Router;

package/dist/tenant/types.d.ts

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

package/dist/theme.d.ts

@@ -1,8 +1,31 @@
-import type { Middleware } from './types.ts';
+import type { Context, Middleware } from './types.ts';
+import { Router } from './router.ts';
+declare module './types.ts' {
+    interface Context {
+        theme: ThemeInjected;
+    }
+}
+export interface ThemeInjected {
+    value: string;
+    set: (value: string, loc?: string) => Response;
+}
 export interface ThemeOptions {
     /** Default theme value (default: 'system'). */
     default?: string;
     /** Cookie name (default: 'theme'). Set to empty string to disable cookie. */
     cookie?: string;
 }
-export declare function theme(options?: ThemeOptions): Middleware;
+/**
+ * Theme module. Returns a Router with an attached `.middleware()` method.
+ *
+ * ```ts
+ * const t = theme()
+ * app.use(t.middleware())  // → ctx.theme = { value, set }
+ * app.use('/', t)          // → GET /__theme/dark (switch route)
+ * ```
+ */
+export interface ThemeModule extends Router {
+    /** Middleware that injects `ctx.theme = { value, set }`. */
+    middleware: () => Middleware<Context, Context & ThemeInjected>;
+}
+export declare function theme(options?: ThemeOptions): ThemeModule;

package/dist/trace.d.ts

@@ -1,3 +1,19 @@
+import type { Context, Middleware } from './types.ts';
+declare module './types.ts' {
+    interface Context {
+        trace: TraceInjected;
+    }
+}
+export interface TraceInjected {
+    /** Unique request identifier (from X-Request-ID header or auto-generated). */
+    requestId: string;
+    /** Unique trace identifier for the request. */
+    traceId: string;
+    /** Milliseconds elapsed since the trace started. */
+    elapsed: () => number;
+    /** Timestamp (ms) when the trace started. */
+    startTime: number;
+}
 export interface TraceContext {
     /** Unique identifier for the current request trace. */
     traceId: string;
@@ -49,3 +65,31 @@ export declare function runWithTrace<T>(incomingTraceId: string | null, fn: () =
  * ```
  */
 export declare function traceElapsed(): number;
+/** Options for {@link trace}. */
+export interface TraceOptions {
+    /** Header name for request ID (default: `'X-Request-ID'`). */
+    header?: string;
+    /** Custom ID generator (default: `crypto.randomUUID`). */
+    generator?: () => string;
+}
+/**
+ * Request tracing middleware.
+ *
+ * Injects `ctx.trace = { requestId, traceId, elapsed, startTime }`.
+ * Reads/writes `X-Request-ID` header. Combines the functionality of `requestId()`
+ * with the per-request tracing from `AsyncLocalStorage`.
+ *
+ * ```ts
+ * import { trace } from 'weifuwu'
+ * app.use(trace())
+ *
+ * app.get('/', (req, ctx) => {
+ *   console.log(ctx.trace.requestId)  // 550e8400-e29b-...
+ *   console.log(ctx.trace.traceId)    // same as currentTraceId()
+ *   console.log(ctx.trace.elapsed())  // ms since request start
+ * })
+ * ```
+ */
+export declare function trace(options?: TraceOptions): Middleware<Context, Context & {
+    trace: TraceInjected;
+}>;

package/dist/types.d.ts

@@ -1,24 +1,7 @@
 export interface Context {
     params: Record<string, string>;
     query: Record<string, string>;
-    user?: unknown;
-    parsed?: Record<string, unknown>;
     mountPath?: string;
-    theme?: {
-        value: string;
-        set?: (value: string, loc?: string) => Response;
-    };
-    flash?: {
-        value: unknown;
-        set: (data: unknown, location?: string) => Response;
-    };
-    i18n?: {
-        locale: string;
-        messages?: Record<string, unknown>;
-        t: (key: string, params?: Record<string, string>, fallback?: string) => string;
-        set?: (value: string, loc?: string) => Response;
-    };
-    env?: Record<string, string>;
     layoutStack?: {
         path: string;
         component: any;
@@ -28,3 +11,11 @@ export interface Context {
 export type Handler<T extends Context = Context> = (req: Request, ctx: T) => Response | Promise<Response>;
 export type Middleware<In extends Context = Context, Out extends In = In> = (req: Request, ctx: In, next: Handler<Out>) => Response | Promise<Response>;
 export type ErrorHandler<T extends Context = Context> = (error: Error, req: Request, ctx: T) => Response | Promise<Response>;
+/**
+ * Interface for resources that require explicit cleanup (connections, pools, timers).
+ * All stateful modules implement this.
+ */
+export interface Closeable {
+    /** Release all resources. Call once when shutting down. */
+    close(): Promise<void>;
+}

package/dist/upload.d.ts

@@ -1,4 +1,9 @@
-import type { Middleware } from './types.ts';
+import type { Context, Middleware } from './types.ts';
+declare module './types.ts' {
+    interface Context {
+        parsed: Record<string, unknown>;
+    }
+}
 /** A parsed file from a multipart upload. */
 export interface UploadedFile {
     /** Original filename from the client. */
@@ -41,4 +46,6 @@ export interface UploadOptions {
  * })
  * ```
  */
-export declare function upload(options?: UploadOptions): Middleware;
+export declare function upload(options?: UploadOptions): Middleware<Context, Context & {
+    parsed: Record<string, unknown>;
+}>;

package/dist/user/client.d.ts

@@ -1,17 +1,25 @@
 import type { UserOptions, UserModule } from './types.ts';
 /**
  * User authentication module — local register/login, JWT verification, OAuth2 server, social login.
+ * Supports DB-less auth via tokens/verify/proxy options.
  *
  * ```ts
+ * // Full auth with DB
  * import { user, postgres } from 'weifuwu'
- *
  * const pg = postgres({ connection: DATABASE_URL })
  * const auth = user({ pg, jwtSecret: process.env.JWT_SECRET })
  *
  * await auth.migrate()
+ * app.use(auth.middleware())   // inject ctx.user
+ * app.use('/', auth)           // /register, /login
+ *
+ * // DB-less token auth
+ * const auth = user({ tokens: ['sk-123', 'sk-456'] })
+ * app.use(auth.middleware())   // injects ctx.user for valid tokens
  *
- * app.use(auth.middleware())   // inject `ctx.user` on every request
- * app.use('/', auth)           // mount auth routes: /register, /login
+ * // DB-less custom verify
+ * const auth = user({ verify: async (token) => validateToken(token) })
+ * app.use(auth.middleware())
  * ```
  */
 export declare function user(options: UserOptions): UserModule;

package/dist/user/types.d.ts

@@ -1,4 +1,4 @@
-import type { Middleware, Context } from '../types.ts';
+import type { Middleware, Context, Closeable } from '../types.ts';
 import type { Router } from '../router.ts';
 import type { PostgresClient } from '../postgres/types.ts';
 /** A user record from the database. */
@@ -58,14 +58,29 @@ export interface OAuthProviderConfig {
 }
 /** Options for {@link user}. */
 export interface UserOptions {
-    /** PostgreSQL client for user storage. */
-    pg: PostgresClient;
-    /** Secret key for JWT signing. */
-    jwtSecret: string;
+    /** PostgreSQL client for user storage. Omit for DB-less token/verify/proxy auth. */
+    pg?: PostgresClient;
+    /** Secret key for JWT signing. Required for JWT auth and login/register routes. */
+    jwtSecret?: string;
     /** Custom table name for users (default: `'users'`). */
     table?: string;
     /** JWT expiration time (default: `'7d'`). */
     expiresIn?: string | number;
+    /** Static token(s) for simple bearer auth. No DB or JWT needed. */
+    tokens?: string[];
+    /** Custom verify function. Receives the token and request, returns user data or null. */
+    verify?: (token: string, req: Request) => unknown | Promise<unknown>;
+    /** Proxy auth — forward request to an external auth service for validation. */
+    proxy?: string | URL;
+    /** Custom header name for token extraction (default: `'Authorization'`). */
+    header?: string;
+    /**
+     * Function to load user data from a user ID stored in the session.
+     * Called when `ctx.session.userId` is present. Only used when `pg` is not provided.
+     * Return a falsy value to reject (e.g. if the user was deleted).
+     * If not provided and no pg, `ctx.user` is set to `{ id: userId }`.
+     */
+    resolveUser?: (userId: unknown) => unknown | Promise<unknown>;
     /** Enable OAuth2 server mode (authorization code flow). */
     oauth2?: OAuth2ServerOptions;
     /**
@@ -92,7 +107,7 @@ export interface UserInjected {
  * app.use('/', auth)           // mounts routes: /register, /login
  * ```
  */
-export interface UserModule extends Router {
+export interface UserModule extends Router, Closeable {
     /**
      * Strict auth middleware. Reads JWT from `Authorization: Bearer` header.
      * Returns 401 if no valid token is found.

package/dist/validate.d.ts

@@ -1,5 +1,10 @@
 import type { ZodSchema } from 'zod';
 import type { Middleware } from './types.ts';
+declare module './types.ts' {
+    interface Context {
+        parsed: Record<string, unknown>;
+    }
+}
 export interface ValidationSchemas {
     body?: ZodSchema;
     query?: ZodSchema;

package/package.json

@@ -1,6 +1,7 @@
 {
   "name": "weifuwu",
-  "version": "0.23.4",
+  "type": "module",
+  "version": "0.24.1",
   "description": "Web-standard HTTP framework for Node.js — (req, ctx) => Response",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -24,7 +25,9 @@
     "start": "cd cli/template && node index.ts",
     "build": "esbuild index.ts --bundle --format=esm --platform=node --outfile=dist/index.js --packages=external --define:__WFW_BUNDLED__=true && esbuild cli.ts --bundle --format=esm --platform=node --outfile=dist/cli.js --packages=external && esbuild react.ts --bundle --format=esm --outfile=dist/react.js --external:react --external:react-dom",
     "prepublishOnly": "npm run build && tsc --emitDeclarationOnly --outdir dist",
+    "typecheck": "tsc --noEmit",
     "test": "node --test 'test/**/*.test.ts'",
+    "test:coverage": "node --experimental-test-coverage --test 'test/**/*.test.ts'",
     "test:unit": "bash scripts/test-unit.sh",
     "test:ci": "node --test 'test/**/*.test.ts'"
   },
@@ -48,15 +51,12 @@
     "yaml": "^2.9.0",
     "zod": "^4.4.3"
   },
-  "type": "module",
-  "license": "MIT",
   "devDependencies": {
-    "@types/jsonwebtoken": "^9.0.10",
-    "@types/node": "^24.0.0",
-    "@types/nodemailer": "^8.0.0",
-    "@types/react": "^19",
-    "@types/react-dom": "^19",
+    "@types/jsonwebtoken": "^9.0.9",
+    "@types/nodemailer": "^6.4.17",
     "@types/ws": "^8.18.1",
-    "typescript": "^6.0.3"
+    "happy-dom": "^20.10.3",
+    "postcss": "^8.5.3",
+    "tailwindcss": "^4.0.0"
   }
 }