weifuwu 0.27.28 → 0.28.2

package/dist/ai/provider.d.ts

@@ -1,45 +0,0 @@
-import type { Context, Middleware } from '../types.ts';
-import { generateText as aiGenerateText, streamText as aiStreamText, type LanguageModel, type EmbeddingModel } from 'ai';
-declare module '../types.ts' {
-    interface Context {
-        ai: AIProvider;
-    }
-}
-export interface AIProviderInjected {
-    ai: AIProvider;
-}
-export interface AIProviderOptions {
-    /** API base URL (default: OPENAI_BASE_URL env or http://localhost:11434/v1). */
-    baseURL?: string;
-    /** API key (default: OPENAI_API_KEY env or 'ollama'). */
-    apiKey?: string;
-    /** Chat model name (default: OPENAI_MODEL env or 'qwen3:0.6b'). */
-    model?: string;
-    /** Embedding model name (default: OPENAI_EMBEDDING_MODEL env or 'qwen3-embedding:0.6b'). */
-    embeddingModel?: string;
-    /** Vector dimension (default: EMBEDDING_DIMENSION env or 1024). */
-    embeddingDimension?: number;
-}
-export interface AIProvider {
-    /** Get the language model. Caches by default; pass a name to override. */
-    model(name?: string): LanguageModel;
-    /** Get the embedding model. Caches by default; pass a name to override. */
-    embeddingModel(name?: string): EmbeddingModel;
-    /** Embed a single text string into a vector. */
-    embed(text: string): Promise<number[]>;
-    /** Embed multiple text strings in batch. */
-    embedMany(texts: string[]): Promise<number[][]>;
-    /** The configured vector dimension. */
-    readonly dimension: number;
-    /**
-     * Generate text using the configured model.
-     * All options are passed through to the AI SDK's `generateText`, with `model` auto-injected.
-     */
-    generateText(params: Omit<Parameters<typeof aiGenerateText>[0], 'model'>): ReturnType<typeof aiGenerateText>;
-    /**
-     * Stream text using the configured model.
-     * All options are passed through to the AI SDK's `streamText`, with `model` auto-injected.
-     */
-    streamText(params: Omit<Parameters<typeof aiStreamText>[0], 'model'>): ReturnType<typeof aiStreamText>;
-}
-export declare function aiProvider(options?: AIProviderOptions): Middleware<Context, Context & AIProviderInjected> & AIProvider;

package/dist/ai/stream.d.ts

@@ -1,13 +0,0 @@
-import type { Context } from '../types.ts';
-import { Router } from '../core/router.ts';
-import type { AIProvider } from './provider.ts';
-export type AIHandler = (req: Request, ctx: Context) => Record<string, unknown> | Promise<Record<string, unknown>>;
-export declare const _ai: Record<string, any>;
-/**
- * Create a streaming AI endpoint.
- *
- * @param handler - Returns options for `streamText` or `streamObject` (if `schema` is present).
- * @param provider - Optional AI provider. If provided and the handler does not return a `model`,
- *                   `provider.model()` is used as the default.
- */
-export declare function aiStream(handler: AIHandler, provider?: AIProvider): Promise<Router>;

package/dist/cli.d.ts

@@ -1,2 +0,0 @@
-#!/usr/bin/env node
-export {};

package/dist/cli.js

