lacis 0.2.0

package/dist/cli/index.js

@@ -0,0 +1,158 @@
+#!/usr/bin/env node
+import { resolve, join, relative } from 'path';
+import { writeFile, readdir } from 'fs/promises';
+import { watch, existsSync, readFileSync } from 'fs';
+import { spawn } from 'child_process';
+
+async function discoverRoutes(routesDir) {
+  const routes = [];
+  async function scan(dir, pathSegments = []) {
+    let entries;
+    try {
+      entries = await readdir(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    const indexFile = entries.find(
+      (e) => !e.isDirectory() && (e.name === "index.ts" || e.name === "index.js")
+    );
+    if (indexFile) {
+      const importPath = "./" + relative(routesDir, join(dir, indexFile.name)).replace(/\\/g, "/").replace(/\.ts$/, ".js");
+      const routePath = "/" + pathSegments.map((s) => s.replace(/^\[(\w+)\??\]$/, ":$1")).join("/");
+      routes.push({ importPath, routePath: routePath === "//" ? "/" : routePath });
+    }
+    for (const entry of entries) {
+      if (entry.isDirectory() && !entry.name.startsWith("+")) {
+        await scan(join(dir, entry.name), [...pathSegments, entry.name]);
+      }
+    }
+  }
+  await scan(routesDir);
+  return routes;
+}
+async function generateManifest(routesDir) {
+  const routes = await discoverRoutes(routesDir);
+  const imports = routes.map((r, i) => `import * as _route_${i} from '${r.importPath}'`).join("\n");
+  const entries = routes.map((r, i) => `  { path: '${r.routePath}', handlers: _route_${i} }`).join(",\n");
+  const content = [
+    "// AUTO-GENERATED by zeno build \u2014 do not edit",
+    imports,
+    "",
+    "export const routes = [",
+    entries,
+    "]",
+    ""
+  ].join("\n");
+  await writeFile(join(routesDir, "_manifest.ts"), content, "utf-8");
+  console.log(`[zeno] Generated manifest with ${routes.length} route(s)`);
+}
+async function watchRoutes(routesDir) {
+  await generateManifest(routesDir);
+  let debounceTimer = null;
+  watch(routesDir, { recursive: true }, (_event, filename) => {
+    if (!filename || filename === "_manifest.ts") return;
+    if (debounceTimer) clearTimeout(debounceTimer);
+    debounceTimer = setTimeout(async () => {
+      console.log(`[zeno] Route changed: ${filename}, regenerating manifest...`);
+      try {
+        await generateManifest(routesDir);
+      } catch (err) {
+        console.error("[zeno] Failed to regenerate manifest:", err);
+      }
+    }, 100);
+  });
+}
+function detectPlatform(cwd) {
+  if (existsSync(join(cwd, "netlify.toml"))) return "netlify";
+  if (existsSync(join(cwd, "vercel.json"))) return "vercel";
+  try {
+    const pkg = JSON.parse(readFileSync(join(cwd, "package.json"), "utf-8"));
+    const allDeps = { ...pkg.dependencies, ...pkg.devDependencies };
+    if (allDeps["@netlify/functions"] || allDeps["netlify-cli"]) return "netlify";
+    if (allDeps["vercel"] || allDeps["@vercel/node"]) return "vercel";
+  } catch {
+  }
+  return "node";
+}
+async function dev(routesDir) {
+  const cwd = process.cwd();
+  if (process.env.VERCEL === "1") {
+    await generateManifest(routesDir);
+    return;
+  }
+  if (process.env.NETLIFY === "true") {
+    await watchRoutes(routesDir);
+    return;
+  }
+  const platform = detectPlatform(cwd);
+  console.log(`[zeno] Detected platform: ${platform}`);
+  await watchRoutes(routesDir);
+  if (platform === "node") {
+    console.log("[zeno] Node mode: watching routes for changes...");
+    return;
+  }
+  const [cmd, args] = platform === "netlify" ? ["netlify", ["dev"]] : ["vercel", ["dev"]];
+  const child = spawn(cmd, args, { stdio: "inherit", shell: true, cwd });
+  child.on("error", (err) => {
+    if (err.code === "ENOENT") {
+      const install = platform === "netlify" ? "npm i -g netlify-cli" : "npm i -g vercel";
+      console.error(`[zeno] ${cmd} CLI not found. Install it with: ${install}`);
+    } else {
+      console.error(`[zeno] Failed to start ${cmd} dev:`, err.message);
+    }
+  });
+  const forward = (signal) => {
+    process.on(signal, () => child.kill(signal));
+  };
+  forward("SIGINT");
+  forward("SIGTERM");
+}
+
+// src/cli/index.ts
+function parseArgs(argv) {
+  const args = argv.slice(2);
+  const command = args[0] ?? "";
+  const routesFlagIndex = args.indexOf("--routes");
+  const routesDirArg = routesFlagIndex !== -1 ? args[routesFlagIndex + 1] : void 0;
+  const routesDir = routesDirArg ? resolve(process.cwd(), routesDirArg) : resolve(process.cwd(), "routes");
+  return { command, routesDir };
+}
+function printHelp() {
+  console.log(`
+Usage: zeno <command> [options]
+
+Commands:
+  build             Generate routes/_manifest.ts
+  watch             Watch routes and regenerate manifest on changes
+  dev               Auto-detect platform and start dev server
+
+To scaffold a new project: npm create zeno@latest
+
+Options:
+  --routes <dir>    Path to routes directory (default: ./routes)
+`);
+}
+async function main() {
+  const { command, routesDir } = parseArgs(process.argv);
+  switch (command) {
+    case "build":
+      await generateManifest(routesDir);
+      break;
+    case "watch":
+      await watchRoutes(routesDir);
+      break;
+    case "dev":
+      await dev(routesDir);
+      break;
+    default:
+      printHelp();
+      if (command) {
+        console.error(`Unknown command: ${command}`);
+        process.exit(1);
+      }
+  }
+}
+main().catch((err) => {
+  console.error("[zeno]", err);
+  process.exit(1);
+});

package/dist/index-rE4kFMlu.d.ts

@@ -0,0 +1,192 @@
+import { IncomingMessage, ServerResponse } from 'http';
+
+interface CookieOptions {
+    path?: string;
+    domain?: string;
+    maxAge?: number;
+    expires?: Date;
+    httpOnly?: boolean;
+    secure?: boolean;
+    sameSite?: 'Strict' | 'Lax' | 'None';
+}
+interface RequestCookies {
+    get(name: string): string | undefined;
+    all(): Record<string, string>;
+}
+interface ResponseCookies {
+    set(name: string, value: string, options?: CookieOptions): ResponseCookies;
+    delete(name: string, options?: Pick<CookieOptions, 'path' | 'domain'>): ResponseCookies;
+}
+interface UploadedFile {
+    filename: string;
+    mimetype: string;
+    data: Buffer;
+    size: number;
+}
+interface Request extends IncomingMessage {
+    params?: Record<string, string>;
+    query?: Record<string, string>;
+    cookies: RequestCookies;
+    getHeader(name: string): string | undefined;
+    createSSEClient(options?: SSEClientOptions, handlers?: SSEEventHandlers): SSEClient;
+    json<T>(): Promise<T>;
+    form<T>(): Promise<T>;
+    body(): Promise<Buffer>;
+}
+interface Response extends ServerResponse {
+    headers?: Record<string, string>;
+    body?: any;
+    cookies: ResponseCookies;
+    json(data: any): void;
+    send(data: any): void;
+    status(code: number): Response;
+    initSSE(options?: SSEOptions): void;
+    sseSend(data: string): void;
+    sseJson(data: any): void;
+    sseEvent(event: string, data: any): void;
+    sseComment(comment: string): void;
+    sseId(id: string): void;
+    sseRetry(ms: number): void;
+    sseClose(comment?: string): void;
+    sseError(event: string, error: string, code?: number, details?: string): void;
+}
+
+type MiddlewareType = 'beforeRequest' | 'afterRequest' | 'onError';
+type MiddlewareCallback = (req: Request, res: Response, context?: any) => Promise<void | boolean> | void | boolean;
+interface MiddlewareModule {
+    beforeRequest?: MiddlewareCallback[];
+    afterRequest?: MiddlewareCallback[];
+    onError?: MiddlewareCallback[];
+}
+type PathMiddlewares = Map<string, {
+    beforeRequest: MiddlewareCallback[];
+    afterRequest: MiddlewareCallback[];
+    onError: MiddlewareCallback[];
+}>;
+
+interface SSEOptions {
+    headers?: Record<string, string>;
+    timeout?: number;
+}
+interface SSEClientOptions {
+    reconnectInterval?: number;
+    maxRetries?: number;
+    body?: string | Record<string, any>;
+    contentType?: string;
+    method?: "GET" | "POST" | "PUT";
+    params?: string | Record<string, string>;
+    disableReconnect?: boolean;
+}
+interface SSEEventHandlers {
+    onMessage?: (data: any) => void;
+    onEvent?: Record<string, (data: any) => void>;
+    onClose?: () => void;
+    onError?: (error: Error) => void;
+}
+interface SSEClient {
+    onMessage: (callback: (data: any) => void) => SSEClient;
+    onEvent: (eventName: string, callback: (data: any) => void) => SSEClient;
+    onClose: (callback: () => void) => SSEClient;
+    close: () => void;
+}
+
+interface AdapterRequest extends IncomingMessage {
+    params?: Record<string, string>;
+    query?: Record<string, string>;
+    body?(): Promise<Buffer>;
+    createSSEClient(options?: SSEClientOptions, handlers?: SSEEventHandlers): SSEClient;
+}
+interface AdapterResponse {
+    json?: (data: any) => void;
+}
+interface AdapterContext {
+    req: AdapterRequest;
+    res: AdapterResponse;
+    route?: Route;
+}
+interface ServerlessRoute {
+    path: string;
+    handlers: RouteHandlers;
+}
+interface ServerlessConfig {
+    routes: ServerlessRoute[];
+    cors?: CorsConfig;
+    middleware?: {
+        beforeRequest?: MiddlewareCallback | MiddlewareCallback[];
+        afterRequest?: MiddlewareCallback | MiddlewareCallback[];
+        onError?: MiddlewareCallback | MiddlewareCallback[];
+    };
+}
+interface Adapter {
+    name: string;
+    createHandler: (config: string | ServerlessConfig) => unknown;
+}
+
+interface CorsConfig {
+    origin?: string | string[] | RegExp | ((origin: string) => boolean);
+    methods?: string[];
+    allowedHeaders?: string[];
+    exposedHeaders?: string[];
+    credentials?: boolean;
+    maxAge?: number;
+}
+type Handler = (req: Request, res: Response) => Promise<void>;
+type RouteHandlers = {
+    GET?: Handler;
+    POST?: Handler;
+    PUT?: Handler;
+    DELETE?: Handler;
+    PATCH?: Handler;
+};
+type Route = {
+    pattern: RegExp;
+    handlers: RouteHandlers;
+    params: string[];
+};
+interface ServerConfig {
+    isDev?: boolean;
+    port?: number;
+    platform?: 'node' | 'vercel' | 'netlify' | 'bun';
+    timeout?: number;
+    httpsOptions?: {
+        cert?: string | Buffer;
+        key?: string | Buffer;
+        ca?: string | Buffer | Array<string | Buffer>;
+    };
+    cluster?: {
+        enabled: boolean;
+        workers?: number;
+    };
+    defaultHeaders?: Record<string, string>;
+    cors?: CorsConfig;
+    middleware?: {
+        beforeRequest?: MiddlewareCallback | MiddlewareCallback[];
+        afterRequest?: MiddlewareCallback | MiddlewareCallback[];
+        onError?: MiddlewareCallback | MiddlewareCallback[];
+    };
+    openapi?: {
+        path?: string;
+        info: {
+            title: string;
+            version: string;
+            description?: string;
+        };
+    };
+    monitoring?: {
+        enabled: boolean;
+        sampleInterval?: number;
+        reportInterval?: number;
+        thresholds?: {
+            cpu?: number;
+            memory?: number;
+            responseTime?: number;
+            errorRate?: number;
+        };
+    };
+}
+interface ClusterConfig {
+    enabled: boolean;
+    workers?: number;
+}
+
+export type { AdapterRequest as A, CorsConfig as C, Handler as H, MiddlewareType as M, PathMiddlewares as P, Request as R, ServerConfig as S, UploadedFile as U, AdapterResponse as a, Response as b, ServerlessRoute as c, MiddlewareCallback as d, SSEOptions as e, SSEClientOptions as f, SSEEventHandlers as g, SSEClient as h, Adapter as i, AdapterContext as j, ClusterConfig as k, CookieOptions as l, MiddlewareModule as m, RequestCookies as n, ResponseCookies as o, Route as p, RouteHandlers as q, ServerlessConfig as r };

package/dist/index.d.ts

@@ -0,0 +1,343 @@
+import { S as ServerConfig, A as AdapterRequest, a as AdapterResponse, R as Request, b as Response, c as ServerlessRoute, M as MiddlewareType, d as MiddlewareCallback, P as PathMiddlewares, C as CorsConfig, e as SSEOptions, f as SSEClientOptions, g as SSEEventHandlers, h as SSEClient } from './index-rE4kFMlu.js';
+export { i as Adapter, j as AdapterContext, k as ClusterConfig, l as CookieOptions, H as Handler, m as MiddlewareModule, n as RequestCookies, o as ResponseCookies, p as Route, q as RouteHandlers, r as ServerlessConfig, U as UploadedFile } from './index-rE4kFMlu.js';
+import { Server, ServerResponse, IncomingMessage } from 'http';
+
+interface VercelRequest {
+    url?: string;
+    method?: string;
+    headers: Record<string, string | string[] | undefined>;
+    body?: any;
+    query?: Record<string, string | string[]>;
+}
+interface VercelResponse {
+    statusCode?: number;
+    status: (statusCode: number) => VercelResponse;
+    json: (body: any) => void;
+    send: (body: any) => void;
+    setHeader: (name: string, value: string) => void;
+}
+interface NetlifyEvent {
+    path: string;
+    httpMethod: string;
+    headers: Record<string, string | undefined>;
+    body?: string;
+    queryStringParameters?: Record<string, string>;
+}
+interface NetlifyContext {
+}
+interface NetlifyResponse {
+    statusCode: number;
+    headers?: Record<string, string>;
+    body: string;
+}
+type NetlifyHandler = (event: NetlifyEvent, context: NetlifyContext) => Promise<NetlifyResponse>;
+type PlatformHandler = ((config?: ServerConfig) => Server) | ((req: AdapterRequest, res: AdapterResponse) => Promise<void>) | ((event: NetlifyEvent, context: NetlifyContext) => Promise<{
+    statusCode: number;
+    body: string;
+    headers?: Record<string, string>;
+}>);
+
+interface MetricValue {
+    min: number;
+    max: number;
+    avg: number;
+    count: number;
+    sum: number;
+    p50?: number;
+    p90?: number;
+    p99?: number;
+}
+interface Metrics {
+    timestamp: number;
+    uptime: number;
+    requestCount: number;
+    activeRequests: number;
+    errorCount: number;
+    responseTimes: MetricValue;
+    statusCodes: Record<number, number>;
+    memory: {
+        rss: number;
+        heapTotal: number;
+        heapUsed: number;
+        external: number;
+        arrayBuffers: number;
+    };
+    cpu: {
+        usage: number;
+        system: number;
+        user: number;
+    };
+    systemLoad: number[];
+    systemMemory: {
+        total: number;
+        free: number;
+        used: number;
+    };
+}
+interface PerformanceData {
+    startTime: number;
+    requestCount: number;
+    activeRequests: number;
+    errorCount: number;
+    responseTimes: number[];
+    statusCodes: Record<number, number>;
+    responseTimesBucket: number[];
+    lastReport: number;
+    lastReset: number;
+}
+interface MonitorOptions {
+    sampleInterval?: number;
+    reportInterval?: number;
+    resetInterval?: number;
+    enableHistogram?: boolean;
+    logToConsole?: boolean;
+    thresholds?: {
+        cpu?: number;
+        memory?: number;
+        responseTime?: number;
+        errorRate?: number;
+    };
+}
+interface AlarmStatus {
+    cpu: boolean;
+    memory: boolean;
+    responseTime: boolean;
+    errorRate: boolean;
+}
+
+interface WorkerStats {
+    pid: number;
+    load: number;
+    lastUsed: number;
+    memoryUsage: NodeJS.MemoryUsage;
+}
+interface BalancerOptions {
+    reportInterval?: number;
+}
+interface StatsMessage {
+    type: "stats";
+    stats: Partial<WorkerStats>;
+}
+
+declare const defaultConfig: ServerConfig;
+declare function getConfig(customConfig?: Partial<ServerConfig>): ServerConfig;
+
+interface StandardSchema<Input = unknown, Output = Input> {
+    readonly "~standard": {
+        readonly version: 1;
+        readonly vendor: string;
+        readonly validate: (value: unknown) => StandardResult<Output> | Promise<StandardResult<Output>>;
+        readonly types?: {
+            readonly input: Input;
+            readonly output: Output;
+        };
+    };
+}
+type StandardResult<Output> = {
+    readonly value: Output;
+    readonly issues?: undefined;
+} | {
+    readonly issues: ReadonlyArray<StandardIssue>;
+};
+interface StandardIssue {
+    readonly message: string;
+    readonly path?: ReadonlyArray<PropertyKey | {
+        readonly key: PropertyKey;
+    }>;
+}
+type InferOutput<T extends StandardSchema> = NonNullable<T["~standard"]["types"]>["output"];
+type ValidatedRequest<TParams extends StandardSchema | undefined, TQuery extends StandardSchema | undefined, TBody extends StandardSchema | undefined> = Omit<Request, "params" | "query" | "body"> & {
+    params: TParams extends StandardSchema ? InferOutput<TParams> : Record<string, string> | undefined;
+    query: TQuery extends StandardSchema ? InferOutput<TQuery> : Record<string, string> | undefined;
+    body: TBody extends StandardSchema ? InferOutput<TBody> : () => Promise<Buffer>;
+};
+interface HandlerMeta {
+    summary?: string;
+    description?: string;
+    tags?: string[];
+    deprecated?: boolean;
+}
+interface DefineHandlerConfig<TParams extends StandardSchema | undefined = undefined, TQuery extends StandardSchema | undefined = undefined, TBody extends StandardSchema | undefined = undefined> {
+    params?: TParams;
+    query?: TQuery;
+    body?: TBody;
+    meta?: HandlerMeta;
+    handler: (req: ValidatedRequest<TParams, TQuery, TBody>, res: Response) => void | Promise<void>;
+}
+type DefinedHandler = ((req: Request, res: Response) => Promise<void>) & {
+    _defineHandler: DefineHandlerConfig<any, any, any>;
+};
+declare function defineHandler<TParams extends StandardSchema | undefined = undefined, TQuery extends StandardSchema | undefined = undefined, TBody extends StandardSchema | undefined = undefined>(config: DefineHandlerConfig<TParams, TQuery, TBody>): DefinedHandler;
+
+interface OpenApiInfo {
+    title: string;
+    version: string;
+    description?: string;
+}
+interface OpenApiConfig {
+    path?: string;
+    info: OpenApiInfo;
+}
+declare function buildOpenApiDoc(config: OpenApiConfig): Promise<Record<string, any>>;
+
+declare function createServer(routesDir: string, config?: ServerConfig): Promise<unknown>;
+
+interface RouteMatchResult {
+    handler: Function | null;
+    params: Record<string, string>;
+    allowedMethods?: string[];
+}
+interface RouteError {
+    error: string;
+    status?: number;
+    allowedMethods?: string[];
+}
+type FindRouteResult = {
+    handler: Function;
+    params: Record<string, string>;
+} | RouteError | null;
+declare class Router {
+    private rootNode;
+    private cachedRoutes;
+    private routeCount;
+    private lastLoaded;
+    private verbose;
+    constructor();
+    private createNode;
+    addRoute(method: string, routePath: string, handler: Function): Router;
+    findRoute(method: string, url: string): RouteMatchResult;
+    private traverse;
+    loadRoutes(routesDir: string): Promise<boolean>;
+    getRoutes(): Array<{
+        method: string;
+        path: string;
+        handler: Function;
+    }>;
+    private collectRoutes;
+    getStats(): {
+        routeCount: number;
+        lastLoaded: number;
+        uptime: number;
+        cacheSize: number;
+    };
+    setVerbose(verbose: boolean): Router;
+    reset(): void;
+}
+declare const router: Router;
+declare function isRouteError(obj: any): obj is RouteError;
+declare function registerRoutes(routes: ServerlessRoute[]): void;
+declare function loadRoutes(routesDir: string): Promise<boolean>;
+declare function findRoute(url: string, method?: string): FindRouteResult;
+declare function getRoutesDir(customDir?: string): string;
+declare function getRouterStats(): {
+    routeCount: number;
+    lastLoaded: number;
+    uptime: number;
+    cacheSize: number;
+};
+declare function setVerboseLogging(verbose: boolean): void;
+declare function resetRouter(): void;
+
+declare function addMiddleware(middlewareName: MiddlewareType, callback: MiddlewareCallback): {
+    remove: () => void;
+};
+declare function addPathMiddleware(path: string, type: MiddlewareType, callback: MiddlewareCallback): {
+    remove: () => void;
+};
+declare function collectMiddleware(url: string): {
+    beforeRequest: MiddlewareCallback[];
+    afterRequest: MiddlewareCallback[];
+    onError: MiddlewareCallback[];
+};
+declare function hasMiddlewares(): boolean;
+declare function runMiddlewares(middlewareName: MiddlewareType, req: Request, res: Response, context?: any): Promise<boolean>;
+declare function loadMiddlewares(routesDir: string): Promise<void>;
+declare function getPathMiddlewares(): PathMiddlewares;
+declare function resetMiddlewares(): void;
+declare function registerMiddlewareConfig(config?: {
+    beforeRequest?: MiddlewareCallback | MiddlewareCallback[];
+    afterRequest?: MiddlewareCallback | MiddlewareCallback[];
+    onError?: MiddlewareCallback | MiddlewareCallback[];
+}): void;
+
+declare const HTTP_STATUS: {
+    OK: number;
+    CREATED: number;
+    NO_CONTENT: number;
+    BAD_REQUEST: number;
+    UNAUTHORIZED: number;
+    FORBIDDEN: number;
+    NOT_FOUND: number;
+    METHOD_NOT_ALLOWED: number;
+    CONFLICT: number;
+    UNPROCESSABLE_ENTITY: number;
+    TOO_MANY_REQUESTS: number;
+    INTERNAL_SERVER_ERROR: number;
+    SERVICE_UNAVAILABLE: number;
+    GATEWAY_TIMEOUT: number;
+};
+interface HttpError {
+    name: string;
+    code: number;
+    message: string;
+    details?: any;
+    expose: boolean;
+    log: boolean;
+    stack?: string;
+}
+declare function createHttpError(options: {
+    name?: string;
+    code?: number;
+    message?: string;
+    details?: any;
+    expose?: boolean;
+    log?: boolean;
+}): HttpError;
+declare function sendError(error: HttpError, res: ServerResponse): void;
+declare function logError(error: HttpError): void;
+declare function createBadRequestError(message?: string, details?: any): HttpError;
+declare function createUnauthorizedError(message?: string, details?: any): HttpError;
+declare function createForbiddenError(message?: string, details?: any): HttpError;
+declare function createNotFoundError(message?: string, details?: any): HttpError;
+declare function createMethodNotAllowedError(message?: string, details?: any): HttpError;
+declare function createConflictError(message?: string, details?: any): HttpError;
+declare function createValidationError(message?: string, details?: any): HttpError;
+declare function createRateLimitError(message?: string, details?: any): HttpError;
+declare function createInternalServerError(message?: string, details?: any): HttpError;
+declare function createServiceUnavailableError(message?: string, details?: any): HttpError;
+declare function createGatewayTimeoutError(message?: string, details?: any): HttpError;
+declare function normalizeError(error: any): HttpError;
+declare function isHttpError(error: any): error is HttpError;
+
+interface RateLimitOptions {
+    windowMs?: number;
+    max?: number;
+    message?: string;
+    keyGenerator?: (req: Request) => string;
+}
+declare function createRateLimit(options?: RateLimitOptions): MiddlewareCallback;
+
+declare function createCorsMiddleware(config: CorsConfig): MiddlewareCallback;
+declare function registerCorsConfig(cors?: CorsConfig): void;
+
+declare function initSSE(res: ServerResponse, options?: SSEOptions): ReturnType<typeof setTimeout>;
+declare function send(res: ServerResponse, data: any): boolean;
+declare function sendJson(res: ServerResponse, data: any): boolean;
+declare function sendEvent(res: ServerResponse, event: string, data: any): boolean;
+declare function sseComment(res: ServerResponse, comment: string): boolean;
+declare function sseId(res: ServerResponse, id: string): boolean;
+declare function sseRetry(res: ServerResponse, ms: number): boolean;
+declare function sseClose(res: ServerResponse, comment?: string): void;
+declare function sseEventError(res: ServerResponse, event: string, error: string, code?: number, details?: string): void;
+
+/**
+ * Creates a Server-Sent Events (SSE) client that can handle both URL connections and existing SSE streams
+ * @param urlOrReq - URL to connect to or an existing IncomingMessage
+ * @param options - Configuration options for the SSE client
+ * @param handlers - Event handlers for the SSE connection
+ * @param req - Optional IncomingMessage to inherit headers from
+ * @returns A Promise resolving to an SSE client for URL connections, or an SSE client directly for existing connections
+ */
+declare function createSSEClient(urlOrReq: string | IncomingMessage, options?: SSEClientOptions, handlers?: SSEEventHandlers, req?: IncomingMessage): Promise<SSEClient> | SSEClient;
+
+export { AdapterRequest, AdapterResponse, type AlarmStatus, type BalancerOptions, CorsConfig, type DefineHandlerConfig, type DefinedHandler, HTTP_STATUS, type HandlerMeta, type InferOutput, type MetricValue, type Metrics, MiddlewareCallback, MiddlewareType, type MonitorOptions, type NetlifyContext, type NetlifyEvent, type NetlifyHandler, type NetlifyResponse, type OpenApiConfig, type OpenApiInfo, PathMiddlewares, type PerformanceData, type PlatformHandler, type RateLimitOptions, Request, Response, SSEClient, SSEClientOptions, SSEEventHandlers, SSEOptions, ServerConfig, ServerlessRoute, type StandardIssue, type StandardSchema, type StatsMessage, type ValidatedRequest, type VercelRequest, type VercelResponse, type WorkerStats, addMiddleware, addPathMiddleware, buildOpenApiDoc, collectMiddleware, createBadRequestError, createConflictError, createCorsMiddleware, createForbiddenError, createGatewayTimeoutError, createHttpError, createInternalServerError, createMethodNotAllowedError, createNotFoundError, createRateLimit, createRateLimitError, createSSEClient, createServer, createServiceUnavailableError, createUnauthorizedError, createValidationError, defaultConfig, defineHandler, findRoute, getConfig, getPathMiddlewares, getRouterStats, getRoutesDir, hasMiddlewares, initSSE, isHttpError, isRouteError, loadMiddlewares, loadRoutes, logError, normalizeError, registerCorsConfig, registerMiddlewareConfig, registerRoutes, resetMiddlewares, resetRouter, router, runMiddlewares, send, sendError, sendEvent, sendJson, setVerboseLogging, sseClose, sseComment, sseEventError, sseId, sseRetry };