diff --git a/.buildkite/scripts/upload-release.sh b/.buildkite/scripts/upload-release.sh
index f245213e1c..e3198479cf 100755
--- a/.buildkite/scripts/upload-release.sh
+++ b/.buildkite/scripts/upload-release.sh
@@ -168,13 +168,14 @@ function send_discord_announcement() {
   local version="$1"
   local commit="$BUILDKITE_COMMIT"
   local short_sha="${commit:0:7}"
-  
+  local commit_url="https://github.com/oven-sh/bun/commit/$commit"
+
   if [ "$version" == "canary" ]; then
     local json_payload=$(cat <<EOF
 {
   "embeds": [{
-    "title": "Bun Canary ${short_sha} now available",
-    "description": "A new canary build of Bun has been automatically uploaded. To upgrade, run:\n\n\`\`\`shell\nbun upgrade --canary\n# bun upgrade --stable <- to downgrade\n\`\`\`\n\nCommit: \`${commit}\`",
+    "title": "New Bun Canary now available",
+    "description": "A new canary build of Bun has been automatically uploaded ([${short_sha}](${commit_url})). To upgrade, run:\n\n\`\`\`shell\nbun upgrade --canary\n\`\`\`\nCommit: \`${commit}\`",
     "color": 16023551,
     "timestamp": "$(date -u +%Y-%m-%dT%H:%M:%SZ)"
   }]
diff --git a/docs/api/http.md b/docs/api/http.md
index 1b6de6836e..77a351d463 100644
--- a/docs/api/http.md
+++ b/docs/api/http.md
@@ -8,19 +8,421 @@ To start a high-performance HTTP server with a clean API, the recommended approa
 
 ## `Bun.serve()`
 
-Start an HTTP server in Bun with `Bun.serve`.
+Use `Bun.serve` to start an HTTP server in Bun.
 
 ```ts
 Bun.serve({
+  // `routes` requires Bun v1.2.3+
+  routes: {
+    // Static routes
+    "/api/status": new Response("OK"),
+
+    // Dynamic routes
+    "/users/:id": req => {
+      return new Response(`Hello User ${req.params.id}!`);
+    },
+
+    // Per-HTTP method handlers
+    "/api/posts": {
+      GET: () => new Response("List posts"),
+      POST: async req => {
+        const body = await req.json();
+        return Response.json({ created: true, ...body });
+      },
+    },
+
+    // Wildcard route for all routes that start with "/api/" and aren't otherwise matched
+    "/api/*": Response.json({ message: "Not found" }, { status: 404 }),
+
+    // Redirect from /blog/hello to /blog/hello/world
+    "/blog/hello": Response.redirect("/blog/hello/world"),
+
+    // Serve a file by buffering it in memory
+    "/favicon.ico": new Response(await Bun.file("./favicon.ico").bytes(), {
+      headers: {
+        "Content-Type": "image/x-icon",
+      },
+    }),
+  },
+
+  // (optional) fallback for unmatched routes:
+  // Required if Bun's version < 1.2.3
   fetch(req) {
-    return new Response("Bun!");
+    return new Response("Not Found", { status: 404 });
   },
 });
 ```
 
+### Routing
+
+Routes in `Bun.serve()` receive a `BunRequest` (which extends [`Request`](https://developer.mozilla.org/en-US/docs/Web/API/Request)) and return a [`Response`](https://developer.mozilla.org/en-US/docs/Web/API/Response) or `Promise<Response>`. This makes it easier to use the same code for both sending & receiving HTTP requests.
+
+```ts
+// Simplified for brevity
+interface BunRequest<T extends string> extends Request {
+  params: Record<T, string>;
+}
+```
+
+#### Async/await in routes
+
+You can use async/await in route handlers to return a `Promise<Response>`.
+
+```ts
+import { sql, serve } from "bun";
+
+serve({
+  port: 3001,
+  routes: {
+    "/api/version": async () => {
+      const [version] = await sql`SELECT version()`;
+      return Response.json(version);
+    },
+  },
+});
+```
+
+#### Promise in routes
+
+You can also return a `Promise<Response>` from a route handler.
+
+```ts
+import { sql, serve } from "bun";
+
+serve({
+  routes: {
+    "/api/version": () => {
+      return new Promise(resolve => {
+        setTimeout(async () => {
+          const [version] = await sql`SELECT version()`;
+          resolve(Response.json(version));
+        }, 100);
+      });
+    },
+  },
+});
+```
+
+#### Type-safe route parameters
+
+TypeScript parses route parameters when passed as a string literal, so that your editor will show autocomplete when accessing `request.params`.
+
+```ts
+import type { BunRequest } from "bun";
+
+Bun.serve({
+  routes: {
+    // TypeScript knows the shape of params when passed as a string literal
+    "/orgs/:orgId/repos/:repoId": req => {
+      const { orgId, repoId } = req.params;
+      return Response.json({ orgId, repoId });
+    },
+
+    "/orgs/:orgId/repos/:repoId/settings": (
+      // optional: you can explicitly pass a type to BunRequest:
+      req: BunRequest<"/orgs/:orgId/repos/:repoId/settings">,
+    ) => {
+      const { orgId, repoId } = req.params;
+      return Response.json({ orgId, repoId });
+    },
+  },
+});
+```
+
+Percent-encoded route parameter values are automatically decoded. Unicode characters are supported. Invalid unicode is replaced with the unicode replacement character `&0xFFFD;`.
+
+### Static responses
+
+Routes can also be `Response` objects (without the handler function). Bun.serve() optimizes it for zero-allocation dispatch - perfect for health checks, redirects, and fixed content:
+
+```ts
+Bun.serve({
+  routes: {
+    // Health checks
+    "/health": new Response("OK"),
+    "/ready": new Response("Ready", {
+      headers: {
+        // Pass custom headers
+        "X-Ready": "1",
+      },
+    }),
+
+    // Redirects
+    "/blog": Response.redirect("https://bun.sh/blog"),
+
+    // API responses
+    "/api/config": Response.json({
+      version: "1.0.0",
+      env: "production",
+    }),
+  },
+});
+```
+
+Static responses do not allocate additional memory after initialization. You can generally expect at least a 15% performance improvement over manually returning a `Response` object.
+
+Static route responses are cached for the lifetime of the server object. To reload static routes, call `server.reload(options)`.
+
+```ts
+const server = Bun.serve({
+  static: {
+    "/api/time": new Response(new Date().toISOString()),
+  },
+
+  fetch(req) {
+    return new Response("404!");
+  },
+});
+
+// Update the time every second.
+setInterval(() => {
+  server.reload({
+    static: {
+      "/api/time": new Response(new Date().toISOString()),
+    },
+
+    fetch(req) {
+      return new Response("404!");
+    },
+  });
+}, 1000);
+```
+
+Reloading routes only impact the next request. In-flight requests continue to use the old routes. After in-flight requests to old routes are finished, the old routes are freed from memory.
+
+To simplify error handling, static routes do not support streaming response bodies from `ReadableStream` or an `AsyncIterator`. Fortunately, you can still buffer the response in memory first:
+
+```ts
+const time = await fetch("https://api.example.com/v1/data");
+// Buffer the response in memory first.
+const blob = await time.blob();
+
+const server = Bun.serve({
+  static: {
+    "/api/data": new Response(blob),
+  },
+
+  fetch(req) {
+    return new Response("404!");
+  },
+});
+```
+
+### Route precedence
+
+Routes are matched in order of specificity:
+
+1. Exact routes (`/users/all`)
+2. Parameter routes (`/users/:id`)
+3. Wildcard routes (`/users/*`)
+4. Global catch-all (`/*`)
+
+```ts
+Bun.serve({
+  routes: {
+    // Most specific first
+    "/api/users/me": () => new Response("Current user"),
+    "/api/users/:id": req => new Response(`User ${req.params.id}`),
+    "/api/*": () => new Response("API catch-all"),
+    "/*": () => new Response("Global catch-all"),
+  },
+});
+```
+
+### Per-HTTP Method Routes
+
+Route handlers can be specialized by HTTP method:
+
+```ts
+Bun.serve({
+  routes: {
+    "/api/posts": {
+      // Different handlers per method
+      GET: () => new Response("List posts"),
+      POST: async req => {
+        const post = await req.json();
+        return Response.json({ id: crypto.randomUUID(), ...post });
+      },
+      PUT: async req => {
+        const updates = await req.json();
+        return Response.json({ updated: true, ...updates });
+      },
+      DELETE: () => new Response(null, { status: 204 }),
+    },
+  },
+});
+```
+
+You can pass any of the following methods:
+
+| Method    | Usecase example                 |
+| --------- | ------------------------------- |
+| `GET`     | Fetch a resource                |
+| `HEAD`    | Check if a resource exists      |
+| `OPTIONS` | Get allowed HTTP methods (CORS) |
+| `DELETE`  | Delete a resource               |
+| `PATCH`   | Update a resource               |
+| `POST`    | Create a resource               |
+| `PUT`     | Update a resource               |
+
+When passing a function instead of an object, all methods will be handled by that function:
+
+```ts
+const server = Bun.serve({
+  routes: {
+    "/api/version": () => Response.json({ version: "1.0.0" }),
+  },
+});
+
+await fetch(new URL("/api/version", server.url));
+await fetch(new URL("/api/version", server.url), { method: "PUT" });
+// ... etc
+```
+
+### Hot Route Reloading
+
+Update routes without server restarts using `server.reload()`:
+
+```ts
+const server = Bun.serve({
+  routes: {
+    "/api/version": () => Response.json({ version: "1.0.0" }),
+  },
+});
+
+// Deploy new routes without downtime
+server.reload({
+  routes: {
+    "/api/version": () => Response.json({ version: "2.0.0" }),
+  },
+});
+```
+
+### Error Handling
+
+Bun provides structured error handling for routes:
+
+```ts
+Bun.serve({
+  routes: {
+    // Errors are caught automatically
+    "/api/risky": () => {
+      throw new Error("Something went wrong");
+    },
+  },
+  // Global error handler
+  error(error) {
+    console.error(error);
+    return new Response(`Internal Error: ${error.message}`, {
+      status: 500,
+      headers: {
+        "Content-Type": "text/plain",
+      },
+    });
+  },
+});
+```
+
+### HTML imports
+
+To add a client-side single-page app, you can use an HTML import:
+
+```ts
+import myReactSinglePageApp from "./index.html";
+
+Bun.serve({
+  routes: {
+    "/": myReactSinglePageApp,
+  },
+});
+```
+
+HTML imports don't just serve HTML. It's a full-featured frontend bundler, transpiler, and toolkit built using Bun's [bundler](https://bun.sh/docs/bundler), JavaScript transpiler and CSS parser.
+
+You can use this to build a full-featured frontend with React, TypeScript, Tailwind CSS, and more. Check out [/docs/bundler/fullstack](https://bun.sh/docs/bundler/fullstack) to learn more.
+
+### Practical example: REST API
+
+Here's a basic database-backed REST API using Bun's router with zero dependencies:
+
+{% codetabs %}
+
+```ts#server.ts
+import type { Post } from "./types.ts";
+import { Database } from "bun:sqlite";
+
+const db = new Database("posts.db");
+db.exec(`
+  CREATE TABLE IF NOT EXISTS posts (
+    id TEXT PRIMARY KEY,
+    title TEXT NOT NULL,
+    content TEXT NOT NULL,
+    created_at TEXT NOT NULL
+  )
+`);
+
+Bun.serve({
+  routes: {
+    // List posts
+    "/api/posts": {
+      GET: () => {
+        const posts = db.query("SELECT * FROM posts").all();
+        return Response.json(posts);
+      },
+
+      // Create post
+      POST: async req => {
+        const post: Omit<Post, "id" | "created_at"> = await req.json();
+        const id = crypto.randomUUID();
+
+        db.query(
+          `INSERT INTO posts (id, title, content, created_at)
+           VALUES (?, ?, ?, ?)`,
+        ).run(id, post.title, post.content, new Date().toISOString());
+
+        return Response.json({ id, ...post }, { status: 201 });
+      },
+    },
+
+    // Get post by ID
+    "/api/posts/:id": req => {
+      const post = db
+        .query("SELECT * FROM posts WHERE id = ?")
+        .get(req.params.id);
+
+      if (!post) {
+        return new Response("Not Found", { status: 404 });
+      }
+
+      return Response.json(post);
+    },
+  },
+
+  error(error) {
+    console.error(error);
+    return new Response("Internal Server Error", { status: 500 });
+  },
+});
+```
+
+```ts#types.ts
+export interface Post {
+  id: string;
+  title: string;
+  content: string;
+  created_at: string;
+}
+```
+
+{% /codetabs %}
+
+### Routing performance
+
+`Bun.serve()`'s router builds on top uWebSocket's [tree-based approach](https://github.com/oven-sh/bun/blob/0d1a00fa0f7830f8ecd99c027fce8096c9d459b6/packages/bun-uws/src/HttpRouter.h#L57-L64) to add [SIMD-accelerated route parameter decoding](https://github.com/oven-sh/bun/blob/jarred/optional-fetch/src/bun.js/bindings/decodeURIComponentSIMD.cpp#L21-L271) and [JavaScriptCore structure caching](https://github.com/oven-sh/bun/blob/jarred/optional-fetch/src/bun.js/bindings/ServerRouteList.cpp#L100-L101) to push the performance limits of what modern hardware allows.
+
 ### `fetch` request handler
 
-The `fetch` handler handles incoming requests. It receives a [`Request`](https://developer.mozilla.org/en-US/docs/Web/API/Request) object and returns a [`Response`](https://developer.mozilla.org/en-US/docs/Web/API/Response) or `Promise<Response>`.
+The `fetch` handler handles incoming requests that weren't matched by any route. It receives a [`Request`](https://developer.mozilla.org/en-US/docs/Web/API/Request) object and returns a [`Response`](https://developer.mozilla.org/en-US/docs/Web/API/Response) or [`Promise<Response>`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise).
 
 ```ts
 Bun.serve({
@@ -70,116 +472,6 @@ const server = Bun.serve({
 });
 ```
 
-### Static routes
-
-Use the `static` option to serve static `Response` objects by route.
-
-```ts
-// Bun v1.1.27+ required
-Bun.serve({
-  static: {
-    // health-check endpoint
-    "/api/health-check": new Response("All good!"),
-
-    // redirect from /old-link to /new-link
-    "/old-link": Response.redirect("/new-link", 301),
-
-    // serve static text
-    "/": new Response("Hello World"),
-
-    // serve a file by buffering it in memory
-    "/index.html": new Response(await Bun.file("./index.html").bytes(), {
-      headers: {
-        "Content-Type": "text/html",
-      },
-    }),
-    "/favicon.ico": new Response(await Bun.file("./favicon.ico").bytes(), {
-      headers: {
-        "Content-Type": "image/x-icon",
-      },
-    }),
-
-    // serve JSON
-    "/api/version.json": Response.json({ version: "1.0.0" }),
-  },
-
-  fetch(req) {
-    return new Response("404!");
-  },
-});
-```
-
-Static routes support headers, status code, and other `Response` options.
-
-```ts
-Bun.serve({
-  static: {
-    "/api/time": new Response(new Date().toISOString(), {
-      headers: {
-        "X-Custom-Header": "Bun!",
-      },
-    }),
-  },
-
-  fetch(req) {
-    return new Response("404!");
-  },
-});
-```
-
-Static routes can serve Response bodies faster than `fetch` handlers because they don't create `Request` objects, they don't create `AbortSignal`, they don't create additional `Response` objects. The only per-request memory allocation is the TCP/TLS socket data needed for each request.
-
-{% note %}
-`static` is experimental
-{% /note %}
-
-Static route responses are cached for the lifetime of the server object. To reload static routes, call `server.reload(options)`.
-
-```ts
-const server = Bun.serve({
-  static: {
-    "/api/time": new Response(new Date().toISOString()),
-  },
-
-  fetch(req) {
-    return new Response("404!");
-  },
-});
-
-// Update the time every second.
-setInterval(() => {
-  server.reload({
-    static: {
-      "/api/time": new Response(new Date().toISOString()),
-    },
-
-    fetch(req) {
-      return new Response("404!");
-    },
-  });
-}, 1000);
-```
-
-Reloading static routes only impact the next request. In-flight requests continue to use the old static routes. After in-flight requests to old static routes are finished, the old static routes are freed from memory.
-
-To simplify error handling, static routes do not support streaming response bodies from `ReadableStream` or an `AsyncIterator`. Fortunately, you can still buffer the response in memory first:
-
-```ts
-const time = await fetch("https://api.example.com/v1/data");
-// Buffer the response in memory first.
-const blob = await time.blob();
-
-const server = Bun.serve({
-  static: {
-    "/api/data": new Response(blob),
-  },
-
-  fetch(req) {
-    return new Response("404!");
-  },
-});
-```
-
 ### Changing the `port` and `hostname`
 
 To configure which port and hostname the server will listen on, set `port` and `hostname` in the options object.
@@ -553,7 +845,7 @@ Update the server's handlers without restarting:
 
 ```ts
 const server = Bun.serve({
-  static: {
+  routes: {
     "/api/version": Response.json({ version: "v1" }),
   },
   fetch(req) {
@@ -563,7 +855,7 @@ const server = Bun.serve({
 
 // Update to new handler
 server.reload({
-  static: {
+  routes: {
     "/api/version": Response.json({ version: "v2" }),
   },
   fetch(req) {
@@ -572,7 +864,7 @@ server.reload({
 });
 ```
 
-This is useful for development and hot reloading. Only `fetch`, `error`, and `static` handlers can be updated.
+This is useful for development and hot reloading. Only `fetch`, `error`, and `routes` can be updated.
 
 ## Per-Request Controls
 
diff --git a/docs/bundler/fullstack.md b/docs/bundler/fullstack.md
index dde0de6d53..4f1e8be9dc 100644
--- a/docs/bundler/fullstack.md
+++ b/docs/bundler/fullstack.md
@@ -3,26 +3,34 @@ Using `Bun.serve()`'s `routes` option, you can run your frontend and backend in
 To get started, import HTML files and pass them to the `routes` option in `Bun.serve()`.
 
 ```ts
+import { sql, serve } from "bun";
 import dashboard from "./dashboard.html";
 import homepage from "./index.html";
 
-const server = Bun.serve({
-  // Add HTML imports to `routes` (before Bun v1.2.3, this was called `static`)
+const server = serve({
   routes: {
-    // Bundle & route index.html to "/"
+    // ** HTML imports **
+    // Bundle & route index.html to "/". This uses HTMLRewriter to scan the HTML for `<script>` and `<link>` tags, run's Bun's JavaScript & CSS bundler on them, transpiles any TypeScript, JSX, and TSX, downlevels CSS with Bun's CSS parser and serves the result.
     "/": homepage,
     // Bundle & route dashboard.html to "/dashboard"
     "/dashboard": dashboard,
 
-    // API endpoints:
-    "/api/users": async req => {
-      const users = await Bun.sql`SELECT * FROM users`;
-      return Response.json(users);
+    // ** API endpoints ** (Bun v1.2.3+ required)
+    "/api/users": {
+      async GET(req) {
+        const users = await sql`SELECT * FROM users`;
+        return Response.json(users);
+      },
+      async POST(req) {
+        const { name, email } = await req.json();
+        const [user] =
+          await sql`INSERT INTO users (name, email) VALUES (${name}, ${email})`;
+        return Response.json(user);
+      },
     },
-
     "/api/users/:id": async req => {
       const { id } = req.params;
-      const [user] = await Bun.sql`SELECT * FROM users WHERE id = ${id}`;
+      const [user] = await sql`SELECT * FROM users WHERE id = ${id}`;
       return Response.json(user);
     },
   },
@@ -32,11 +40,11 @@ const server = Bun.serve({
   // - Hot reloading (Bun v1.2.3+ required)
   development: true,
 
-  // Handle API requests
-  async fetch(req) {
-    // Return 404 for unmatched routes
-    return new Response("Not Found", { status: 404 });
-  },
+  // Prior to v1.2.3, the `fetch` option was used to handle all API requests. It is now optional.
+  // async fetch(req) {
+  //   // Return 404 for unmatched routes
+  //   return new Response("Not Found", { status: 404 });
+  // },
 });
 
 console.log(`Listening on ${server.url}`);
diff --git a/packages/bun-types/bun.d.ts b/packages/bun-types/bun.d.ts
index 42dd4e7efd..306dff01c8 100644
--- a/packages/bun-types/bun.d.ts
+++ b/packages/bun-types/bun.d.ts
@@ -455,189 +455,6 @@ declare module "bun" {
   }
   const TOML: TOML;
 
-  type Serve<WebSocketDataType = undefined> =
-    | ServeOptions
-    | TLSServeOptions
-    | UnixServeOptions
-    | UnixTLSServeOptions
-    | WebSocketServeOptions<WebSocketDataType>
-    | TLSWebSocketServeOptions<WebSocketDataType>
-    | UnixWebSocketServeOptions<WebSocketDataType>
-    | UnixTLSWebSocketServeOptions<WebSocketDataType>;
-
-  /** 
-    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.
-
-    @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 
-          });
-        }
-      }
-    });
-    ```
-    @param options - Server configuration options
-    @param options.routes - Route definitions mapping paths to handlers
-    */
-  function serve<T, R extends { [K in keyof R]: RouterTypes.RouteValue<K & string> }>(
-    options: Serve<T> & {
-      routes?: R;
-      /**
-       * @deprecated Use {@link routes} instead in new code
-       */
-      static?: R;
-    },
-  ): Server;
-
   /**
    * Synchronously resolve a `moduleId` as though it were imported from `parent`
    *
@@ -4280,7 +4097,24 @@ declare module "bun" {
      *
      * Passing other options such as `port` or `hostname` won't do anything.
      */
-    reload(options: Serve): void;
+    reload<T, R extends { [K in keyof R]: RouterTypes.RouteValue<K & string> }>(
+      options: (
+        | (Omit<ServeOptions, "fetch"> & {
+            routes: R;
+            fetch?: (this: Server, request: Request, server: Server) => Response | Promise<Response>;
+          })
+        | (Omit<ServeOptions, "routes"> & {
+            routes?: never;
+            fetch: (this: Server, request: Request, server: Server) => Response | Promise<Response>;
+          })
+        | WebSocketServeOptions<T>
+      ) & {
+        /**
+         * @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.
@@ -4478,6 +4312,198 @@ declare module "bun" {
     readonly id: string;
   }
 
+  type Serve<WebSocketDataType = undefined> =
+    | ServeOptions
+    | TLSServeOptions
+    | UnixServeOptions
+    | UnixTLSServeOptions
+    | WebSocketServeOptions<WebSocketDataType>
+    | TLSWebSocketServeOptions<WebSocketDataType>
+    | UnixWebSocketServeOptions<WebSocketDataType>
+    | UnixTLSWebSocketServeOptions<WebSocketDataType>;
+
+  /** 
+    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.
+
+    @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 
+          });
+        }
+      }
+    });
+    ```
+    @param options - Server configuration options
+    @param options.routes - Route definitions mapping paths to handlers
+    */
+  function serve<T, R extends { [K in keyof R]: RouterTypes.RouteValue<K & string> }>(
+    options: (
+      | (Omit<ServeOptions, "fetch"> & {
+          routes: R;
+          fetch?: (this: Server, request: Request, server: Server) => Response | Promise<Response>;
+        })
+      | (Omit<ServeOptions, "routes"> & {
+          routes?: never;
+          fetch: (this: Server, request: Request, server: Server) => Response | Promise<Response>;
+        })
+      | WebSocketServeOptions<T>
+    ) & {
+      /**
+       * @deprecated Use `routes` instead in new code. This will continue to work for awhile 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.
    *
diff --git a/src/bun.js/api/BunObject.zig b/src/bun.js/api/BunObject.zig
index 4abd69469a..e84f1b1d81 100644
--- a/src/bun.js/api/BunObject.zig
+++ b/src/bun.js/api/BunObject.zig
@@ -3076,8 +3076,11 @@ pub fn serve(globalObject: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) bun.J
             globalObject,
             &config,
             &args,
-            callframe.isFromBunMain(globalObject.vm()),
-            true,
+            .{
+                .allow_bake_config = bun.FeatureFlags.bake() and callframe.isFromBunMain(globalObject.vm()),
+                .is_fetch_required = true,
+                .has_user_routes = false,
+            },
         );
 
         if (globalObject.hasException()) {
diff --git a/src/bun.js/api/server.zig b/src/bun.js/api/server.zig
index 6e47aa92ed..bfe7f528fc 100644
--- a/src/bun.js/api/server.zig
+++ b/src/bun.js/api/server.zig
@@ -1210,12 +1210,17 @@ pub const ServerConfig = struct {
         }
     };
 
+    pub const FromJSOptions = struct {
+        allow_bake_config: bool = true,
+        is_fetch_required: bool = true,
+        has_user_routes: bool = false,
+    };
+
     pub fn fromJS(
         global: *JSC.JSGlobalObject,
         args: *ServerConfig,
         arguments: *JSC.Node.ArgumentsSlice,
-        allow_bake_config: bool,
-        is_fetch_required: bool,
+        opts: FromJSOptions,
     ) bun.JSError!void {
         const vm = arguments.vm;
         const env = vm.transpiler.env;
@@ -1306,7 +1311,20 @@ pub const ServerConfig = struct {
 
             if ((try arg.get(global, "routes")) orelse (try arg.get(global, "static"))) |static| {
                 if (!static.isObject()) {
-                    return global.throwInvalidArguments("Bun.serve expects 'static' to be an object shaped like { [pathname: string]: Response }", .{});
+                    return global.throwInvalidArguments(
+                        \\Bun.serve() expects 'routes' to be an object shaped like:
+                        \\
+                        \\  {
+                        \\    "/path": {
+                        \\      GET: (req) => new Response("Hello"),
+                        \\      POST: (req) => new Response("Hello"),
+                        \\    },
+                        \\    "/path2/:param": new Response("Hello"),
+                        \\    "/path3/:param1/:param2": (req) => new Response("Hello")
+                        \\  }
+                        \\
+                        \\Learn more at https://bun.sh/docs/api/http
+                    , .{});
                 }
                 args.had_routes_object = true;
 
@@ -1350,11 +1368,11 @@ pub const ServerConfig = struct {
                     }
 
                     if (path.len == 0 or (path[0] != '/')) {
-                        return global.throwInvalidArguments("Invalid static route \"{s}\". path must start with '/'", .{path});
+                        return global.throwInvalidArguments("Invalid route {}. Path must start with '/'", .{bun.fmt.quote(path)});
                     }
 
                     if (!is_ascii) {
-                        return global.throwInvalidArguments("Invalid static route \"{s}\". Please encode all non-ASCII characters in the path.", .{path});
+                        return global.throwInvalidArguments("Invalid route {}. Please encode all non-ASCII characters in the path.", .{bun.fmt.quote(path)});
                     }
 
                     if (value == .false) {
@@ -1391,7 +1409,7 @@ pub const ServerConfig = struct {
                         inline for (methods) |method| {
                             if (value.getOwn(global, @tagName(method))) |function| {
                                 if (!function.isCallable(global.vm())) {
-                                    return global.throwInvalidArguments("Expected {s} to be a function", .{@tagName(method)});
+                                    return global.throwInvalidArguments("Expected {s} in {} route to be a function", .{ @tagName(method), bun.fmt.quote(path) });
                                 }
                                 if (!found) {
                                     try validateRouteName(global, path);
@@ -1566,22 +1584,22 @@ pub const ServerConfig = struct {
             }
             if (global.hasException()) return error.JSError;
 
-            if (try arg.getTruthy(global, "app")) |bake_args_js| brk: {
-                if (!bun.FeatureFlags.bake()) {
-                    break :brk;
-                }
-                if (args.bake != null) {
-                    // "app" is likely to be removed in favor of the HTML loader.
-                    return global.throwInvalidArguments("'app' + HTML loader not supported.", .{});
-                }
-                if (!allow_bake_config) {
-                    return global.throwInvalidArguments("To use the \"app\" option, change from calling \"Bun.serve({ app })\" to \"export default { app: ... }\"", .{});
-                }
-                if (args.development == .production) {
-                    return global.throwInvalidArguments("TODO: 'development: false' in serve options with 'app'. For now, use `bun build --app` or set 'development: true'", .{});
-                }
+            if (opts.allow_bake_config) {
+                if (try arg.getTruthy(global, "app")) |bake_args_js| brk: {
+                    if (!bun.FeatureFlags.bake()) {
+                        break :brk;
+                    }
+                    if (args.bake != null) {
+                        // "app" is likely to be removed in favor of the HTML loader.
+                        return global.throwInvalidArguments("'app' + HTML loader not supported.", .{});
+                    }
 
-                args.bake = try bun.bake.UserOptions.fromJS(bake_args_js, global);
+                    if (args.development == .production) {
+                        return global.throwInvalidArguments("TODO: 'development: false' in serve options with 'app'. For now, use `bun build --app` or set 'development: true'", .{});
+                    }
+
+                    args.bake = try bun.bake.UserOptions.fromJS(bake_args_js, global);
+                }
             }
 
             if (try arg.get(global, "reusePort")) |dev| {
@@ -1627,9 +1645,25 @@ pub const ServerConfig = struct {
                 const onRequest = onRequest_.withAsyncContextIfNeeded(global);
                 JSC.C.JSValueProtect(global, onRequest.asObjectRef());
                 args.onRequest = onRequest;
-            } else if (args.bake == null and is_fetch_required) {
+            } else if (args.bake == null and ((args.static_routes.items.len + args.user_routes_to_build.items.len) == 0 and !opts.has_user_routes) and opts.is_fetch_required) {
                 if (global.hasException()) return error.JSError;
-                return global.throwInvalidArguments("Expected fetch() to be a function", .{});
+                return global.throwInvalidArguments(
+                    \\Bun.serve() needs either:
+                    \\
+                    \\  - A routes object:
+                    \\     routes: {
+                    \\       "/path": {
+                    \\         GET: (req) => new Response("Hello")
+                    \\       }
+                    \\     }
+                    \\
+                    \\  - Or a fetch handler:
+                    \\     fetch: (req) => {
+                    \\       return new Response("Hello")
+                    \\     }
+                    \\
+                    \\Learn more at https://bun.sh/docs/api/http
+                , .{});
             } else {
                 if (global.hasException()) return error.JSError;
             }
@@ -6765,7 +6799,11 @@ pub fn NewServer(comptime NamespaceType: type, comptime ssl_enabled_: bool, comp
             defer args_slice.deinit();
 
             var new_config: ServerConfig = .{};
-            try ServerConfig.fromJS(globalThis, &new_config, &args_slice, false, false);
+            try ServerConfig.fromJS(globalThis, &new_config, &args_slice, .{
+                .allow_bake_config = false,
+                .is_fetch_required = true,
+                .has_user_routes = this.user_routes.items.len > 0,
+            });
             if (globalThis.hasException()) {
                 new_config.deinit();
                 return error.JSError;
@@ -7427,37 +7465,6 @@ pub fn NewServer(comptime NamespaceType: type, comptime ssl_enabled_: bool, comp
             resp.end(buffer, false);
         }
 
-        pub fn onSrcRequest(this: *ThisServer, req: *uws.Request, resp: *App.Response) void {
-            JSC.markBinding(@src());
-            this.pending_requests += 1;
-            defer this.pending_requests -= 1;
-            req.setYield(false);
-
-            if (req.header("open-in-editor") == null) {
-                resp.writeStatus("501 Not Implemented");
-                resp.end("Viewing source without opening in editor is not implemented yet!", false);
-                return;
-            }
-
-            var ctx = &JSC.VirtualMachine.get().rareData().editor_context;
-            ctx.autoDetectEditor(JSC.VirtualMachine.get().transpiler.env);
-            const line: ?string = req.header("editor-line");
-            const column: ?string = req.header("editor-column");
-
-            if (ctx.editor) |editor| {
-                resp.writeStatus("200 Opened");
-                resp.end("Opened in editor", false);
-                var url = req.url()["/src:".len..];
-                if (strings.indexOfChar(url, ':')) |colon| {
-                    url = url[0..colon];
-                }
-                editor.open(ctx.path, url, line, column, this.allocator) catch Output.prettyErrorln("Failed to open editor", .{});
-            } else {
-                resp.writeStatus("500 Missing Editor :(");
-                resp.end("Please set your editor in bunfig.toml", false);
-            }
-        }
-
         pub fn onPendingRequest(this: *ThisServer) void {
             this.pending_requests += 1;
         }
@@ -7907,8 +7914,6 @@ pub fn NewServer(comptime NamespaceType: type, comptime ssl_enabled_: bool, comp
                     JSC.markBinding(@src());
                     Bun__addInspector(ssl_enabled, app, this.globalThis);
                 }
-
-                app.get("/src:/*", *ThisServer, this, onSrcRequest);
             }
 
             var has_dev_catch_all = false;
@@ -7917,14 +7922,13 @@ pub fn NewServer(comptime NamespaceType: type, comptime ssl_enabled_: bool, comp
                 has_dev_catch_all = dev.attachRoutes(this) catch bun.outOfMemory();
             }
 
-            if (!has_dev_catch_all) {
+            if (!has_dev_catch_all and this.config.onRequest != .zero) {
                 // "/*" routes are added backwards, so if they have a static route,
                 // it will never be matched so we need to check for that first
                 if (!has_html_catch_all) {
-                    bun.assert(this.config.onRequest != .zero);
                     app.any("/*", *ThisServer, this, onRequest);
-                } else if (this.config.onRequest != .zero) {
-                    // The HTML catch-all receives GET, HEAD, and OPTIONS
+                } else {
+                    // The HTML catch-all receives GET, HEAD.
                     app.post("/*", *ThisServer, this, onRequest);
                     app.put("/*", *ThisServer, this, onRequest);
                     app.patch("/*", *ThisServer, this, onRequest);
@@ -7933,11 +7937,31 @@ pub fn NewServer(comptime NamespaceType: type, comptime ssl_enabled_: bool, comp
                     app.trace("/*", *ThisServer, this, onRequest);
                     app.connect("/*", *ThisServer, this, onRequest);
                 }
+            } else if (!has_dev_catch_all and this.config.onRequest == .zero and !has_html_catch_all) {
+                app.any("/*", *ThisServer, this, on404);
+            } else if (!has_dev_catch_all and this.config.onRequest == .zero) {
+                app.post("/*", *ThisServer, this, on404);
+                app.put("/*", *ThisServer, this, on404);
+                app.patch("/*", *ThisServer, this, on404);
+                app.delete("/*", *ThisServer, this, on404);
+                app.options("/*", *ThisServer, this, on404);
+                app.trace("/*", *ThisServer, this, on404);
+                app.connect("/*", *ThisServer, this, on404);
             }
 
             return route_list_value;
         }
 
+        pub fn on404(_: *ThisServer, req: *uws.Request, resp: *App.Response) void {
+            if (comptime Environment.enable_logs)
+                httplog("{s} - {s} 404", .{ req.method(), req.url() });
+
+            resp.writeStatus("404 Not Found");
+
+            // Rely on browser default page for now.
+            resp.end("", false);
+        }
+
         // TODO: make this return JSError!void, and do not deinitialize on synchronous failure, to allow errdefer in caller scope
         pub fn listen(this: *ThisServer) JSC.JSValue {
             httplog("listen", .{});
diff --git a/src/bun.js/api/server/StaticRoute.zig b/src/bun.js/api/server/StaticRoute.zig
index 093de6cfd7..b7b898fc6b 100644
--- a/src/bun.js/api/server/StaticRoute.zig
+++ b/src/bun.js/api/server/StaticRoute.zig
@@ -135,7 +135,7 @@ pub fn fromJS(globalThis: *JSC.JSGlobalObject, argument: JSC.JSValue) bun.JSErro
     }
 
     return globalThis.throwInvalidArguments(
-        \\'static' expects a Record<string, Response | HTMLBundle>
+        \\'routes' expects a Record<string, Response | HTMLBundle | {[method: string]: (req: BunRequest) => Response|Promise<Response>}>
         \\
         \\To bundle frontend apps on-demand with Bun.serve(), import HTML files.
         \\
@@ -146,9 +146,21 @@ pub fn fromJS(globalThis: *JSC.JSGlobalObject, argument: JSC.JSValue) bun.JSErro
         \\import app from "./app.html";
         \\
         \\serve({
-        \\  static: {
+        \\  routes: {
         \\    "/index.json": Response.json({ message: "Hello World" }),
         \\    "/app": app,
+        \\    "/path/:param": (req) => {
+        \\      const param = req.params.param;
+        \\      return Response.json({ message: `Hello ${param}` });
+        \\    },
+        \\    "/path": {
+        \\      GET(req) {
+        \\        return Response.json({ message: "Hello World" });
+        \\      },
+        \\      POST(req) {
+        \\        return Response.json({ message: "Hello World" });
+        \\      },
+        \\    },
         \\  },
         \\
         \\  fetch(request) {
diff --git a/src/bun.js/bindings/decodeURIComponentSIMD.cpp b/src/bun.js/bindings/decodeURIComponentSIMD.cpp
index 98f27e5bd1..dc2f120897 100644
--- a/src/bun.js/bindings/decodeURIComponentSIMD.cpp
+++ b/src/bun.js/bindings/decodeURIComponentSIMD.cpp
@@ -245,12 +245,12 @@ slow_path:
         } else {
             // Look ahead for next % using SIMD
             const uint8_t* lookAhead = cursor;
-            while (lookAhead + 16 <= end) {
+            while (lookAhead + stride <= end) {
                 auto chunk = SIMD::load(lookAhead);
                 if (SIMD::isNonZero(SIMD::equal(chunk, percentVector))) {
                     break;
                 }
-                lookAhead += 16;
+                lookAhead += stride;
             }
 
             // Append everything up to lookAhead
diff --git a/test/js/bun/http/bun-serve-routes.test.ts b/test/js/bun/http/bun-serve-routes.test.ts
index 23d3f4d2da..5434d3e3f0 100644
--- a/test/js/bun/http/bun-serve-routes.test.ts
+++ b/test/js/bun/http/bun-serve-routes.test.ts
@@ -10,7 +10,7 @@ describe("path parameters", () => {
       port: 0,
       fetch: () => new Response("fallback"),
       routes: {
-        "/users/:id": (req: BunRequest<"/users/:id">) => {
+        "/users/:id": req => {
           return new Response(
             JSON.stringify({
               id: req.params.id,
@@ -431,3 +431,113 @@ it("throws a validation error when a route parameter name is duplicated", () =>
     });
   }).toThrow("Support for duplicate route parameter names is not yet implemented.");
 });
+
+it("fetch() is optional when routes are specified", async () => {
+  await using server = Bun.serve({
+    port: 0,
+    routes: { "/test": () => new Response("test") },
+  });
+
+  expect(await fetch(new URL("/test", server.url)).then(res => res.text())).toBe("test");
+  expect(await fetch(new URL("/test1", server.url)).then(res => res.status)).toBe(404);
+
+  server.reload({
+    routes: {
+      "/test": () => new Response("test2"),
+    },
+  });
+
+  expect(await fetch(new URL("/test", server.url)).then(res => res.text())).toBe("test2");
+});
+
+it("throws a validation error when passing invalid routes", () => {
+  expect(() => {
+    Bun.serve({ routes: { "/test": 123 } });
+  }).toThrowErrorMatchingInlineSnapshot(`
+    "'routes' expects a Record<string, Response | HTMLBundle | {[method: string]: (req: BunRequest) => Response|Promise<Response>}>
+
+    To bundle frontend apps on-demand with Bun.serve(), import HTML files.
+
+    Example:
+
+    \`\`\`js
+    import { serve } from "bun";
+    import app from "./app.html";
+
+    serve({
+      routes: {
+        "/index.json": Response.json({ message: "Hello World" }),
+        "/app": app,
+        "/path/:param": (req) => {
+          const param = req.params.param;
+          return Response.json({ message: \`Hello \${param}\` });
+        },
+        "/path": {
+          GET(req) {
+            return Response.json({ message: "Hello World" });
+          },
+          POST(req) {
+            return Response.json({ message: "Hello World" });
+          },
+        },
+      },
+
+      fetch(request) {
+        return new Response("fallback response");
+      },
+    });
+    \`\`\`
+
+    See https://bun.sh/docs/api/http for more information."
+  `);
+});
+
+it("throws a validation error when routes object is empty and fetch is not specified", async () => {
+  expect(() =>
+    Bun.serve({
+      port: 0,
+      routes: {},
+    }),
+  ).toThrowErrorMatchingInlineSnapshot(`
+    "Bun.serve() needs either:
+
+      - A routes object:
+         routes: {
+           "/path": {
+             GET: (req) => new Response("Hello")
+           }
+         }
+
+      - Or a fetch handler:
+         fetch: (req) => {
+           return new Response("Hello")
+         }
+
+    Learn more at https://bun.sh/docs/api/http"
+  `);
+});
+
+it("throws a validation error when routes object is undefined and fetch is not specified", async () => {
+  expect(() =>
+    Bun.serve({
+      port: 0,
+      routes: undefined,
+    }),
+  ).toThrowErrorMatchingInlineSnapshot(`
+    "Bun.serve() needs either:
+
+      - A routes object:
+         routes: {
+           "/path": {
+             GET: (req) => new Response("Hello")
+           }
+         }
+
+      - Or a fetch handler:
+         fetch: (req) => {
+           return new Response("Hello")
+         }
+
+    Learn more at https://bun.sh/docs/api/http"
+  `);
+});