bun-types 1.2.24-canary.20251005T140541 → 1.2.24-canary.20251007T140703

package/bun.d.ts

@@ -18,7 +18,7 @@ declare module "bun" {
   type ArrayBufferView<TArrayBuffer extends ArrayBufferLike = ArrayBufferLike> =
     | NodeJS.TypedArray<TArrayBuffer>
     | DataView<TArrayBuffer>;
-  type BufferSource = NodeJS.TypedArray | DataView | ArrayBufferLike;
+  type BufferSource = NodeJS.TypedArray<ArrayBufferLike> | DataView<ArrayBufferLike> | ArrayBufferLike;
   type StringOrBuffer = string | NodeJS.TypedArray | ArrayBufferLike;
   type XMLHttpRequestBodyInit = Blob | BufferSource | FormData | URLSearchParams | string;
   type ReadableStreamController<T> = ReadableStreamDefaultController<T>;
@@ -90,6 +90,12 @@ declare module "bun" {
       };
     type Merge<A, B> = MergeInner<A, B> & MergeInner<B, A>;
     type DistributedMerge<T, Else = T> = T extends T ? Merge<T, Exclude<Else, T>> : never;
+
+    type Without<A, B> = A & {
+      [Key in Exclude<keyof B, keyof A>]?: never;
+    };
+
+    type XOR<A, B> = Without<A, B> | Without<B, A>;
   }
 
   interface ErrorEventInit extends EventInit {
@@ -2780,1568 +2786,113 @@ declare module "bun" {
    */
   function build(config: BuildConfig): Promise<BuildOutput>;
 
-  /**
-   * A status that represents the outcome of a sent message.
-   *
-   * - if **0**, the message was **dropped**.
-   * - if **-1**, there is **backpressure** of messages.
-   * - if **>0**, it represents the **number of bytes sent**.
-   *
-   * @example
-   * ```js
-   * const status = ws.send("Hello!");
-   * if (status === 0) {
-   *   console.log("Message was dropped");
-   * } else if (status === -1) {
-   *   console.log("Backpressure was applied");
-   * } else {
-   *   console.log(`Success! Sent ${status} bytes`);
-   * }
-   * ```
-   */
-  type ServerWebSocketSendStatus = number;
-
-  /**
-   * A state that represents if a WebSocket is connected.
-   *
-   * - `WebSocket.CONNECTING` is `0`, the connection is pending.
-   * - `WebSocket.OPEN` is `1`, the connection is established and `send()` is possible.
-   * - `WebSocket.CLOSING` is `2`, the connection is closing.
-   * - `WebSocket.CLOSED` is `3`, the connection is closed or couldn't be opened.
-   *
-   * @link https://developer.mozilla.org/en-US/docs/Web/API/WebSocket/readyState
-   */
-  type WebSocketReadyState = 0 | 1 | 2 | 3;
-
-  /**
-   * A fast WebSocket designed for servers.
-   *
-   * Features:
-   * - **Message compression** - Messages can be compressed
-   * - **Backpressure** - If the client is not ready to receive data, the server will tell you.
-   * - **Dropped messages** - If the client cannot receive data, the server will tell you.
-   * - **Topics** - Messages can be {@link ServerWebSocket.publish}ed to a specific topic and the client can {@link ServerWebSocket.subscribe} to topics
-   *
-   * This is slightly different than the browser {@link WebSocket} which Bun supports for clients.
-   *
-   * Powered by [uWebSockets](https://github.com/uNetworking/uWebSockets).
-   *
-   * @example
-   * ```ts
-   * Bun.serve({
-   *   websocket: {
-   *     open(ws) {
-   *       console.log("Connected", ws.remoteAddress);
-   *     },
-   *     message(ws, data) {
-   *       console.log("Received", data);
-   *       ws.send(data);
-   *     },
-   *     close(ws, code, reason) {
-   *       console.log("Disconnected", code, reason);
-   *     },
-   *   }
-   * });
-   * ```
-   *
-   * @category HTTP & Networking
-   */
-  interface ServerWebSocket<T = undefined> {
-    /**
-     * Sends a message to the client.
-     *
-     * @param data The data to send.
-     * @param compress Should the data be compressed? If the client does not support compression, this is ignored.
-     * @example
-     * ws.send("Hello!");
-     * ws.send("Compress this.", true);
-     * ws.send(new Uint8Array([1, 2, 3, 4]));
-     */
-    send(data: string | BufferSource, compress?: boolean): ServerWebSocketSendStatus;
-
-    /**
-     * Sends a text message to the client.
-     *
-     * @param data The data to send.
-     * @param compress Should the data be compressed? If the client does not support compression, this is ignored.
-     * @example
-     * ws.send("Hello!");
-     * ws.send("Compress this.", true);
-     */
-    sendText(data: string, compress?: boolean): ServerWebSocketSendStatus;
-
-    /**
-     * Sends a binary message to the client.
-     *
-     * @param data The data to send.
-     * @param compress Should the data be compressed? If the client does not support compression, this is ignored.
-     * @example
-     * ws.send(new TextEncoder().encode("Hello!"));
-     * ws.send(new Uint8Array([1, 2, 3, 4]), true);
-     */
-    sendBinary(data: BufferSource, compress?: boolean): ServerWebSocketSendStatus;
-
-    /**
-     * Closes the connection.
-     *
-     * Here is a list of close codes:
-     * - `1000` means "normal closure" **(default)**
-     * - `1009` means a message was too big and was rejected
-     * - `1011` means the server encountered an error
-     * - `1012` means the server is restarting
-     * - `1013` means the server is too busy or the client is rate-limited
-     * - `4000` through `4999` are reserved for applications (you can use it!)
-     *
-     * To close the connection abruptly, use `terminate()`.
-     *
-     * @param code The close code to send
-     * @param reason The close reason to send
-     */
-    close(code?: number, reason?: string): void;
-
-    /**
-     * Abruptly close the connection.
-     *
-     * To gracefully close the connection, use `close()`.
-     */
-    terminate(): void;
-
-    /**
-     * Sends a ping.
-     *
-     * @param data The data to send
-     */
-    ping(data?: string | BufferSource): ServerWebSocketSendStatus;
-
-    /**
-     * Sends a pong.
-     *
-     * @param data The data to send
-     */
-    pong(data?: string | BufferSource): ServerWebSocketSendStatus;
-
-    /**
-     * Sends a message to subscribers of the topic.
-     *
-     * @param topic The topic name.
-     * @param data The data to send.
-     * @param compress Should the data be compressed? If the client does not support compression, this is ignored.
-     * @example
-     * ws.publish("chat", "Hello!");
-     * ws.publish("chat", "Compress this.", true);
-     * ws.publish("chat", new Uint8Array([1, 2, 3, 4]));
-     */
-    publish(topic: string, data: string | BufferSource, compress?: boolean): ServerWebSocketSendStatus;
-
-    /**
-     * Sends a text message to subscribers of the topic.
-     *
-     * @param topic The topic name.
-     * @param data The data to send.
-     * @param compress Should the data be compressed? If the client does not support compression, this is ignored.
-     * @example
-     * ws.publish("chat", "Hello!");
-     * ws.publish("chat", "Compress this.", true);
-     */
-    publishText(topic: string, data: string, compress?: boolean): ServerWebSocketSendStatus;
-
-    /**
-     * Sends a binary message to subscribers of the topic.
-     *
-     * @param topic The topic name.
-     * @param data The data to send.
-     * @param compress Should the data be compressed? If the client does not support compression, this is ignored.
-     * @example
-     * ws.publish("chat", new TextEncoder().encode("Hello!"));
-     * ws.publish("chat", new Uint8Array([1, 2, 3, 4]), true);
-     */
-    publishBinary(topic: string, data: BufferSource, compress?: boolean): ServerWebSocketSendStatus;
-
-    /**
-     * Subscribes a client to the topic.
-     *
-     * @param topic The topic name.
-     * @example
-     * ws.subscribe("chat");
-     */
-    subscribe(topic: string): void;
-
-    /**
-     * Unsubscribes a client to the topic.
-     *
-     * @param topic The topic name.
-     * @example
-     * ws.unsubscribe("chat");
-     */
-    unsubscribe(topic: string): void;
-
-    /**
-     * Is the client subscribed to a topic?
-     *
-     * @param topic The topic name.
-     * @example
-     * ws.subscribe("chat");
-     * console.log(ws.isSubscribed("chat")); // true
-     */
-    isSubscribed(topic: string): boolean;
-
-    /**
-     * Batches `send()` and `publish()` operations, which makes it faster to send data.
-     *
-     * The `message`, `open`, and `drain` callbacks are automatically corked, so
-     * you only need to call this if you are sending messages outside of those
-     * callbacks or in async functions.
-     *
-     * @param callback The callback to run.
-     * @example
-     * ws.cork((ctx) => {
-     *   ctx.send("These messages");
-     *   ctx.sendText("are sent");
-     *   ctx.sendBinary(new TextEncoder().encode("together!"));
-     * });
-     */
-    cork<T = unknown>(callback: (ws: ServerWebSocket<T>) => T): T;
-
-    /**
-     * The IP address of the client.
-     *
-     * @example
-     * console.log(socket.remoteAddress); // "127.0.0.1"
-     */
-    readonly remoteAddress: string;
-
-    /**
-     * The ready state of the client.
-     *
-     * - if `0`, the client is connecting.
-     * - if `1`, the client is connected.
-     * - if `2`, the client is closing.
-     * - if `3`, the client is closed.
-     *
-     * @example
-     * console.log(socket.readyState); // 1
-     */
-    readonly readyState: WebSocketReadyState;
-
-    /**
-     * Sets how binary data is returned in events.
-     *
-     * - if `nodebuffer`, binary data is returned as `Buffer` objects. **(default)**
-     * - if `arraybuffer`, binary data is returned as `ArrayBuffer` objects.
-     * - if `uint8array`, binary data is returned as `Uint8Array` objects.
-     *
-     * @example
-     * let ws: WebSocket;
-     * ws.binaryType = "uint8array";
-     * ws.addEventListener("message", ({ data }) => {
-     *   console.log(data instanceof Uint8Array); // true
-     * });
-     */
-    binaryType?: "nodebuffer" | "arraybuffer" | "uint8array";
-
-    /**
-     * Custom data that you can assign to a client, can be read and written at any time.
-     *
-     * @example
-     * import { serve } from "bun";
-     *
-     * serve({
-     *   fetch(request, server) {
-     *     const data = {
-     *       accessToken: request.headers.get("Authorization"),
-     *     };
-     *     if (server.upgrade(request, { data })) {
-     *       return;
-     *     }
-     *     return new Response();
-     *   },
-     *   websocket: {
-     *     open(ws) {
-     *       console.log(ws.data.accessToken);
-     *     }
-     *   }
-     * });
-     */
-    data: T;
-
-    getBufferedAmount(): number;
+  interface ErrorLike extends Error {
+    code?: string;
+    errno?: number;
+    syscall?: string;
   }
 
   /**
-   * Compression options for WebSocket messages.
-   */
-  type WebSocketCompressor =
-    | "disable"
-    | "shared"
-    | "dedicated"
-    | "3KB"
-    | "4KB"
-    | "8KB"
-    | "16KB"
-    | "32KB"
-    | "64KB"
-    | "128KB"
-    | "256KB";
-
-  /**
-   * Create a server-side {@link ServerWebSocket} handler for use with {@link Bun.serve}
-   *
-   * @category HTTP & Networking
-   *
-   * @example
-   * ```ts
-   * import { websocket, serve } from "bun";
-   *
-   * serve<{name: string}>({
-   *   port: 3000,
-   *   websocket: {
-   *     open: (ws) => {
-   *       console.log("Client connected");
-   *    },
-   *     message: (ws, message) => {
-   *       console.log(`${ws.data.name}: ${message}`);
-   *    },
-   *     close: (ws) => {
-   *       console.log("Client disconnected");
-   *    },
-   *  },
-   *
-   *   fetch(req, server) {
-   *     const url = new URL(req.url);
-   *     if (url.pathname === "/chat") {
-   *       const upgraded = server.upgrade(req, {
-   *         data: {
-   *           name: new URL(req.url).searchParams.get("name"),
-   *        },
-   *      });
-   *       if (!upgraded) {
-   *         return new Response("Upgrade failed", { status: 400 });
-   *      }
-   *      return;
-   *    }
-   *     return new Response("Hello World");
-   *  },
-   * });
-   * ```
+   * Options for TLS connections
    */
-  interface WebSocketHandler<T = undefined> {
-    /**
-     * Called when the server receives an incoming message.
-     *
-     * If the message is not a `string`, its type is based on the value of `binaryType`.
-     * - if `nodebuffer`, then the message is a `Buffer`.
-     * - if `arraybuffer`, then the message is an `ArrayBuffer`.
-     * - if `uint8array`, then the message is a `Uint8Array`.
-     *
-     * @param ws The websocket that sent the message
-     * @param message The message received
-     */
-    message(ws: ServerWebSocket<T>, message: string | Buffer): void | Promise<void>;
-
-    /**
-     * Called when a connection is opened.
-     *
-     * @param ws The websocket that was opened
-     */
-    open?(ws: ServerWebSocket<T>): void | Promise<void>;
-
-    /**
-     * Called when a connection was previously under backpressure,
-     * meaning it had too many queued messages, but is now ready to receive more data.
-     *
-     * @param ws The websocket that is ready for more data
-     */
-    drain?(ws: ServerWebSocket<T>): void | Promise<void>;
-
+  interface TLSOptions {
     /**
-     * Called when a connection is closed.
-     *
-     * @param ws The websocket that was closed
-     * @param code The close code
-     * @param reason The close reason
+     * Passphrase for the TLS key
      */
-    close?(ws: ServerWebSocket<T>, code: number, reason: string): void | Promise<void>;
+    passphrase?: string;
 
     /**
-     * Called when a ping is sent.
-     *
-     * @param ws The websocket that received the ping
-     * @param data The data sent with the ping
+     * File path to a .pem file custom Diffie Helman parameters
      */
-    ping?(ws: ServerWebSocket<T>, data: Buffer): void | Promise<void>;
+    dhParamsFile?: string;
 
     /**
-     * Called when a pong is received.
-     *
-     * @param ws The websocket that received the ping
-     * @param data The data sent with the ping
+     * Explicitly set a server name
      */
-    pong?(ws: ServerWebSocket<T>, data: Buffer): void | Promise<void>;
+    serverName?: string;
 
     /**
-     * Sets the maximum size of messages in bytes.
-     *
-     * Default is 16 MB, or `1024 * 1024 * 16` in bytes.
+     * This sets `OPENSSL_RELEASE_BUFFERS` to 1.
+     * It reduces overall performance but saves some memory.
+     * @default false
      */
-    maxPayloadLength?: number;
+    lowMemoryMode?: boolean;
 
     /**
-     * Sets the maximum number of bytes that can be buffered on a single connection.
-     *
-     * Default is 16 MB, or `1024 * 1024 * 16` in bytes.
+     * If set to `false`, any certificate is accepted.
+     * Default is `$NODE_TLS_REJECT_UNAUTHORIZED` environment variable, or `true` if it is not set.
      */
-    backpressureLimit?: number;
+    rejectUnauthorized?: boolean;
 
     /**
-     * Sets if the connection should be closed if `backpressureLimit` is reached.
+     * If set to `true`, the server will request a client certificate.
      *
      * Default is `false`.
      */
-    closeOnBackpressureLimit?: boolean;
+    requestCert?: boolean;
 
     /**
-     * Sets the the number of seconds to wait before timing out a connection
-     * due to no messages or pings.
-     *
-     * Default is 2 minutes, or `120` in seconds.
+     * Optionally override the trusted CA certificates. Default is to trust
+     * the well-known CAs curated by Mozilla. Mozilla's CAs are completely
+     * replaced when CAs are explicitly specified using this option.
      */
-    idleTimeout?: number;
-
+    ca?: string | BufferSource | BunFile | Array<string | BufferSource | BunFile> | undefined;
     /**
-     * Should `ws.publish()` also send a message to `ws` (itself), if it is subscribed?
-     *
-     * Default is `false`.
+     *  Cert chains in PEM format. One cert chain should be provided per
+     *  private key. Each cert chain should consist of the PEM formatted
+     *  certificate for a provided private key, followed by the PEM
+     *  formatted intermediate certificates (if any), in order, and not
+     *  including the root CA (the root CA must be pre-known to the peer,
+     *  see ca). When providing multiple cert chains, they do not have to
+     *  be in the same order as their private keys in key. If the
+     *  intermediate certificates are not provided, the peer will not be
+     *  able to validate the certificate, and the handshake will fail.
      */
-    publishToSelf?: boolean;
-
+    cert?: string | BufferSource | BunFile | Array<string | BufferSource | BunFile> | undefined;
     /**
-     * Should the server automatically send and respond to pings to clients?
-     *
-     * Default is `true`.
+     * Private keys in PEM format. PEM allows the option of private keys
+     * being encrypted. Encrypted keys will be decrypted with
+     * options.passphrase. Multiple keys using different algorithms can be
+     * provided either as an array of unencrypted key strings or buffers,
+     * or an array of objects in the form {pem: <string|buffer>[,
+     * passphrase: <string>]}. The object form can only occur in an array.
+     * object.passphrase is optional. Encrypted keys will be decrypted with
+     * object.passphrase if provided, or options.passphrase if it is not.
      */
-    sendPings?: boolean;
-
+    key?: string | BufferSource | BunFile | Array<string | BufferSource | BunFile> | undefined;
     /**
-     * Sets the compression level for messages, for clients that supports it. By default, compression is disabled.
-     *
-     * Default is `false`.
+     * Optionally affect the OpenSSL protocol behavior, which is not
+     * usually necessary. This should be used carefully if at all! Value is
+     * a numeric bitmask of the SSL_OP_* options from OpenSSL Options
      */
-    perMessageDeflate?:
-      | boolean
-      | {
-          /**
-           * Sets the compression level.
-           */
-          compress?: WebSocketCompressor | boolean;
-          /**
-           * Sets the decompression level.
-           */
-          decompress?: WebSocketCompressor | boolean;
-        };
-  }
-
-  namespace RouterTypes {
-    type ExtractRouteParams<T> = T extends `${string}:${infer Param}/${infer Rest}`
-      ? { [K in Param]: string } & ExtractRouteParams<Rest>
-      : T extends `${string}:${infer Param}`
-        ? { [K in Param]: string }
-        : T extends `${string}*`
-          ? {}
-          : {};
-
-    type RouteHandler<T extends string> = (req: BunRequest<T>, server: Server) => Response | Promise<Response>;
-
-    type RouteHandlerWithWebSocketUpgrade<T extends string> = (
-      req: BunRequest<T>,
-      server: Server,
-    ) => Response | undefined | void | Promise<Response | undefined | void>;
-
-    type HTTPMethod = "GET" | "POST" | "PUT" | "DELETE" | "PATCH" | "HEAD" | "OPTIONS";
-
-    type RouteHandlerObject<T extends string> = {
-      [K in HTTPMethod]?: RouteHandler<T>;
-    };
+    secureOptions?: number | undefined; // Value is a numeric bitmask of the `SSL_OP_*` options
 
-    type RouteHandlerWithWebSocketUpgradeObject<T extends string> = {
-      [K in HTTPMethod]?: RouteHandlerWithWebSocketUpgrade<T>;
-    };
+    ALPNProtocols?: string | BufferSource;
 
-    type RouteValue<T extends string> =
-      | Response
-      | false
-      | RouteHandler<T>
-      | RouteHandlerObject<T>
-      | HTMLBundle
-      | BunFile;
-    type RouteValueWithWebSocketUpgrade<T extends string> =
-      | RouteValue<T>
-      | RouteHandlerWithWebSocketUpgrade<T>
-      | RouteHandlerWithWebSocketUpgradeObject<T>;
-  }
+    ciphers?: string;
 
-  interface BunRequest<T extends string = string> extends Request {
-    params: RouterTypes.ExtractRouteParams<T>;
-    readonly cookies: CookieMap;
+    clientRenegotiationLimit?: number;
 
-    clone(): BunRequest<T>;
+    clientRenegotiationWindow?: number;
   }
 
-  interface GenericServeOptions {
+  interface SocketAddress {
     /**
-     * What URI should be used to make {@link Request.url} absolute?
-     *
-     * By default, looks at {@link hostname}, {@link port}, and whether or not SSL is enabled to generate one
-     *
-     * @example
-     * ```js
-     * "http://my-app.com"
-     * ```
-     *
-     * @example
-     * ```js
-     * "https://wongmjane.com/"
-     * ```
-     *
-     * This should be the public, absolute URL – include the protocol and {@link hostname}. If the port isn't 80 or 443, then include the {@link port} too.
-     *
-     * @example
-     * "http://localhost:3000"
+     * The IP address of the client.
      */
-    // baseURI?: string;
+    address: string;
 
     /**
-     * What is the maximum size of a request body? (in bytes)
-     * @default 1024 * 1024 * 128 // 128MB
+     * The port of the client.
      */
-    maxRequestBodySize?: number;
+    port: number;
 
     /**
-     * Render contextual errors? This enables bun's error page
-     * @default process.env.NODE_ENV !== 'production'
-     */
-    development?:
-      | boolean
-      | {
-          /**
-           * Enable Hot Module Replacement for routes (including React Fast Refresh, if React is in use)
-           *
-           * @default true if process.env.NODE_ENV !== 'production'
-           *
-           */
-          hmr?: boolean;
-
-          /**
-           * Enable console log streaming from browser to server
-           * @default false
-           */
-          console?: boolean;
-
-          /**
-           * Enable automatic workspace folders for Chrome DevTools
-           *
-           * This lets you persistently edit files in the browser. It works by adding the following route to the server:
-           * `/.well-known/appspecific/com.chrome.devtools.json`
-           *
-           * The response is a JSON object with the following shape:
-           * ```json
-           * {
-           *   "workspace": {
-           *     "root": "<cwd>",
-           *     "uuid": "<uuid>"
-           *   }
-           * }
-           * ```
-           *
-           * The `root` field is the current working directory of the server.
-           * The `"uuid"` field is a hash of the file that started the server and a hash of the current working directory.
-           *
-           * For security reasons, if the remote socket address is not from localhost, 127.0.0.1, or ::1, the request is ignored.
-           * @default true
-           */
-          chromeDevToolsAutomaticWorkspaceFolders?: boolean;
-        };
-
-    error?: (this: Server, error: ErrorLike) => Response | Promise<Response> | void | Promise<void>;
-
-    /**
-     * Uniquely identify a server instance with an ID
-     *
-     * ---
-     *
-     * **When bun is started with the `--hot` flag**:
-     *
-     * This string will be used to hot reload the server without interrupting
-     * pending requests or websockets. If not provided, a value will be
-     * generated. To disable hot reloading, set this value to `null`.
-     *
-     * **When bun is not started with the `--hot` flag**:
-     *
-     * This string will currently do nothing. But in the future it could be useful for logs or metrics.
-     */
-    id?: string | null;
-  }
-
-  interface ServeOptions extends GenericServeOptions {
-    /**
-     * What port should the server listen on?
-     * @default process.env.PORT || "3000"
-     */
-    port?: string | number;
-
-    /**
-     * Whether the `SO_REUSEPORT` flag should be set.
-     *
-     * This allows multiple processes to bind to the same port, which is useful for load balancing.
-     *
-     * @default false
-     */
-    reusePort?: boolean;
-
-    /**
-     * Whether the `IPV6_V6ONLY` flag should be set.
-     * @default false
-     */
-    ipv6Only?: boolean;
-
-    /**
-     * What hostname should the server listen on?
-     *
-     * @default
-     * ```js
-     * "0.0.0.0" // listen on all interfaces
-     * ```
-     * @example
-     *  ```js
-     * "127.0.0.1" // Only listen locally
-     * ```
-     * @example
-     * ```js
-     * "remix.run" // Only listen on remix.run
-     * ````
-     *
-     * note: hostname should not include a {@link port}
-     */
-    hostname?: string;
-
-    /**
-     * If set, the HTTP server will listen on a unix socket instead of a port.
-     * (Cannot use unix with port + hostname)
-     */
-    unix?: never;
-
-    /**
-     * Sets the the number of seconds to wait before timing out a connection
-     * due to inactivity.
-     *
-     * Default is `10` seconds.
-     */
-    idleTimeout?: number;
-
-    /**
-     * Handle HTTP requests
-     *
-     * Respond to {@link Request} objects with a {@link Response} object.
-     */
-    fetch(this: Server, request: Request, server: Server): Response | Promise<Response>;
-  }
-
-  interface UnixServeOptions extends GenericServeOptions {
-    /**
-     * If set, the HTTP server will listen on a unix socket instead of a port.
-     */
-    unix: string;
-
-    /**
-     * If set, the HTTP server will listen on this port
-     * (Cannot use port with unix)
-     */
-    port?: never;
-
-    /**
-     * If set, the HTTP server will listen on this hostname
-     * (Cannot use hostname with unix)
-     */
-    hostname?: never;
-
-    /**
-     * Handle HTTP requests
-     *
-     * Respond to {@link Request} objects with a {@link Response} object.
-     */
-    fetch(this: Server, request: Request, server: Server): Response | Promise<Response>;
-  }
-
-  interface WebSocketServeOptions<WebSocketDataType = undefined> extends GenericServeOptions {
-    /**
-     * What port should the server listen on?
-     * @default process.env.PORT || "3000"
-     */
-    port?: string | number;
-
-    /**
-     * What hostname should the server listen on?
-     *
-     * @default
-     * ```js
-     * "0.0.0.0" // listen on all interfaces
-     * ```
-     * @example
-     *  ```js
-     * "127.0.0.1" // Only listen locally
-     * ```
-     * @example
-     * ```js
-     * "remix.run" // Only listen on remix.run
-     * ````
-     *
-     * note: hostname should not include a {@link port}
-     */
-    hostname?: string;
-
-    /**
-     * Enable websockets with {@link Bun.serve}
-     *
-     * For simpler type safety, see {@link Bun.websocket}
-     *
-     * @example
-     * ```js
-     * Bun.serve({
-     *  websocket: {
-     *    open: (ws) => {
-     *      console.log("Client connected");
-     *    },
-     *    message: (ws, message) => {
-     *      console.log("Client sent message", message);
-     *    },
-     *    close: (ws) => {
-     *      console.log("Client disconnected");
-     *    },
-     *  },
-     *  fetch(req, server) {
-     *    const url = new URL(req.url);
-     *    if (url.pathname === "/chat") {
-     *      const upgraded = server.upgrade(req);
-     *      if (!upgraded) {
-     *        return new Response("Upgrade failed", { status: 400 });
-     *      }
-     *    }
-     *    return new Response("Hello World");
-     *  },
-     * });
-     * ```
-     * Upgrade a {@link Request} to a {@link ServerWebSocket} via {@link Server.upgrade}
-     *
-     * Pass `data` in @{link Server.upgrade} to attach data to the {@link ServerWebSocket.data} property
-     */
-    websocket: WebSocketHandler<WebSocketDataType>;
-
-    /**
-     * Handle HTTP requests or upgrade them to a {@link ServerWebSocket}
-     *
-     * Respond to {@link Request} objects with a {@link Response} object.
-     */
-    fetch(
-      this: Server,
-      request: Request,
-      server: Server,
-    ): Response | undefined | void | Promise<Response | undefined | void>;
-  }
-
-  interface UnixWebSocketServeOptions<WebSocketDataType = undefined> extends GenericServeOptions {
-    /**
-     * If set, the HTTP server will listen on a unix socket instead of a port.
-     * (Cannot be used with hostname+port)
-     */
-    unix: string;
-
-    /**
-     * Enable websockets with {@link Bun.serve}
-     *
-     * For simpler type safety, see {@link Bun.websocket}
-     *
-     * @example
-     * ```js
-     * import { serve } from "bun";
-     * serve({
-     *  websocket: {
-     *    open: (ws) => {
-     *      console.log("Client connected");
-     *    },
-     *    message: (ws, message) => {
-     *      console.log("Client sent message", message);
-     *    },
-     *    close: (ws) => {
-     *      console.log("Client disconnected");
-     *    },
-     *  },
-     *  fetch(req, server) {
-     *    const url = new URL(req.url);
-     *    if (url.pathname === "/chat") {
-     *      const upgraded = server.upgrade(req);
-     *      if (!upgraded) {
-     *        return new Response("Upgrade failed", { status: 400 });
-     *      }
-     *    }
-     *    return new Response("Hello World");
-     *  },
-     * });
-     * ```
-     * Upgrade a {@link Request} to a {@link ServerWebSocket} via {@link Server.upgrade}
-     *
-     * Pass `data` in @{link Server.upgrade} to attach data to the {@link ServerWebSocket.data} property
-     */
-    websocket: WebSocketHandler<WebSocketDataType>;
-
-    /**
-     * Handle HTTP requests or upgrade them to a {@link ServerWebSocket}
-     *
-     * Respond to {@link Request} objects with a {@link Response} object.
-     */
-    fetch(this: Server, request: Request, server: Server): Response | undefined | Promise<Response | undefined>;
-  }
-
-  interface TLSWebSocketServeOptions<WebSocketDataType = undefined>
-    extends WebSocketServeOptions<WebSocketDataType>,
-      TLSOptionsAsDeprecated {
-    unix?: never;
-    tls?: TLSOptions | TLSOptions[];
-  }
-
-  interface UnixTLSWebSocketServeOptions<WebSocketDataType = undefined>
-    extends UnixWebSocketServeOptions<WebSocketDataType>,
-      TLSOptionsAsDeprecated {
-    /**
-     * If set, the HTTP server will listen on a unix socket instead of a port.
-     * (Cannot be used with hostname+port)
-     */
-    unix: string;
-    tls?: TLSOptions | TLSOptions[];
-  }
-
-  interface TLSServeOptions extends ServeOptions, TLSOptionsAsDeprecated {
-    tls?: TLSOptions | TLSOptions[];
-  }
-
-  interface UnixTLSServeOptions extends UnixServeOptions, TLSOptionsAsDeprecated {
-    tls?: TLSOptions | TLSOptions[];
-  }
-
-  interface ErrorLike extends Error {
-    code?: string;
-    errno?: number;
-    syscall?: string;
-  }
-
-  /**
-   * Options for TLS connections
-   */
-  interface TLSOptions {
-    /**
-     * Passphrase for the TLS key
-     */
-    passphrase?: string;
-
-    /**
-     * File path to a .pem file custom Diffie Helman parameters
-     */
-    dhParamsFile?: string;
-
-    /**
-     * Explicitly set a server name
-     */
-    serverName?: string;
-
-    /**
-     * This sets `OPENSSL_RELEASE_BUFFERS` to 1.
-     * It reduces overall performance but saves some memory.
-     * @default false
-     */
-    lowMemoryMode?: boolean;
-
-    /**
-     * If set to `false`, any certificate is accepted.
-     * Default is `$NODE_TLS_REJECT_UNAUTHORIZED` environment variable, or `true` if it is not set.
-     */
-    rejectUnauthorized?: boolean;
-
-    /**
-     * If set to `true`, the server will request a client certificate.
-     *
-     * Default is `false`.
-     */
-    requestCert?: boolean;
-
-    /**
-     * Optionally override the trusted CA certificates. Default is to trust
-     * the well-known CAs curated by Mozilla. Mozilla's CAs are completely
-     * replaced when CAs are explicitly specified using this option.
-     */
-    ca?: string | BufferSource | BunFile | Array<string | BufferSource | BunFile> | undefined;
-    /**
-     *  Cert chains in PEM format. One cert chain should be provided per
-     *  private key. Each cert chain should consist of the PEM formatted
-     *  certificate for a provided private key, followed by the PEM
-     *  formatted intermediate certificates (if any), in order, and not
-     *  including the root CA (the root CA must be pre-known to the peer,
-     *  see ca). When providing multiple cert chains, they do not have to
-     *  be in the same order as their private keys in key. If the
-     *  intermediate certificates are not provided, the peer will not be
-     *  able to validate the certificate, and the handshake will fail.
-     */
-    cert?: string | BufferSource | BunFile | Array<string | BufferSource | BunFile> | undefined;
-    /**
-     * Private keys in PEM format. PEM allows the option of private keys
-     * being encrypted. Encrypted keys will be decrypted with
-     * options.passphrase. Multiple keys using different algorithms can be
-     * provided either as an array of unencrypted key strings or buffers,
-     * or an array of objects in the form {pem: <string|buffer>[,
-     * passphrase: <string>]}. The object form can only occur in an array.
-     * object.passphrase is optional. Encrypted keys will be decrypted with
-     * object.passphrase if provided, or options.passphrase if it is not.
-     */
-    key?: string | BufferSource | BunFile | Array<string | BufferSource | BunFile> | undefined;
-    /**
-     * Optionally affect the OpenSSL protocol behavior, which is not
-     * usually necessary. This should be used carefully if at all! Value is
-     * a numeric bitmask of the SSL_OP_* options from OpenSSL Options
-     */
-    secureOptions?: number | undefined; // Value is a numeric bitmask of the `SSL_OP_*` options
-
-    ALPNProtocols?: string | BufferSource;
-
-    ciphers?: string;
-
-    clientRenegotiationLimit?: number;
-
-    clientRenegotiationWindow?: number;
-  }
-
-  // Note for contributors: TLSOptionsAsDeprecated should be considered immutable
-  // and new TLS option keys should only be supported on the `.tls` property (which comes
-  // from the TLSOptions interface above).
-  /**
-   * This exists because Bun.serve() extends the TLSOptions object, but
-   * they're now considered deprecated. You should be passing the
-   * options on `.tls` instead.
-   *
-   * @example
-   * ```ts
-   * //// OLD ////
-   * Bun.serve({
-   *   fetch: () => new Response("Hello World"),
-   *   passphrase: "secret",
-   * });
-   *
-   * //// NEW ////
-   * Bun.serve({
-   *   fetch: () => new Response("Hello World"),
-   *   tls: {
-   *     passphrase: "secret",
-   *   },
-   * });
-   * ```
-   */
-  interface TLSOptionsAsDeprecated {
-    /**
-     * Passphrase for the TLS key
-     *
-     * @deprecated Use `.tls.passphrase` instead
-     */
-    passphrase?: string;
-
-    /**
-     * File path to a .pem file custom Diffie Helman parameters
-     *
-     * @deprecated Use `.tls.dhParamsFile` instead
-     */
-    dhParamsFile?: string;
-
-    /**
-     * Explicitly set a server name
-     *
-     * @deprecated Use `.tls.serverName` instead
-     */
-    serverName?: string;
-
-    /**
-     * This sets `OPENSSL_RELEASE_BUFFERS` to 1.
-     * It reduces overall performance but saves some memory.
-     * @default false
-     *
-     * @deprecated Use `.tls.lowMemoryMode` instead
-     */
-    lowMemoryMode?: boolean;
-
-    /**
-     * If set to `false`, any certificate is accepted.
-     * Default is `$NODE_TLS_REJECT_UNAUTHORIZED` environment variable, or `true` if it is not set.
-     *
-     * @deprecated Use `.tls.rejectUnauthorized` instead
-     */
-    rejectUnauthorized?: boolean;
-
-    /**
-     * If set to `true`, the server will request a client certificate.
-     *
-     * Default is `false`.
-     *
-     * @deprecated Use `.tls.requestCert` instead
-     */
-    requestCert?: boolean;
-
-    /**
-     * Optionally override the trusted CA certificates. Default is to trust
-     * the well-known CAs curated by Mozilla. Mozilla's CAs are completely
-     * replaced when CAs are explicitly specified using this option.
-     *
-     * @deprecated Use `.tls.ca` instead
-     */
-    ca?: string | Buffer | BunFile | Array<string | Buffer | BunFile> | undefined;
-    /**
-     *  Cert chains in PEM format. One cert chain should be provided per
-     *  private key. Each cert chain should consist of the PEM formatted
-     *  certificate for a provided private key, followed by the PEM
-     *  formatted intermediate certificates (if any), in order, and not
-     *  including the root CA (the root CA must be pre-known to the peer,
-     *  see ca). When providing multiple cert chains, they do not have to
-     *  be in the same order as their private keys in key. If the
-     *  intermediate certificates are not provided, the peer will not be
-     *  able to validate the certificate, and the handshake will fail.
-     *
-     * @deprecated Use `.tls.cert` instead
-     */
-    cert?: string | Buffer | BunFile | Array<string | Buffer | BunFile> | undefined;
-    /**
-     * Private keys in PEM format. PEM allows the option of private keys
-     * being encrypted. Encrypted keys will be decrypted with
-     * options.passphrase. Multiple keys using different algorithms can be
-     * provided either as an array of unencrypted key strings or buffers,
-     * or an array of objects in the form {pem: <string|buffer>[,
-     * passphrase: <string>]}. The object form can only occur in an array.
-     * object.passphrase is optional. Encrypted keys will be decrypted with
-     * object.passphrase if provided, or options.passphrase if it is not.
-     *
-     * @deprecated Use `.tls.key` instead
-     */
-    key?: string | Buffer | BunFile | Array<string | Buffer | BunFile> | undefined;
-    /**
-     * Optionally affect the OpenSSL protocol behavior, which is not
-     * usually necessary. This should be used carefully if at all! Value is
-     * a numeric bitmask of the SSL_OP_* options from OpenSSL Options
-     *
-     * @deprecated `Use .tls.secureOptions` instead
-     */
-    secureOptions?: number | undefined; // Value is a numeric bitmask of the `SSL_OP_*` options
-  }
-
-  interface SocketAddress {
-    /**
-     * The IP address of the client.
-     */
-    address: string;
-    /**
-     * The port of the client.
-     */
-    port: number;
-    /**
-     * The IP family ("IPv4" or "IPv6").
+     * The IP family ("IPv4" or "IPv6").
      */
     family: "IPv4" | "IPv6";
   }
 
-  /**
-   * HTTP & HTTPS Server
-   *
-   * To start the server, see {@link serve}
-   *
-   * For performance, Bun pre-allocates most of the data for 2048 concurrent requests.
-   * That means starting a new server allocates about 500 KB of memory. Try to
-   * avoid starting and stopping the server often (unless it's a new instance of bun).
-   *
-   * Powered by a fork of [uWebSockets](https://github.com/uNetworking/uWebSockets). Thank you \@alexhultman.
-   *
-   * @category HTTP & Networking
-   */
-  interface Server extends Disposable {
-    /*
-     * Closes all connections connected to this server which are not sending a request or waiting for a response. Does not close the listen socket.
-     */
-    closeIdleConnections(): void;
-
-    /**
-     * Stop listening to prevent new connections from being accepted.
-     *
-     * By default, it does not cancel in-flight requests or websockets. That means it may take some time before all network activity stops.
-     *
-     * @param closeActiveConnections Immediately terminate in-flight requests, websockets, and stop accepting new connections.
-     * @default false
-     */
-    stop(closeActiveConnections?: boolean): Promise<void>;
-
-    /**
-     * Update the `fetch` and `error` handlers without restarting the server.
-     *
-     * This is useful if you want to change the behavior of your server without
-     * restarting it or for hot reloading.
-     *
-     * @example
-     *
-     * ```js
-     * // create the server
-     * const server = Bun.serve({
-     *  fetch(request) {
-     *    return new Response("Hello World v1")
-     *  }
-     * });
-     *
-     * // Update the server to return a different response
-     * server.reload({
-     *   fetch(request) {
-     *     return new Response("Hello World v2")
-     *   }
-     * });
-     * ```
-     *
-     * Passing other options such as `port` or `hostname` won't do anything.
-     */
-    reload<T, R extends { [K in keyof R]: RouterTypes.RouteValue<K & string> }>(
-      options: ServeFunctionOptions<T, R> & {
-        /**
-         * @deprecated Use `routes` instead in new code. This will continue to work for awhile though.
-         */
-        static?: R;
-      },
-    ): Server;
-
-    /**
-     * Mock the fetch handler for a running server.
-     *
-     * This feature is not fully implemented yet. It doesn't normalize URLs
-     * consistently in all cases and it doesn't yet call the `error` handler
-     * consistently. This needs to be fixed
-     */
-    fetch(request: Request | string): Response | Promise<Response>;
-
-    /**
-     * Upgrade a {@link Request} to a {@link ServerWebSocket}
-     *
-     * @param request The {@link Request} to upgrade
-     * @param options Pass headers or attach data to the {@link ServerWebSocket}
-     *
-     * @returns `true` if the upgrade was successful and `false` if it failed
-     *
-     * @example
-     * ```js
-     * import { serve } from "bun";
-     *  serve({
-     *    websocket: {
-     *      open: (ws) => {
-     *        console.log("Client connected");
-     *      },
-     *      message: (ws, message) => {
-     *        console.log("Client sent message", message);
-     *      },
-     *      close: (ws) => {
-     *        console.log("Client disconnected");
-     *      },
-     *    },
-     *    fetch(req, server) {
-     *      const url = new URL(req.url);
-     *      if (url.pathname === "/chat") {
-     *        const upgraded = server.upgrade(req);
-     *        if (!upgraded) {
-     *          return new Response("Upgrade failed", { status: 400 });
-     *        }
-     *      }
-     *      return new Response("Hello World");
-     *    },
-     *  });
-     * ```
-     *  What you pass to `data` is available on the {@link ServerWebSocket.data} property
-     */
-    // eslint-disable-next-line @definitelytyped/no-unnecessary-generics
-    upgrade<T = undefined>(
-      request: Request,
-      options?: {
-        /**
-         * Send any additional headers while upgrading, like cookies
-         */
-        headers?: HeadersInit;
-        /**
-         * This value is passed to the {@link ServerWebSocket.data} property
-         */
-        data?: T;
-      },
-    ): boolean;
-
-    /**
-     * Send a message to all connected {@link ServerWebSocket} subscribed to a topic
-     *
-     * @param topic The topic to publish to
-     * @param data The data to send
-     * @param compress Should the data be compressed? Ignored if the client does not support compression.
-     *
-     * @returns 0 if the message was dropped, -1 if backpressure was applied, or the number of bytes sent.
-     *
-     * @example
-     *
-     * ```js
-     * server.publish("chat", "Hello World");
-     * ```
-     *
-     * @example
-     * ```js
-     * server.publish("chat", new Uint8Array([1, 2, 3, 4]));
-     * ```
-     *
-     * @example
-     * ```js
-     * server.publish("chat", new ArrayBuffer(4), true);
-     * ```
-     *
-     * @example
-     * ```js
-     * server.publish("chat", new DataView(new ArrayBuffer(4)));
-     * ```
-     */
-    publish(
-      topic: string,
-      data: string | ArrayBufferView | ArrayBuffer | SharedArrayBuffer,
-      compress?: boolean,
-    ): ServerWebSocketSendStatus;
-
-    /**
-     * A count of connections subscribed to a given topic
-     *
-     * This operation will loop through each topic internally to get the count.
-     *
-     * @param topic the websocket topic to check how many subscribers are connected to
-     * @returns the number of subscribers
-     */
-    subscriberCount(topic: string): number;
-
-    /**
-     * Returns the client IP address and port of the given Request. If the request was closed or is a unix socket, returns null.
-     *
-     * @example
-     * ```js
-     * export default {
-     *  async fetch(request, server) {
-     *    return new Response(server.requestIP(request));
-     *  }
-     * }
-     * ```
-     */
-    requestIP(request: Request): SocketAddress | null;
-
-    /**
-     * Reset the idleTimeout of the given Request to the number in seconds. 0 means no timeout.
-     *
-     * @example
-     * ```js
-     * export default {
-     *  async fetch(request, server) {
-     *    server.timeout(request, 60);
-     *    await Bun.sleep(30000);
-     *    return new Response("30 seconds have passed");
-     *  }
-     * }
-     * ```
-     */
-    timeout(request: Request, seconds: number): void;
-    /**
-     * Undo a call to {@link Server.unref}
-     *
-     * If the Server has already been stopped, this does nothing.
-     *
-     * If {@link Server.ref} is called multiple times, this does nothing. Think of it as a boolean toggle.
-     */
-    ref(): void;
-
-    /**
-     * Don't keep the process alive if this server is the only thing left.
-     * Active connections may continue to keep the process alive.
-     *
-     * By default, the server is ref'd.
-     *
-     * To prevent new connections from being accepted, use {@link Server.stop}
-     */
-    unref(): void;
-
-    /**
-     * How many requests are in-flight right now?
-     */
-    readonly pendingRequests: number;
-
-    /**
-     * How many {@link ServerWebSocket}s are in-flight right now?
-     */
-    readonly pendingWebSockets: number;
-
-    readonly url: URL;
-
-    /**
-     * The port the server is listening on.
-     *
-     * This will be undefined when the server is listening on a unix socket.
-     *
-     * @example
-     * ```js
-     * 3000
-     * ```
-     */
-    readonly port: number | undefined;
-
-    /**
-     * The hostname the server is listening on. Does not include the port.
-     *
-     * This will be `undefined` when the server is listening on a unix socket.
-     *
-     * @example
-     * ```js
-     * "localhost"
-     * ```
-     */
-    readonly hostname: string | undefined;
-
-    /**
-     * Is the server running in development mode?
-     *
-     * In development mode, `Bun.serve()` returns rendered error messages with
-     * stack traces instead of a generic 500 error. This makes debugging easier,
-     * but development mode shouldn't be used in production or you will risk
-     * leaking sensitive information.
-     */
-    readonly development: boolean;
-
-    /**
-     * An identifier of the server instance
-     *
-     * When bun is started with the `--hot` flag, this ID is used to hot reload the server without interrupting pending requests or websockets.
-     *
-     * When bun is not started with the `--hot` flag, this ID is currently unused.
-     */
-    readonly id: string;
-  }
-
-  /**
-   * The type of options that can be passed to {@link serve}
-   */
-  type Serve<WebSocketDataType = undefined> =
-    | ServeOptions
-    | TLSServeOptions
-    | UnixServeOptions
-    | UnixTLSServeOptions
-    | WebSocketServeOptions<WebSocketDataType>
-    | TLSWebSocketServeOptions<WebSocketDataType>
-    | UnixWebSocketServeOptions<WebSocketDataType>
-    | UnixTLSWebSocketServeOptions<WebSocketDataType>;
-
-  /**
-   * The type of options that can be passed to {@link serve}, with support for `routes` and a safer requirement for `fetch`
-   */
-  type ServeFunctionOptions<T, R extends { [K in keyof R]: RouterTypes.RouteValue<Extract<K, string>> }> =
-    | (__internal.DistributedOmit<Exclude<Serve<T>, WebSocketServeOptions<T>>, "fetch"> & {
-        routes: R;
-        fetch?: (this: Server, request: Request, server: Server) => Response | Promise<Response>;
-      })
-    | (__internal.DistributedOmit<Exclude<Serve<T>, WebSocketServeOptions<T>>, "routes"> & {
-        routes?: never;
-        fetch: (this: Server, request: Request, server: Server) => Response | Promise<Response>;
-      })
-    | (Omit<WebSocketServeOptions<T>, "fetch"> & {
-        routes: {
-          [K in keyof R]: RouterTypes.RouteValueWithWebSocketUpgrade<Extract<K, string>>;
-        };
-        fetch?: (
-          this: Server,
-          request: Request,
-          server: Server,
-        ) => Response | Promise<Response | void | undefined> | void | undefined;
-      })
-    | (Omit<WebSocketServeOptions<T>, "fetch"> & {
-        routes?: never;
-        fetch: (
-          this: Server,
-          request: Request,
-          server: Server,
-        ) => Response | Promise<Response | void | undefined> | void | undefined;
-      });
-
-  /**
-   * Bun.serve provides a high-performance HTTP server with built-in routing support.
-   * It enables both function-based and object-based route handlers with type-safe
-   * parameters and method-specific handling.
-   *
-   * @param options - Server configuration options
-   *
-   * @category HTTP & Networking
-   *
-   * @example Basic Usage
-   * ```ts
-   * Bun.serve({
-   *   port: 3000,
-   *   fetch(req) {
-   *     return new Response("Hello World");
-   *   }
-   * });
-   * ```
-   *
-   * @example Route-based Handlers
-   * ```ts
-   * Bun.serve({
-   *   routes: {
-   *     // Static responses
-   *     "/": new Response("Home page"),
-   *
-   *     // Function handlers with type-safe parameters
-   *     "/users/:id": (req) => {
-   *       // req.params.id is typed as string
-   *       return new Response(`User ${req.params.id}`);
-   *     },
-   *
-   *     // Method-specific handlers
-   *     "/api/posts": {
-   *       GET: () => new Response("Get posts"),
-   *       POST: async (req) => {
-   *         const body = await req.json();
-   *         return new Response("Created post");
-   *       },
-   *       DELETE: (req) => new Response("Deleted post")
-   *     },
-   *
-   *     // Wildcard routes
-   *     "/static/*": (req) => {
-   *       // Handle any path under /static/
-   *       return new Response("Static file");
-   *     },
-   *
-   *     // Disable route (fall through to fetch handler)
-   *     "/api/legacy": false
-   *   },
-   *
-   *   // Fallback handler for unmatched routes
-   *   fetch(req) {
-   *     return new Response("Not Found", { status: 404 });
-   *   }
-   * });
-   * ```
-   *
-   * @example Path Parameters
-   * ```ts
-   * Bun.serve({
-   *   routes: {
-   *     // Single parameter
-   *     "/users/:id": (req: BunRequest<"/users/:id">) => {
-   *       return new Response(`User ID: ${req.params.id}`);
-   *     },
-   *
-   *     // Multiple parameters
-   *     "/posts/:postId/comments/:commentId": (
-   *       req: BunRequest<"/posts/:postId/comments/:commentId">
-   *     ) => {
-   *       return new Response(JSON.stringify(req.params));
-   *       // Output: {"postId": "123", "commentId": "456"}
-   *     }
-   *   }
-   * });
-   * ```
-   *
-   * @example Route Precedence
-   * ```ts
-   * // Routes are matched in the following order:
-   * // 1. Exact static routes ("/about")
-   * // 2. Parameter routes ("/users/:id")
-   * // 3. Wildcard routes ("/api/*")
-   *
-   * Bun.serve({
-   *   routes: {
-   *     "/api/users": () => new Response("Users list"),
-   *     "/api/users/:id": (req) => new Response(`User ${req.params.id}`),
-   *     "/api/*": () => new Response("API catchall"),
-   *     "/*": () => new Response("Root catchall")
-   *   }
-   * });
-   * ```
-   *
-   * @example Error Handling
-   * ```ts
-   * Bun.serve({
-   *   routes: {
-   *     "/error": () => {
-   *       throw new Error("Something went wrong");
-   *     }
-   *   },
-   *   error(error) {
-   *     // Custom error handler
-   *     console.error(error);
-   *     return new Response(`Error: ${error.message}`, {
-   *       status: 500
-   *     });
-   *   }
-   * });
-   * ```
-   *
-   * @example Server Lifecycle
-   * ```ts
-   * const server = Bun.serve({
-   *   // Server config...
-   * });
-   *
-   * // Update routes at runtime
-   * server.reload({
-   *   routes: {
-   *     "/": () => new Response("Updated route")
-   *   }
-   * });
-   *
-   * // Stop the server
-   * server.stop();
-   * ```
-   *
-   * @example Development Mode
-   * ```ts
-   * Bun.serve({
-   *   development: true, // Enable hot reloading
-   *   routes: {
-   *     // Routes will auto-reload on changes
-   *   }
-   * });
-   * ```
-   *
-   * @example Type-Safe Request Handling
-   * ```ts
-   * type Post = {
-   *   id: string;
-   *   title: string;
-   * };
-   *
-   * Bun.serve({
-   *   routes: {
-   *     "/api/posts/:id": async (
-   *       req: BunRequest<"/api/posts/:id">
-   *     ) => {
-   *       if (req.method === "POST") {
-   *         const body: Post = await req.json();
-   *         return Response.json(body);
-   *       }
-   *       return new Response("Method not allowed", {
-   *         status: 405
-   *       });
-   *     }
-   *   }
-   * });
-   * ```
-   */
-  function serve<T, R extends { [K in keyof R]: RouterTypes.RouteValue<K & string> }>(
-    options: ServeFunctionOptions<T, R> & {
-      /**
-       * @deprecated Use `routes` instead in new code. This will continue to work for a while though.
-       */
-      static?: R;
-    },
-  ): Server;
-
   /**
    * [`Blob`](https://developer.mozilla.org/en-US/docs/Web/API/Blob) powered by the fastest system calls available for operating on files.
    *