@@ -1,126 +0,0 @@
-#!/usr/bin/env node
-
-// cli.ts
-import { mkdir, writeFile } from "node:fs/promises";
-import { existsSync } from "node:fs";
-import { execSync } from "node:child_process";
-import { join, dirname, resolve } from "node:path";
-import { fileURLToPath } from "node:url";
-import { parseArgs } from "node:util";
-var __filename = fileURLToPath(import.meta.url);
-var __dirname = dirname(__filename);
-var pkgRoot = existsSync(join(__dirname, "package.json")) ? __dirname : resolve(__dirname, "..");
-async function readPkg() {
-  return JSON.parse(
-    await import("node:fs/promises").then(
-      (fs) => fs.readFile(join(pkgRoot, "package.json"), "utf-8")
-    )
-  );
-}
-async function cmdVersion() {
-  const pkg = await readPkg();
-  console.log(pkg.version);
-}
-async function cmdInit(name, opts) {
-  const targetDir = resolve(process.cwd(), name);
-  if (existsSync(targetDir)) {
-    console.error(`Directory ${name} already exists.`);
-    process.exit(1);
-  }
-  const pkg = await readPkg();
-  const typesNodeVersion = pkg.devDependencies?.["@types/node"] || "^22";
-  await generateMinimal(targetDir, name, pkg.version, typesNodeVersion, opts.skipInstall);
-}
-async function generateMinimal(targetDir, name, version, typesNodeVersion, skipInstall) {
-  await mkdir(targetDir, { recursive: true });
-  await writeFile(
-    join(targetDir, "app.ts"),
-    [
-      `import { Router } from 'weifuwu'`,
-      ``,
-      `export const app = new Router()`,
-      ``,
-      `app.get('/', () => new Response('Hello from ${name}!'))`,
-      `app.get('/api/ping', () => Response.json({ pong: true, time: new Date().toISOString() }))`,
-      ``
-    ].join("\n")
-  );
-  await writeFile(
-    join(targetDir, "index.ts"),
-    [
-      `import { loadEnv, serve } from 'weifuwu'`,
-      `import { app } from './app.ts'`,
-      ``,
-      `loadEnv()`,
-      `const port = Number(process.env.PORT) || 3000`,
-      `serve(app.handler(), { port })`,
-      ``
-    ].join("\n")
-  );
-  await writePackageJson(targetDir, name, version, typesNodeVersion, {});
-  await writeCommonFiles(targetDir);
-  await finishInit(targetDir, skipInstall);
-}
-async function writePackageJson(targetDir, name, version, typesNodeVersion, _extra) {
-  const pkg = {
-    name,
-    type: "module",
-    scripts: {
-      dev: "node --watch index.ts",
-      start: "node index.ts"
-    },
-    dependencies: {
-      weifuwu: "^" + version
-    },
-    devDependencies: {
-      "@types/node": typesNodeVersion
-    }
-  };
-  await writeFile(join(targetDir, "package.json"), JSON.stringify(pkg, null, 2) + "\n");
-}
-async function writeCommonFiles(targetDir) {
-  await writeFile(join(targetDir, ".gitignore"), "node_modules\n.env\n.weifuwu\n");
-  await writeFile(join(targetDir, ".env"), "PORT=3000\n");
-}
-async function finishInit(targetDir, skipInstall) {
-  if (!skipInstall) {
-    console.log("\nInstalling dependencies...");
-    execSync("npm install", { cwd: targetDir, stdio: "inherit" });
-  }
-  console.log(`
-\u2705 Created ${targetDir.split("/").pop()}/`);
-  console.log(`   cd ${targetDir.split("/").pop()}`);
-  if (skipInstall) console.log(`   npm install`);
-  console.log(`   npm run dev`);
-}
-var cmd = process.argv[2];
-var HELP = `
-weifuwu \u2014 Web-standard HTTP microframework for Node.js
-
-Usage:
-  npx weifuwu init <name>               Create a new project
-  npx weifuwu init <name> --skip-install  Skip npm install
-  npx weifuwu version                   Print version
-`;
-if (cmd === "version" || cmd === "-v" || cmd === "--version") {
-  cmdVersion().catch(console.error);
-} else if (cmd === "init") {
-  const { values, positionals } = parseArgs({
-    args: process.argv.slice(3),
-    options: {
-      "skip-install": { type: "boolean" }
-    },
-    strict: false,
-    allowPositionals: true
-  });
-  const name = positionals[0];
-  if (!name) {
-    console.error("Usage: npx weifuwu init <name> [--skip-install]");
-    process.exit(1);
-  }
-  cmdInit(name, { skipInstall: !!values["skip-install"] }).catch(
-    console.error
-  );
-} else {
-  console.log(HELP);
-}

package/dist/core/cookie.d.ts

@@ -1,36 +0,0 @@
-/** 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

@@ -1,69 +0,0 @@
-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/logger.d.ts

@@ -1,16 +0,0 @@
-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

@@ -1,88 +0,0 @@
-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;
-    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<Context>): Router<T>;
-    use(mod: Router & {
-        middleware: () => Middleware;
-    }): 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 mergeMws;
-    private _collect;
-    private _collectWs;
-    private splitPath;
-    private matchTrie;
-    private matchWsTrie;
-    private handleError;
-    private handle;
-    private runChain;
-}
-export {};

package/dist/core/serve.d.ts

@@ -1,38 +0,0 @@
-import { type IncomingMessage, type ServerResponse } from 'node:http';
-import type { Duplex } from 'node:stream';
-import { type Handler } from '../types.ts';
-export interface ServeOptions {
-    port?: number;
-    hostname?: string;
-    signal?: AbortSignal;
-    websocket?: (req: IncomingMessage, socket: Duplex, head: Buffer) => void;
-    /** 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(handler: Handler, options?: ServeOptions): Promise<{
-    server: Server;
-    url: string;
-}>;
-export declare function serve(handler: Handler, options?: ServeOptions): Server;

package/dist/core/sse.d.ts

@@ -1,47 +0,0 @@
-/**
- * Format an SSE message string with a named event type.
- *
- * ```ts
- * formatSSE('ping', { ts: Date.now() })
- * // "event: ping\ndata: {"ts":...}\n\n"
- * ```
- */
-export declare function formatSSE(event: string, data: unknown): string;
-/**
- * Format an SSE message string with only a data line (no event type).
- *
- * ```ts
- * formatSSEData({ message: 'hello' })
- * // "data: {"message":"hello"}\n\n"
- * ```
- */
-export declare function formatSSEData(data: unknown): string;
-/** An SSE event to be sent via {@link createSSEStream}. */
-export interface SSEEvent {
-    /** Event type (maps to `event:` field). */
-    event: string;
-    /** Event payload (serialized as JSON in `data:` field). */
-    data: unknown;
-}
-/**
- * Create a Server-Sent Events (SSE) `Response` from an async iterable.
- *
- * Each item in the iterable is serialized as an SSE message:
- * - If the item has a `.type` property → `event: {type}` + `data: {item}`
- * - Otherwise → `data: {item}`
- *
- * Errors are sent as `event: error` messages. `AbortError` is silently ignored.
- *
- * ```ts
- * app.get('/events', () => {
- *   async function* generate() {
- *     yield { type: 'ping', data: { ts: Date.now() } }
- *   }
- *   return createSSEStream(generate())
- * })
- * ```
- */
-export declare function createSSEStream(iterable: AsyncIterable<any>, opts?: {
-    headers?: Record<string, string>;
-    status?: number;
-}): Response;

