yinzerflow 0.6.14 → 0.8.0

package/index.d.ts

@@ -984,24 +984,26 @@ interface Response$1 {
 }
 /**
  Time duration string format
- 
- Format: number followed by unit (s, m, h, d)
- 
+
+ Format: number followed by unit (ms, s, m, h, d)
+
  Units:
+ - ms: milliseconds
  - s: seconds
  - m: minutes
  - h: hours
  - d: days
- 
+
  @example
  ```typescript
- '30s'  // 30 seconds
- '15m'  // 15 minutes
- '2h'   // 2 hours
- '1d'   // 1 day
+ '500ms' // 500 milliseconds
+ '30s'   // 30 seconds
+ '15m'   // 15 minutes
+ '2h'    // 2 hours
+ '1d'    // 1 day
  ```
  */
-export type TimeString = `${number}${"d" | "h" | "m" | "s"}`;
+export type TimeString = `${number}${"d" | "h" | "m" | "ms" | "s"}`;
 export interface InternalCookieOptions {
 	/**
 	 * Expiration date/time for the cookie
@@ -1454,6 +1456,156 @@ export interface Context<T extends HandlerCallbackGenerics = HandlerCallbackGene
  * @see {@link HandlerCallbackGenerics} for custom typing options
  */
 export type HandlerCallback<T extends HandlerCallbackGenerics = HandlerCallbackGenerics> = (ctx: Context<T>, error?: unknown) => Promise<T["response"] | void> | T["response"] | void;
+/**
+ * User-facing WebSocket types for YinzerFlow.
+ *
+ * These types define the public API surface for WebSocket support:
+ * route handlers, the per-connection `ws` object, upgrade requests,
+ * route options, and backpressure configuration.
+ */
+// ============================================
+// WebSocket Connection Object
+// ============================================
+/**
+ * A live WebSocket connection exposed to route handlers.
+ *
+ * @template T - Shape of per-socket data attached during upgrade
+ *
+ * @example
+ * ```typescript
+ * app.ws<{ userId: string }>('/feed', {
+ *   message(ws, data) {
+ *     ws.send(`Echo: ${data}`);
+ *     ws.publish('updates', data as string);
+ *     console.log(ws.data.userId, ws.readyState);
+ *   }
+ * });
+ * ```
+ */
+interface WebSocket$1<T = unknown> {
+	/** Send a text or binary message to this client. */
+	send: (data: Buffer | string) => void;
+	/** Write a pre-encoded WebSocket frame directly (used internally by pub/sub broadcast). */
+	sendRaw: (encodedFrame: Buffer) => void;
+	/** Initiate a graceful close handshake. */
+	close: (code?: number, reason?: string) => void;
+	/** Send a ping frame (payload must be ≤125 bytes per RFC 6455 §5.5). */
+	ping: (data?: Buffer) => void;
+	/** Subscribe this connection to a named channel for pub/sub. */
+	subscribe: (channel: string) => void;
+	/** Unsubscribe this connection from a named channel. */
+	unsubscribe: (channel: string) => void;
+	/** Publish a message to all subscribers of a channel (excluding this connection). Returns recipient count. */
+	publish: (channel: string, data: Buffer | string) => number;
+	/** Check if this connection is subscribed to a channel. */
+	isSubscribed: (channel: string) => boolean;
+	/** Per-socket data attached during the upgrade handler. */
+	readonly data: T;
+	/** Current connection state (use wsReadyState constants for comparison). */
+	readonly readyState: number;
+	/** Remote IP address of the connected client. */
+	readonly remoteAddress: string;
+	/** Number of bytes queued in the socket's write buffer. */
+	readonly bufferedAmount: number;
+}
+// ============================================
+// Upgrade Request
+// ============================================
+/**
+ * Parsed HTTP upgrade request passed to the `upgrade` handler.
+ * Contains everything needed to decide whether to accept the connection
+ * and what per-socket data to attach.
+ */
+export interface WebSocketUpgradeRequest {
+	/** HTTP headers from the upgrade request (lowercased keys). */
+	headers: Record<string, string>;
+	/** URL path of the upgrade request. */
+	path: string;
+	/** Parsed query string parameters. */
+	query: Record<string, string>;
+	/** Route parameters extracted from parameterized paths (e.g., `/ws/:room` → `{ room: 'lobby' }`). */
+	params: Record<string, string>;
+	/** Remote IP address of the client. */
+	remoteAddress: string;
+}
+// ============================================
+// Route Handlers
+// ============================================
+/**
+ * Handler functions for a WebSocket route.
+ *
+ * @template T - Shape of per-socket data returned from `upgrade`
+ *
+ * @example
+ * ```typescript
+ * app.ws<{ username: string }>('/chat', {
+ *   upgrade(req) {
+ *     const user = validateToken(req.headers.authorization);
+ *     return user ? { username: user.name } : false;
+ *   },
+ *   open(ws) {
+ *     ws.subscribe('chat');
+ *   },
+ *   message(ws, data, isBinary) {
+ *     ws.publish('chat', data as string);
+ *   },
+ *   close(ws, code, reason) {
+ *     // cleanup — unsubscribe is automatic
+ *   }
+ * });
+ * ```
+ */
+export interface WebSocketHandlers<T = unknown> {
+	/**
+	 * Called before the handshake completes. Return per-socket data to accept,
+	 * or `false` to reject the connection with a 403 response.
+	 * If omitted, the connection is accepted with `undefined` as data.
+	 */
+	upgrade?: (request: WebSocketUpgradeRequest) => Promise<T | false> | T | false;
+	/** Called when the connection is established and ready. */
+	open?: (ws: WebSocket$1<T>) => void;
+	/** Called when a complete message (text or binary) is received. */
+	message?: (ws: WebSocket$1<T>, data: Buffer | string, isBinary: boolean) => void;
+	/** Called when the connection is closed (after close handshake or on error). */
+	close?: (ws: WebSocket$1<T>, code: number, reason: string) => void;
+	/** Called when a socket error occurs. */
+	error?: (ws: WebSocket$1<T>, error: Error) => void;
+	/** Called when a backpressured socket's write buffer drains. */
+	drain?: (ws: WebSocket$1<T>) => void;
+}
+// ============================================
+// Route Options
+// ============================================
+/**
+ * Per-route WebSocket options that override global websocket configuration.
+ */
+export interface WebSocketRouteOptions {
+	/** Maximum incoming message payload in bytes (default: global `websocket.maxPayloadLength`). */
+	maxPayloadLength?: number;
+	/** Seconds of inactivity before closing the connection (default: global `websocket.idleTimeout`). 0 = no timeout. */
+	idleTimeout?: number;
+	/** Backpressure handling for this route. */
+	backpressure?: WebSocketBackpressureOptions;
+}
+/**
+ * Backpressure configuration for WebSocket connections.
+ */
+export interface WebSocketBackpressureOptions {
+	/**
+	 * Strategy when the client can't keep up with outgoing data:
+	 * - `'buffer'`: Queue messages up to `limit` bytes, then close the connection (safe default)
+	 * - `'drop'`: Silently discard messages (ideal for real-time data like trading quotes)
+	 * @default 'buffer'
+	 */
+	strategy: "buffer" | "drop";
+	/** Maximum buffered bytes before the connection is closed (only applies to 'buffer' strategy). @default 1048576 (1MB) */
+	limit?: number;
+}
+/**
+ * WebSocket message hook handler signature.
+ * Used for `wsBeforeMessage` and `wsAfterMessage` global hooks.
+ */
+export type WebSocketMessageHook = (ws: WebSocket$1, data: Buffer | string, isBinary: boolean) => Promise<void> | void;
 export type InternalGlobalHookOptions = {
 	routesToExclude: Array<string>;
 } & {
@@ -1472,13 +1624,26 @@ export interface InternalHookRegistryImpl {
 		handler: HandlerCallback;
 		options?: InternalGlobalHookOptions;
 	}>;
+	readonly _wsBeforeMessage: Set<{
+		handler: WebSocketMessageHook;
+	}>;
+	readonly _wsAfterMessage: Set<{
+		handler: WebSocketMessageHook;
+	}>;
 	_onError: HandlerCallback;
 	_onNotFound: HandlerCallback;
 	_addBeforeRoutingHooks: (handlers: Array<HandlerCallback>, options?: InternalGlobalHookOptions) => void;
 	_addBeforeHooks: (handlers: Array<HandlerCallback>, options?: InternalGlobalHookOptions) => void;
 	_addAfterHooks: (handlers: Array<HandlerCallback>, options?: InternalGlobalHookOptions) => void;
+	_addWsBeforeMessageHooks: (handlers: Array<WebSocketMessageHook>) => void;
+	_addWsAfterMessageHooks: (handlers: Array<WebSocketMessageHook>) => void;
 	_addOnError: (handler: HandlerCallback) => void;
 	_addOnNotFound: (handler: HandlerCallback) => void;
+	setLogger: (logger: {
+		info: (...args: Array<unknown>) => void;
+		warn: (...args: Array<unknown>) => void;
+		error: (...args: Array<unknown>) => void;
+	}) => void;
 }
 /**
  * Internal route registry implementation for managing route storage and lookup.
@@ -1887,33 +2052,52 @@ export declare const logLevels: {
 	readonly error: "error";
 	readonly warn: "warn";
 	readonly info: "info";
+	readonly debug: "debug";
 };
 /**
  * YinzerFlow Logging Levels
  *
  * String-based logging levels for intuitive configuration:
- * - 'off': No logging at all. Mainly used for network logging internally, but feel free to use it for other purposes.
+ * - 'off': No logging at all
  * - 'error': Only errors
- * - 'warn': Warnings and errors (includes security warnings, slow requests)
+ * - 'warn': Warnings and errors (includes security warnings)
  * - 'info': Info, warnings, and errors (standard application logging)
+ * - 'debug': All messages including verbose connection details
  *
- * Network logging is controlled separately via boolean networkLogging config.
+ * Access logging is controlled separately via `logging.requests` config.
  */
 export type LogLevel = CreateEnum<typeof logLevels>;
 export interface Logger {
 	info: (...args: Array<unknown>) => void;
 	warn: (...args: Array<unknown>) => void;
 	error: (...args: Array<unknown>) => void;
+	debug?: ((...args: Array<unknown>) => void) | undefined;
 }
 export interface LoggerConfig {
-	logLevel?: LogLevel | undefined;
+	level?: LogLevel | undefined;
 	prefix?: string | undefined;
-	logger?: {
-		info: (...args: Array<unknown>) => void;
-		warn: (...args: Array<unknown>) => void;
-		error: (...args: Array<unknown>) => void;
-	} | undefined;
+	logLevel?: LogLevel | undefined;
 }
+/**
+ * Byte size string format
+ *
+ * Format: number followed by unit (b, kb, mb, gb)
+ *
+ * Units:
+ * - b: bytes
+ * - kb: kilobytes (1024 bytes)
+ * - mb: megabytes (1048576 bytes)
+ * - gb: gigabytes (1073741824 bytes)
+ *
+ * @example
+ * ```typescript
+ * '512b'   // 512 bytes
+ * '256kb'  // 256 kilobytes
+ * '1mb'    // 1 megabyte
+ * '2gb'    // 2 gigabytes
+ * ```
+ */
+export type ByteString = `${number}${"b" | "gb" | "kb" | "mb"}`;
 export declare const rateLimitAlgorithm: {
 	readonly slidingWindowCounter: "sliding-window-counter";
 };
@@ -2380,32 +2564,14 @@ export interface InternalServerOptions {
 	 */
 	host: string;
 	/**
-	 * Custom logger instance
+	 * Logging configuration — controls app logger, access logs, and diagnostics.
 	 *
-	 * Use createLogger() to create logger instances with custom configuration
-	 * @default undefined (uses built-in logger with default settings)
-	 *
-	 * @example
-	 * ```typescript
-	 * const logger = createLogger({ prefix: 'APP', logLevel: 'info' });
-	 * new YinzerFlow({ logger });
-	 * ```
-	 */
-	logger?: Logger;
-	/**
-	 * Network request/response logging (nginx-style logs)
-	 * Completely separate from application logs - simple on/off toggle
-	 * @default false
+	 * Three independent channels:
+	 * - **App logger**: Developer logs + framework errors/warnings (gated by `level`)
+	 * - **Access log**: nginx-style request/response lines (gated by `requests` on/off)
+	 * - **Diagnostics**: Framework health monitoring (gated by individual thresholds)
 	 */
-	networkLogs: boolean;
-	/**
-	 * Custom logger for network logs (optional)
-	 * If provided, network logs will be routed to this logger instead of built-in formatting
-	 * Can be the same as the application logger or a different one
-	 * Useful for unified monitoring (e.g., Winston with Datadog transport for both app and network logs)
-	 * @default undefined (uses built-in network logging)
-	 */
-	networkLogger?: Logger;
+	logging: InternalLoggingOptions;
 	/**
 	 * Cross-Origin Resource Sharing configuration
 	 */
@@ -2441,6 +2607,117 @@ export interface InternalServerOptions {
 	 * @default true
 	 */
 	gracefulShutdownTimeout: TimeString | number;
+	/**
+	 * WebSocket configuration — controls max payload, idle timeout, connection limits, and backpressure.
+	 * Only takes effect when `app.ws()` routes are registered (zero overhead otherwise).
+	 */
+	websocket: InternalWebSocketOptions;
+}
+/**
+ * Internal WebSocket Configuration
+ */
+export interface InternalWebSocketOptions {
+	/** Maximum incoming message payload in bytes. @default 16777216 (16MB) */
+	maxPayloadLength: number;
+	/** Seconds of inactivity before closing. 0 = no timeout. @default 120 */
+	idleTimeout: number;
+	/** Maximum concurrent WebSocket connections per IP. @default 50 */
+	maxConnectionsPerIp: number;
+	/** Allowed origins for upgrade requests. Empty = allow all. @default [] */
+	allowedOrigins: Array<string>;
+	/** Backpressure handling when clients can't keep up. */
+	backpressure: {
+		/** 'buffer' (queue up to limit, safe default) or 'drop' (discard, for real-time data). @default 'buffer' */
+		strategy: "buffer" | "drop";
+		/** Max queued bytes before closing connection (buffer strategy only). @default 1048576 (1MB) */
+		limit: number;
+	};
+}
+/**
+ * Internal Logging Configuration
+ * Controls three independent channels: app logger, access logs, and diagnostics.
+ */
+export interface InternalLoggingOptions {
+	/**
+	 * Log level threshold — messages at this severity and above are output.
+	 * From least to most severe: debug → info → warn → error.
+	 * @default 'warn'
+	 */
+	level: LogLevel;
+	/**
+	 * Log line prefix shown in brackets, e.g. [YINZER]
+	 * @default 'YINZER'
+	 */
+	prefix: string;
+	/**
+	 * Enable Pittsburgh personality phrases in log output
+	 * @default true
+	 */
+	personality: boolean;
+	/**
+	 * Enable nginx-style access logs (one line per request/response)
+	 * @default false
+	 */
+	requests: boolean;
+	/**
+	 * Custom logger for application logs (optional)
+	 * If provided, app logs route to this logger instead of built-in formatting
+	 * @default undefined
+	 */
+	logger?: Logger;
+	/**
+	 * Custom logger for access logs (optional)
+	 * If provided, access logs route to this logger instead of built-in formatting
+	 * @default undefined
+	 */
+	accessLogger?: Logger;
+	/**
+	 * Framework diagnostics — health monitoring independent of app log level.
+	 * All thresholds default to false (disabled). Set a threshold to enable.
+	 */
+	diagnostics: InternalDiagnosticsOptions;
+}
+/**
+ * Internal Diagnostics Configuration
+ * Framework health monitoring that fires independently of the app log level.
+ * Even with `level: 'off'`, diagnostics still fire when thresholds are exceeded.
+ */
+export interface InternalDiagnosticsOptions {
+	/**
+	 * Log requests slower than this threshold
+	 * @default false (disabled)
+	 * @example '500ms' or 500 (milliseconds)
+	 */
+	slowRequests: TimeString | number | false;
+	/**
+	 * Log responses larger than this threshold
+	 * @default false (disabled)
+	 * @example '1mb' or 1048576 (bytes)
+	 */
+	largeResponses: ByteString | number | false;
+	/**
+	 * Log requests with bodies larger than this threshold
+	 * @default false (disabled)
+	 * @example '1mb' or 1048576 (bytes)
+	 */
+	largeRequests: ByteString | number | false;
+	/**
+	 * Log periodic memory/heap usage at this interval
+	 * @default false (disabled)
+	 * @example '30s' or 30000 (milliseconds)
+	 */
+	memory: TimeString | number | false;
+	/**
+	 * Log event loop lag exceeding this threshold
+	 * @default false (disabled)
+	 * @example '100ms' or 100 (milliseconds)
+	 */
+	eventLoop: TimeString | number | false;
+	/**
+	 * Log rate limit hits
+	 * @default false (disabled)
+	 */
+	rateLimits: boolean;
 }
 export type HttpMethodHandlers = Record<Lowercase<keyof typeof httpMethod>, InternalSetupMethod>;
 export type RouteGroupMethod = (prefix: string, callback: (group: RouteGroup) => void, options?: InternalRouteRegistryOptions) => RouteGroup;
@@ -2772,12 +3049,33 @@ export interface Setup extends HttpMethodHandlers {
 	 * @see {@link HandlerCallback} for not-found handler function signature
 	 */
 	onNotFound: (handler: HandlerCallback) => void;
+	/**
+	 * Register a WebSocket route.
+	 *
+	 * @template T - Per-socket data shape returned from the upgrade handler
+	 * @param path - URL path for WebSocket connections (e.g., '/ws', '/chat/:room')
+	 * @param handlers - Lifecycle handlers (upgrade, open, message, close, error, drain)
+	 * @param options - Per-route options that override global websocket config
+	 */
+	ws: <T = unknown>(path: string, handlers: WebSocketHandlers<T>, options?: WebSocketRouteOptions) => void;
+	/** Register global hooks that run before each WebSocket message handler. */
+	wsBeforeMessage: (handlers: Array<WebSocketMessageHook>) => void;
+	/** Register global hooks that run after each WebSocket message handler. */
+	wsAfterMessage: (handlers: Array<WebSocketMessageHook>) => void;
 }
 export type InternalSetupMethod = (path: string, handler: HandlerCallback<any>, options?: InternalRouteRegistryOptions) => void;
 export interface InternalSetupImpl extends Setup {
 	readonly _configuration: InternalServerOptions;
 	readonly _routeRegistry: InternalRouteRegistryImpl;
 	readonly _hooks: InternalHookRegistryImpl;
+	/** Per-instance logger. Set by `_configureLogging()` in YinzerFlow. */
+	_log: {
+		info: (...args: Array<unknown>) => void;
+		warn: (...args: Array<unknown>) => void;
+		error: (...args: Array<unknown>) => void;
+		debug: (...args: Array<unknown>) => void;
+		table: (data: unknown, ...additionalArgs: Array<unknown>) => void;
+	};
 }
 declare class HookRegistryImpl implements InternalHookRegistryImpl {
 	readonly _beforeRouting: Set<{
@@ -2792,12 +3090,26 @@ declare class HookRegistryImpl implements InternalHookRegistryImpl {
 		handler: HandlerCallback;
 		options?: InternalGlobalHookOptions;
 	}>;
+	readonly _wsBeforeMessage: Set<{
+		handler: WebSocketMessageHook;
+	}>;
+	readonly _wsAfterMessage: Set<{
+		handler: WebSocketMessageHook;
+	}>;
 	_onError: HandlerCallback;
 	_onNotFound: HandlerCallback;
+	private _logger;
+	setLogger(logger: {
+		info: (...args: Array<unknown>) => void;
+		warn: (...args: Array<unknown>) => void;
+		error: (...args: Array<unknown>) => void;
+	}): void;
 	constructor();
 	_addBeforeRoutingHooks(handlers: Array<HandlerCallback>, options?: InternalGlobalHookOptions): void;
 	_addBeforeHooks(handlers: Array<HandlerCallback>, options?: InternalGlobalHookOptions): void;
 	_addAfterHooks(handlers: Array<HandlerCallback>, options?: InternalGlobalHookOptions): void;
+	_addWsBeforeMessageHooks(handlers: Array<WebSocketMessageHook>): void;
+	_addWsAfterMessageHooks(handlers: Array<WebSocketMessageHook>): void;
 	private _validateHandlersArray;
 	_addOnError(handler: HandlerCallback): void;
 	_addOnNotFound(handler: HandlerCallback): void;
@@ -2827,29 +3139,30 @@ declare class HookRegistryImpl implements InternalHookRegistryImpl {
  * // Basic configuration with logging
  * const app = new YinzerFlow({
  *   port: 8080,
- *   logLevel: 'info',
- *   networkLogs: true
+ *   logging: { level: 'info', requests: true }
  * });
  *
  * // Full configuration example
  * const app = new YinzerFlow({
  *   port: 3000,
  *   host: '0.0.0.0',
- *   logLevel: 'debug',
- *   networkLogs: true,
- *   autoGracefulShutdown: true,
+ *   logging: {
+ *     level: 'debug',
+ *     personality: true,
+ *     requests: true,
+ *     logger: {
+ *       info: (message, ...args) => console.log(`[APP] ${message}`, ...args),
+ *       warn: (message, ...args) => console.warn(`[APP] ${message}`, ...args),
+ *       error: (message, ...args) => console.error(`[APP] ${message}`, ...args),
+ *       debug: (message, ...args) => console.debug(`[APP] ${message}`, ...args)
+ *     }
+ *   },
  *   cors: {
  *     enabled: true,
  *     origin: ['https://example.com', 'https://app.example.com'],
  *     methods: ['GET', 'POST', 'PUT', 'DELETE'],
  *     headers: ['Content-Type', 'Authorization'],
  *     credentials: true
- *   },
- *   logger: {
- *     info: (message, ...args) => console.log(`[APP] ${message}`, ...args),
- *     warn: (message, ...args) => console.warn(`[APP] ${message}`, ...args),
- *     error: (message, ...args) => console.error(`[APP] ${message}`, ...args),
- *     debug: (message, ...args) => console.debug(`[APP] ${message}`, ...args)
  *   }
  * });
  * ```
@@ -2949,10 +3262,61 @@ declare class RouteRegistryImpl implements InternalRouteRegistryImpl {
 	private _storeParameterizedRoute;
 	private _findParameterizedRoute;
 }
+declare const loggerBrand: unique symbol;
+declare const LOG_LEVELS: {
+	readonly off: 0;
+	readonly error: 1;
+	readonly warn: 2;
+	readonly info: 3;
+	readonly debug: 4;
+};
+export declare const createLogger: (initialConfig?: LoggerConfig & {
+	personality?: boolean;
+	logger?: Logger | null | undefined;
+}) => {
+	info: (...args: Array<unknown>) => void;
+	warn: (...args: Array<unknown>) => void;
+	error: (...args: Array<unknown>) => void;
+	debug: (...args: Array<unknown>) => void;
+	table: (data: unknown, ...additionalArgs: Array<unknown>) => void;
+	levels: typeof LOG_LEVELS;
+	[loggerBrand]: {
+		level: string;
+		prefix: string;
+		personality: boolean;
+	};
+};
+declare const log: {
+	info: (...args: Array<unknown>) => void;
+	warn: (...args: Array<unknown>) => void;
+	error: (...args: Array<unknown>) => void;
+	debug: (...args: Array<unknown>) => void;
+	table: (data: unknown, ...additionalArgs: Array<unknown>) => void;
+	levels: typeof LOG_LEVELS;
+	[loggerBrand]: {
+		level: string;
+		prefix: string;
+		personality: boolean;
+	};
+};
+export interface WsRouteMatch {
+	handlers: WebSocketHandlers;
+	options: WebSocketRouteOptions | undefined;
+	params: Record<string, string>;
+}
+declare class WebSocketRouter {
+	private readonly _exactRoutes;
+	private readonly _parameterizedRoutes;
+	_register(path: string, handlers: WebSocketHandlers, options?: WebSocketRouteOptions): void;
+	_match(path: string): WsRouteMatch | undefined;
+	_hasRoutes(): boolean;
+}
 declare class SetupImpl implements InternalSetupImpl {
 	readonly _configuration: InternalServerOptions;
 	readonly _routeRegistry: RouteRegistryImpl;
 	readonly _hooks: HookRegistryImpl;
+	readonly _wsRouter: WebSocketRouter;
+	_log: typeof log;
 	constructor(customConfiguration?: ServerOptions);
 	get(path: string, handler: HandlerCallback<any>, options?: InternalRouteRegistryOptions): void;
 	head(path: string, handler: HandlerCallback<any>, options?: InternalRouteRegistryOptions): void;
@@ -2967,13 +3331,24 @@ declare class SetupImpl implements InternalSetupImpl {
 	afterAll(handlers: Array<HandlerCallback<any>>, options?: InternalGlobalHookOptions): void;
 	onError(handler: HandlerCallback<any>): void;
 	onNotFound(handler: HandlerCallback<any>): void;
+	ws<T = unknown>(path: string, handlers: WebSocketHandlers<T>, options?: WebSocketRouteOptions): void;
+	wsBeforeMessage(handlers: Array<WebSocketMessageHook>): void;
+	wsAfterMessage(handlers: Array<WebSocketMessageHook>): void;
 }
 export declare class YinzerFlow extends SetupImpl {
 	private _isListening;
 	private _server?;
 	private _globalRateLimiter?;
+	private _diagnostics?;
 	private readonly _maxBufferSize;
+	private _accessLog?;
+	private _accessLogEnabled;
+	private _wsConnections?;
+	private _wsChannelManager?;
+	private _wsSecurity?;
 	constructor(configuration?: ServerOptions);
+	get log(): typeof YinzerFlow._log;
+	private _configureLogging;
 	private _setupServer;
 	private _processRequest;
 	private _handleRequestError;
@@ -2982,6 +3357,17 @@ export declare class YinzerFlow extends SetupImpl {
 	private _looksLikeHttp;
 	private _parseContentLength;
 	private _handleConnection;
+	private _handleConnectionData;
+	private _handleHeaderPhase;
+	private _handleWebSocketUpgrade;
+	private _handleWebSocketUpgradeAsync;
+	private _setupWsConnection;
+	private _mergeWsConnectionOptions;
+	private _wrapWsHandlers;
+	private _parseHeadersMap;
+	private _sendHttpError;
+	publish(channel: string, data: Buffer | string): number;
+	subscriberCount(channel: string): number;
 	listen(): Promise<void>;
 	close(): Promise<void>;
 	status(): {
@@ -2991,26 +3377,6 @@ export declare class YinzerFlow extends SetupImpl {
 	};
 	private _setupGracefulShutdown;
 }
-declare const LOG_LEVELS: {
-	readonly off: 0;
-	readonly error: 1;
-	readonly warn: 2;
-	readonly info: 3;
-};
-export declare const createLogger: (initialConfig?: LoggerConfig) => {
-	info: (...args: Array<unknown>) => void;
-	warn: (...args: Array<unknown>) => void;
-	error: (...args: Array<unknown>) => void;
-	table: (data: unknown, ...additionalArgs: Array<unknown>) => void;
-	levels: typeof LOG_LEVELS;
-};
-export declare const log: {
-	info: (...args: Array<unknown>) => void;
-	warn: (...args: Array<unknown>) => void;
-	error: (...args: Array<unknown>) => void;
-	table: (data: unknown, ...additionalArgs: Array<unknown>) => void;
-	levels: typeof LOG_LEVELS;
-};
 export declare const corsHook: (config: InternalCorsEnabledOptions) => HandlerCallback;
 export declare const rateLimitHook: <T extends HandlerCallbackGenerics>(rateLimitOptions: RateLimitOptions) => HandlerCallback<T>;
 export declare const colors: {
@@ -3022,5 +3388,40 @@ export declare const colors: {
 	readonly magenta: "\u001B[95m";
 	readonly gray: "\u001B[90m";
 };
+export declare const wsOpcode: {
+	readonly continuation: 0;
+	readonly text: 1;
+	readonly binary: 2;
+	readonly close: 8;
+	readonly ping: 9;
+	readonly pong: 10;
+};
+export declare const wsCloseCode: {
+	readonly normal: 1000;
+	readonly goingAway: 1001;
+	readonly protocolError: 1002;
+	readonly unsupported: 1003;
+	readonly noStatus: 1005;
+	readonly abnormal: 1006;
+	readonly invalidPayload: 1007;
+	readonly policyViolation: 1008;
+	readonly tooLarge: 1009;
+	readonly missingExtension: 1010;
+	readonly internalError: 1011;
+};
+export declare const wsReadyState: {
+	readonly connecting: 0;
+	readonly open: 1;
+	readonly closing: 2;
+	readonly closed: 3;
+};
+export declare const wsBackpressureStrategy: {
+	readonly buffer: "buffer";
+	readonly drop: "drop";
+};
+
+export {
+	WebSocket$1 as WebSocket,
+};
 
 export {};