package/dist/core/trace.d.ts

@@ -1,95 +0,0 @@
-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;
-    /** Timestamp (ms since epoch) when the trace started. */
-    startTime: number;
-}
-/**
- * Get the current request's trace ID.
- * Returns `undefined` when called outside a request context (e.g. at startup).
- *
- * ```ts
- * const traceId = currentTraceId()
- * log.info({ traceId }, 'request started')
- * ```
- */
-export declare function currentTraceId(): string | undefined;
-/**
- * Get the full current trace context ({ traceId, startTime }).
- * Returns `undefined` outside a request.
- */
-export declare function currentTrace(): TraceContext | undefined;
-/**
- * Run a function inside a trace context.
- * Used internally by `serve()` for every incoming request.
- * If `incomingTraceId` is provided (e.g. from an `X-Trace-Id` header) it is reused;
- * otherwise a new UUID is generated.
- *
- * ```ts
- * const result = runWithTrace(req.headers.get('x-trace-id'), () => {
- *   return handleRequest(req)
- * })
- * ```
- *
- * @param incomingTraceId - Optional trace ID from upstream. Pass `null` to auto-generate.
- * @param fn - Function to execute within the trace scope.
- * @returns The return value of `fn`.
- */
-export declare function runWithTrace<T>(incomingTraceId: string | null, fn: () => T): T;
-/**
- * Milliseconds elapsed since the current trace started.
- * Returns `0` if called outside a request context.
- *
- * ```ts
- * app.use(async (req, ctx, next) => {
- *   const res = await next(req, ctx)
- *   console.log('handled in', traceElapsed(), 'ms')
- *   return res
- * })
- * ```
- */
-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/graphql.d.ts

@@ -1,16 +0,0 @@
-import { type GraphQLSchema } from 'graphql';
-import type { Context } from './types.ts';
-import { Router } from './core/router.ts';
-export interface GraphQLOptions {
-    schema: string | GraphQLSchema;
-    rootValue?: any;
-    resolvers?: any;
-    context?: (req: Request, ctx: Context) => Record<string, any> | Promise<Record<string, any>>;
-    graphiql?: boolean;
-    /** Max query depth (nesting). Default: 10. Set 0 to disable. */
-    maxDepth?: number;
-    /** Execution timeout in ms. Default: 30_000. */
-    timeout?: number;
-}
-export type GraphQLHandler = (req: Request, ctx: Context) => GraphQLOptions | Promise<GraphQLOptions>;
-export declare function graphql(handler: GraphQLHandler): Router;

package/dist/hub.d.ts

@@ -1,36 +0,0 @@
-import type { Redis, WebSocket, Closeable } from './types.ts';
-/** Options for {@link createHub}. */
-export interface HubOptions {
-    /** Optional Redis client for cross-process pub/sub broadcast. */
-    redis?: Redis;
-    /** Key prefix for Redis channels (default: `'hub:'`). */
-    prefix?: string;
-}
-/**
- * In-memory (and optionally Redis-backed) pub/sub hub for WebSocket rooms.
- *
- * Used internally by the WebSocket handler to implement `ctx.ws.join()` / `ctx.ws.sendRoom()`. */
-export interface Hub extends Closeable {
-    /** Subscribe a WebSocket to a room/group. */
-    join(key: string, ws: WebSocket): void;
-    /** Unsubscribe a WebSocket from all rooms. */
-    leave(ws: WebSocket): void;
-    /** Send a JSON message to all members of a room. */
-    broadcast(key: string, data: unknown): void;
-    /** Close the hub, disconnect Redis subscribers, clear all rooms. */
-    close(): Promise<void>;
-}
-/**
- * Create a pub/sub hub for WebSocket room management.
- *
- * In-memory by default. Pass `redis` to enable cross-process broadcasting.
- *
- * ```ts
- * import { createHub } from 'weifuwu'
- *
- * const hub = createHub()
- * hub.join('room:general', ws)
- * hub.broadcast('room:general', { type: 'chat', text: 'Hello' })
- * ```
- */
-export declare function createHub(opts?: HubOptions): Hub;