h3 2.0.1-rc.2 → 2.0.1-rc.21

package/dist/docs/2.examples/2.handle-session.md

@@ -0,0 +1,130 @@
+# Sessions
+
+> Remember your users using a session.
+
+A session is a way to remember users using cookies. It is a very common method for authenticating users or saving data about them, such as their language or preferences on the web.
+
+H3 provides many utilities to handle sessions:
+
+- `useSession` initializes a session and returns a wrapper to control it.
+- `getSession` initializes or retrieves the current user session.
+- `updateSession` updates the data of the current session.
+- `clearSession` clears the current session.
+Most of the time, you will use `useSession` to manipulate the session.
+
+## Initialize a Session
+
+To initialize a session, you need to use `useSession` in an [event handler](/guide/handler):
+
+```js
+import { useSession } from "h3";
+
+app.use(async (event) => {
+  const session = await useSession(event, {
+    password: "80d42cfb-1cd2-462c-8f17-e3237d9027e9",
+  });
+
+  // do something...
+});
+```
+
+> [!WARNING]
+> You must provide a password to encrypt the session.
+
+This will initialize a session and return an header `Set-Cookie` with a cookie named `h3` and an encrypted content.
+
+If the request contains a cookie named `h3` or a header named `x-h3-session`, the session will be initialized with the content of the cookie or the header.
+
+> [!NOTE]
+> The header take precedence over the cookie.
+
+## Get Data from a Session
+
+To get data from a session, we will still use `useSession`. Under the hood, it will use `getSession` to get the session.
+
+```js
+import { useSession } from "h3";
+
+app.use(async (event) => {
+  const session = await useSession(event, {
+    password: "80d42cfb-1cd2-462c-8f17-e3237d9027e9",
+  });
+
+  return session.data;
+});
+```
+
+Data are stored in the `data` property of the session. If there is no data, it will be an empty object.
+
+## Add Data to a Session
+
+To add data to a session, we will still use `useSession`. Under the hood, it will use `updateSession` to update the session.
+
+```js
+import { useSession } from "h3";
+
+app.use(async (event) => {
+  const session = await useSession(event, {
+    password: "80d42cfb-1cd2-462c-8f17-e3237d9027e9",
+  });
+
+  const count = (session.data.count || 0) + 1;
+  await session.update({
+    count: count,
+  });
+
+  return count === 0 ? "Hello world!" : `Hello world! You have visited this page ${count} times.`;
+});
+```
+
+What is happening here?
+
+We try to get a session from the request. If there is no session, a new one will be created. Then, we increment the `count` property of the session and we update the session with the new value. Finally, we return a message with the number of times the user visited the page.
+
+Try to visit the page multiple times and you will see the number of times you visited the page.
+
+> [!NOTE]
+> If you use a CLI tool like `curl` to test this example, you will not see the number of times you visited the page because the CLI tool does not save cookies. You must get the cookie from the response and send it back to the server.
+
+## Clear a Session
+
+To clear a session, we will still use `useSession`. Under the hood, it will use `clearSession` to clear the session.
+
+```js
+import { useSession } from "h3";
+
+app.use("/clear", async (event) => {
+  const session = await useSession(event, {
+    password: "80d42cfb-1cd2-462c-8f17-e3237d9027e9",
+  });
+
+  await session.clear();
+
+  return "Session cleared";
+});
+```
+
+H3 will send a header `Set-Cookie` with an empty cookie named `h3` to clear the session.
+
+## Options
+
+When to use `useSession`, you can pass an object with options as the second argument to configure the session:
+
+```js
+import { useSession } from "h3";
+
+app.use(async (event) => {
+  const session = await useSession(event, {
+    name: "my-session",
+    password: "80d42cfb-1cd2-462c-8f17-e3237d9027e9",
+    cookie: {
+      httpOnly: true,
+      secure: true,
+      sameSite: "strict",
+    },
+    maxAge: 60 * 60 * 24 * 7, // 7 days
+  });
+
+  return session.data;
+});
+```

package/dist/docs/2.examples/3.serve-static-assets.md

@@ -0,0 +1,66 @@
+# Static Assets
+
+> Serve static assets such as HTML, images, CSS, JavaScript, etc.
+
+H3 can serve static assets such as HTML, images, CSS, JavaScript, etc.
+
+To serve a static directory, you can use the `serveStatic` utility.
+
+```ts
+import { H3, serveStatic } from "h3";
+
+const app = new H3();
+
+app.use("/public/**", (event) => {
+  return serveStatic(event, {
+    getContents: (id) => {
+      // TODO
+    },
+    getMeta: (id) => {
+      // TODO
+    },
+  });
+});
+```
+
+This does not serve any files yet. You need to implement the `getContents` and `getMeta` methods.
+
+- `getContents` is used to read the contents of a file. It should return a `Promise` that resolves to the contents of the file or `undefined` if the file does not exist.
+- `getMeta` is used to get the metadata of a file. It should return a `Promise` that resolves to the metadata of the file or `undefined` if the file does not exist.
+They are separated to allow H3 to respond to `HEAD` requests without reading the contents of the file and to use the `Last-Modified` header.
+
+## Read files
+
+Now, create a `index.html` file in the `public` directory with a simple message and open your browser to http://localhost:3000. You should see the message.
+
+Then, we can create the `getContents` and `getMeta` methods:
+
+```ts
+import { stat, readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { H3, serve, serveStatic } from "h3";
+
+const app = new H3();
+
+app.use("/public/**", (event) => {
+  return serveStatic(event, {
+    indexNames: ["/index.html"],
+    getContents: (id) => readFile(join("public", id)),
+    getMeta: async (id) => {
+      const stats = await stat(join("public", id)).catch(() => {});
+      if (stats?.isFile()) {
+        return {
+          size: stats.size,
+          mtime: stats.mtimeMs,
+        };
+      }
+    },
+  });
+});
+
+serve(app);
+```
+
+The `getContents` reads the file and returns its contents, pretty simple. The `getMeta` uses `fs.stat` to get the file metadata. If the file does not exist or is not a file, it returns `undefined`. Otherwise, it returns the file size and the last modification time.
+
+The file size and last modification time are used to create an etag to send a `304 Not Modified` response if the file has not been modified since the last request. This is useful to avoid sending the same file multiple times if it has not changed.

package/dist/docs/2.examples/4.stream-response.md

@@ -0,0 +1,76 @@
+# Stream Response
+
+> Stream response to the client.
+
+Using stream responses It allows you to send data to the client as soon as you have it. This is useful for large files or long running responses.
+
+## Create a Stream
+
+To stream a response, you first need to create a stream using the [`ReadableStream`](https://developer.mozilla.org/en-US/docs/Web/API/ReadableStream) API:
+
+```ts
+const stream = new ReadableStream();
+```
+
+For the example, we will create a start function that will send a random number every 100 milliseconds. After 1000 milliseconds, it will close the stream:
+
+```ts
+let interval: NodeJS.Timeout;
+const stream = new ReadableStream({
+  start(controller) {
+    controller.enqueue("<ul>");
+
+    interval = setInterval(() => {
+      controller.enqueue("<li>" + Math.random() + "</li>");
+    }, 100);
+
+    setTimeout(() => {
+      clearInterval(interval);
+      controller.close();
+    }, 1000);
+  },
+  cancel() {
+    clearInterval(interval);
+  },
+});
+```
+
+## Send a Stream
+
+```ts
+import { H3 } from "h3";
+
+export const app = new H3();
+
+app.use((event) => {
+  // Set to response header to tell to the client that we are sending a stream.
+  event.res.headers.set("Content-Type", "text/html");
+  event.res.headers.set("Cache-Control", "no-cache");
+  event.res.headers.set("Transfer-Encoding", "chunked");
+
+  let interval: NodeJS.Timeout;
+  const stream = new ReadableStream({
+    start(controller) {
+      controller.enqueue("<ul>");
+
+      interval = setInterval(() => {
+        controller.enqueue("<li>" + Math.random() + "</li>");
+      }, 100);
+
+      setTimeout(() => {
+        clearInterval(interval);
+        controller.close();
+      }, 1000);
+    },
+    cancel() {
+      clearInterval(interval);
+    },
+  });
+
+  return stream;
+});
+```
+
+Open your browser to http://localhost:3000 and you should see a list of random numbers appearing every 100 milliseconds.
+
+Magic! 🎉

package/dist/docs/2.examples/5.validate-data.md

@@ -0,0 +1,193 @@
+# Validate Data
+
+> Ensure that your data are valid and safe before processing them.
+
+When you receive data on your server, you must validate them. By validate, we mean that the shape of the received data must match the expected shape. It's important because you can't trust the data coming from unknown sources, like a user or an external API.
+
+> [!WARNING]
+> Do not use type generics as a validation. Providing an interface to a utility like `readBody` is not a validation. You must validate the data before using it.
+
+## Utilities for Validation
+
+H3 provide some utilities to help you to handle data validation. You will be able to validate:
+
+- query with `getValidatedQuery`
+- params with `getValidatedRouterParams`.
+- body with `readValidatedBody`
+H3 doesn't provide any validation library but it does support schemas coming from a **Standard-Schema** compatible one, like: [Zod](https://zod.dev), [Valibot](https://valibot.dev), [ArkType](https://arktype.io/), etc... (for all compatible libraries please check [their official repository](https://github.com/standard-schema/standard-schema)). If you want to use a validation library that is not compatible with Standard-Schema, you can still use it, but you will have to use parsing functions provided by the library itself (refer to the [Safe Parsing](#safe-parsing) section below).
+
+> [!WARNING]
+> H3 is runtime agnostic. This means that you can use it in [any runtime](/adapters). But some validation libraries are not compatible with all runtimes.
+
+Let's see how to validate data with [Zod](https://zod.dev) and [Valibot](https://valibot.dev).
+
+### Validate Params
+
+You can use `getValidatedRouterParams` to validate params and get the result, as a replacement of `getRouterParams`:
+
+```js
+import { getValidatedRouterParams } from "h3";
+import * as z from "zod";
+import * as v from "valibot";
+
+// Example with Zod
+const contentSchema = z.object({
+  topic: z.string().min(1),
+  uuid: z.string().uuid(),
+});
+// Example with Valibot
+const contentSchema = v.object({
+  topic: v.pipe(v.string(), v.nonEmpty()),
+  uuid: v.pipe(v.string(), v.uuid()),
+});
+
+app.all(
+  // You must use a router to use params
+  "/content/:topic/:uuid",
+  async (event) => {
+    const params = await getValidatedRouterParams(event, contentSchema);
+    return `You are looking for content with topic "${params.topic}" and uuid "${params.uuid}".`;
+  },
+);
+```
+
+If you send a valid request like `/content/posts/123e4567-e89b-12d3-a456-426614174000` to this event handler, you will get a response like this:
+
+```txt
+You are looking for content with topic "posts" and uuid "123e4567-e89b-12d3-a456-426614174000".
+```
+
+If you send an invalid request and the validation fails, H3 will throw a `400 Validation Error` error. In the data of the error, you will find the validation errors you can use on your client to display a nice error message to your user.
+
+### Validate Query
+
+You can use `getValidatedQuery` to validate query and get the result, as a replacement of `getQuery`:
+
+```js
+import { getValidatedQuery } from "h3";
+import * as z from "zod";
+import * as v from "valibot";
+
+// Example with Zod
+const stringToNumber = z.string().regex(/^\d+$/, "Must be a number string").transform(Number);
+const paginationSchema = z.object({
+  page: stringToNumber.optional().default(1),
+  size: stringToNumber.optional().default(10),
+});
+
+// Example with Valibot
+const stringToNumber = v.pipe(
+  v.string(),
+  v.regex(/^\d+$/, "Must be a number string"),
+  v.transform(Number),
+);
+const paginationSchema = v.object({
+  page: v.optional(stringToNumber, 1),
+  size: v.optional(stringToNumber, 10),
+});
+
+app.use(async (event) => {
+  const query = await getValidatedQuery(event, paginationSchema);
+  return `You are on page ${query.page} with ${query.size} items per page.`;
+});
+```
+
+As you may have noticed, compared to the `getValidatedRouterParams` example, we can leverage validation libraries to transform the incoming data. In this case, we transform the string representation of a number into a real number, which is useful for things like content pagination.
+
+If you send a valid request like `/?page=2&size=20` to this event handler, you will get a response like this:
+
+```txt
+You are on page 2 with 20 items per page.
+```
+
+If you send an invalid request and the validation fails, H3 will throw a `400 Validation Error` error. In the data of the error, you will find the validation errors you can use on your client to display a nice error message to your user.
+
+### Validate Body
+
+You can use `readValidatedBody` to validate body and get the result, as a replacement of `readBody`:
+
+```js
+import { readValidatedBody } from "h3";
+import { z } from "zod";
+import * as v from "valibot";
+
+// Example with Zod
+const userSchema = z.object({
+  name: z.string().min(3).max(20),
+  age: z.number({ coerce: true }).positive().int(),
+});
+
+// Example with Valibot
+const userSchema = v.object({
+  name: v.pipe(v.string(), v.minLength(3), v.maxLength(20)),
+  age: v.pipe(v.number(), v.integer(), v.minValue(0)),
+});
+
+app.use(async (event) => {
+  const body = await readValidatedBody(event, userSchema);
+  return `Hello ${body.name}! You are ${body.age} years old.`;
+});
+```
+
+If you send a valid POST request with a JSON body like this:
+
+```json
+{
+  "name": "John",
+  "age": 42
+}
+```
+
+You will get a response like this:
+
+```txt
+Hello John! You are 42 years old.
+```
+
+If you send an invalid request and the validation fails, H3 will throw a `400 Validation Error` error. In the data of the error, you will find the validation errors you can use on your client to display a nice error message to your user.
+
+## Safe Parsing
+
+By default if a schema is directly provided as e second argument for each validation utility (`getValidatedRouterParams`, `getValidatedQuery`, and `readValidatedBody`) it will throw a `400 Validation Error` error if the validation fails, but in some cases you may want to handle the validation errors yourself. For this you should provide the actual safe validation function as the second argument, depending on the validation library you are using.
+
+Going back to the first example with `getValidatedRouterParams`, for Zod it would look like this:
+
+```ts
+import { getValidatedRouterParams } from "h3";
+import { z } from "zod/v4";
+
+const contentSchema = z.object({
+  topic: z.string().min(1),
+  uuid: z.string().uuid(),
+});
+
+app.all("/content/:topic/:uuid", async (event) => {
+  const params = await getValidatedRouterParams(event, contentSchema.safeParse);
+  if (!params.success) {
+    // Handle validation errors
+    return `Validation failed:\n${z.prettifyError(params.error)}`;
+  }
+  return `You are looking for content with topic "${params.data.topic}" and uuid "${params.data.uuid}".`;
+});
+```
+
+And for Valibot, it would look like this:
+
+```ts
+import { getValidatedRouterParams } from "h3";
+import * as v from "valibot";
+
+const contentSchema = v.object({
+  topic: v.pipe(v.string(), v.nonEmpty()),
+  uuid: v.pipe(v.string(), v.uuid()),
+});
+
+app.all("/content/:topic/:uuid", async (event) => {
+  const params = await getValidatedRouterParams(event, v.safeParser(contentSchema));
+  if (!params.success) {
+    // Handle validation errors
+    return `Validation failed:\n${v.summarize(params.issues)}`;
+  }
+  return `You are looking for content with topic "${params.output.topic}" and uuid "${params.output.uuid}".`;
+});
+```

package/dist/docs/3.migration/0.index/index.md

@@ -0,0 +1,200 @@
+# Migration guide for v1 to v2
+
+H3 version 2 includes some behavior and API changes that you need to consider applying when migrating.
+
+> [!NOTE]
+> Currently H3 v2 in beta stage. You can try with [nightly channel](/guide/advanced/nightly).
+
+> [!NOTE]
+> This is an undergoing migration guide and might be updated.
+
+> [!TIP]
+> H3 has a brand new documentation rewrite. Head to the new [Guide](/guide) section to learn more!
+
+## Latest Node.js and ESM-only
+
+> [!TIP]
+> H3 v2 requires Node.js >= 20.11 (latest LTS recommended) .
+
+If your application is currently using CommonJS modules (`require` and `module.exports`), You can still use `require("h3")` thanks to `require(esm)` supported in latest Node.js versions.
+
+You can alternatively use other compatible runtimes [Bun](https://bun.sh/) or [Deno](https://deno.com/).
+
+## Web Standards
+
+> [!TIP]
+> H3 v2 is rewritten based on web standard primitives ([`URL`](https://developer.mozilla.org/en-US/docs/Web/API/URL), [`Headers`](https://developer.mozilla.org/en-US/docs/Web/API/Headers), [`Request`](https://developer.mozilla.org/en-US/docs/Web/API/Request), and [`Response`](https://developer.mozilla.org/en-US/docs/Web/API/Response)).
+
+When using Node.js, H3 uses a compatibility layer ([💥 srvx](https://srvx.h3.dev/guide/node)) and in other runtimes uses native web compatibility APIs.
+
+Access to the native `event.node.{req,res}` is only available when running server in Node.js runtime.
+
+`event.web` is renamed to `event.req` (instance of web [Request](https://developer.mozilla.org/en-US/docs/Web/API/Request)).
+
+## Response Handling
+
+> [!TIP]
+> You should always explicitly **return** the response body or **throw** an error.
+
+If you were previously using methods below, you can replace them with `return` statements returning a text, JSON, stream, or web `Response` (h3 smartly detects and handles each):
+
+- `send(event, value)`: Migrate to `return <value>`.
+- `sendError(event, <error>)`: Migrate to `throw createError(<error>)`.
+- `sendStream(event, <stream>)`: Migrate to `return <stream>`.
+- `sendWebResponse(event, <response>)`: Migrate to `return <response>`.
+Other send utils that are renamed and need explicit `return`:
+
+- `sendNoContent(event)` / `return null`: Migrate to `return noContent()`.
+- `sendIterable(event, <value>)`: Migrate to `return iterable(<value>)`.
+- `sendProxy(event, target)`: Migrate to `return proxy(event, target)`.
+- `handleCors(event)`: Check return value and early `return` if handled(not `false`).
+- `serveStatic(event, content)`: Make sure to add `return` before.
+- `sendRedirect(event, location, code)`: Migrate to `return redirect(location, code)`.
+<read-more></read-more>
+
+## H3 and Router
+
+> [!TIP]
+> Router function is now integrated into the H3 core.
+>  Instead of `createApp()` and `createRouter()` you can use [`new H3()`](/guide/api/h3).
+
+Any handler can return a response. If middleware don't return a response, next handlers will be tried and finally make a 404 if neither responses. Router handlers can return or not return any response, in this case, H3 will send a simple 200 with empty content.
+
+<read-more></read-more>
+
+H3 migrated to a brand new route-matching engine ([🌳 rou3](https://rou3.h3.dev/)). You might experience slight (but more intuitive) behavior changes for matching patterns.
+
+**Other changes from v1:**
+
+- Middleware added with `app.use("/path", handler)` only matches `/path` (not `/path/foo/bar`). For matching all subpaths like before, it should be updated to `app.use("/path/**", handler)`.
+- The `event.path` received in each handler will have a full path without omitting the prefixes. use `withBase(base, handler)` utility to make prefixed app. (example: `withBase("/api", app.handler)`).
+- **`router.add(path, method: Method | Method[]` signature is changed to `router.add(method: Method, path)`**
+- `router.use(path, handler)` is deprecated. Use `router.all(path, handler)` instead.
+- `app.use(() => handler, { lazy: true })` is no supported anymore. Instead you can use `app.use(defineLazyEventHandler(() => handler), { lazy: true })`.
+- `app.use(["/path1", "/path2"], ...)` and `app.use("/path", [handler1, handler2])` are not supported anymore. Instead, use multiple `app.use()` calls.
+- `app.resolve(path)` removed.
+<read-more></read-more>
+
+<read-more></read-more>
+
+## Request Body
+
+> [!TIP]
+> Most of request body utilities can now be replaced with native `event.req.*` methods which is based on web [`Request`](https://developer.mozilla.org/en-US/docs/Web/API/Response) interface.
+
+`readBody(event)` utility will use [`JSON.parse`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/JSON/parse) or [`URLSearchParams`](https://developer.mozilla.org/en-US/docs/Web/API/URLSearchParams) for parsing requests with `application/x-www-form-urlencoded` content-type.
+
+- For text: Use [event.req.text()](https://developer.mozilla.org/en-US/docs/Web/API/Request/text).
+- For json: Use [event.req.json()](https://developer.mozilla.org/en-US/docs/Web/API/Request/json).
+- For formData: Use [event.req.formData()](https://developer.mozilla.org/en-US/docs/Web/API/Request/formData).
+- For stream: Use [event.req.body](https://developer.mozilla.org/en-US/docs/Web/API/Request/body).
+**Behavior changes:**
+
+- Body utils won't throw an error if the incoming request has no body (or is a `GET` method for example) but instead, return empty values.
+- Native `request.json` and `readBody` does not use [unjs/destr](https://destr.unjs.io) anymore. You should always filter and sanitize data coming from user to avoid [prototype-poisoning](https://medium.com/intrinsic-blog/javascript-prototype-poisoning-vulnerabilities-in-the-wild-7bc15347c96).
+
+## Cookie and Headers
+
+> [!TIP]
+H3 now natively uses standard web [`Headers`](https://developer.mozilla.org/en-US/docs/Web/API/Headers) for all utils.
+
+Header values are always a plain `string` now (no `null` or `undefined` or `number` or `string[]`).
+
+For the [`Set-Cookie`](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Set-Cookie) header, you can use [`headers.getSetCookie`](https://developer.mozilla.org/en-US/docs/Web/API/Headers/getSetCookie) that always returns a string array.
+
+## Other Deprecations
+
+H3 v2 deprecated some legacy and aliased utilities.
+
+### App and router utils
+
+- `createApp` / `createRouter`: Migrate to `new H3()`.
+
+### Error utils
+
+- `createError`/`H3Error`: Migrate to `HTTPError`
+- `isError`: Migrate to `HTTPError.isError`
+
+### Handler utils
+
+- `eventHandler`/`defineEventHandler`: Migrate to `defineHandler` (you can also directly use a function!).
+- `lazyEventHandler`: Migrate to `defineLazyEventHandler`.
+- `isEventHandler`: (removed) Any function can be an event handler.
+- `useBase`: Migrate to `withBase`.
+- `defineRequestMiddleware` and `defineResponseMiddleware` removed.
+
+### Request utils
+
+- `getHeader` / `getRequestHeader`: Migrate to `event.req.headers.get(name)`.
+- `getHeaders` / `getRequestHeaders`: Migrate to `Object.fromEntries(event.req.headers.entries())`.
+- `getRequestPath`: Migrate to `event.url.pathname`.
+- `getMethod`: Migrate to `event.req.method`.
+
+> [!NOTE]
+The following `H3Event` properties are deprecated in v2 and might be removed in a future version:
+
+> - `event.path` → use `event.url.pathname + event.url.search`
+> - `event.method` → use `event.req.method`
+> - `event.headers` → use `event.req.headers`
+> - `event.node` → use `event.runtime.node`
+
+### Response utils
+
+- `getResponseHeader` / `getResponseHeaders`: Migrate to `event.res.headers.get(name)`
+- `setHeader` / `setResponseHeader` / `setHeaders` / `setResponseHeaders`: Migrate to `event.res.headers.set(name, value)`.
+- `appendHeader` / `appendResponseHeader` / `appendResponseHeaders`: Migrate to `event.res.headers.append(name, value)`.
+- `removeResponseHeader` / `clearResponseHeaders`: Migrate to `event.res.headers.delete(name)`
+- `appendHeaders`: Migrate to `appendResponseHeaders`.
+- `defaultContentType`: Migrate to `event.res.headers.set("content-type", type)`
+- `getResponseStatus` / `getResponseStatusText` / `setResponseStatus`: Use `event.res.status` and `event.res.statusText`.
+
+### Node.js utils
+
+- `defineNodeListener`: Migrate to `defineNodeHandler`.
+- `fromNodeMiddleware`: Migrate to `fromNodeHandler`.
+- `toNodeListener`: Migrate to `toNodeHandler`.
+- `createEvent`: (removed): Use Node.js adapter (`toNodeHandler(app)`).
+- `fromNodeRequest`: (removed): Use Node.js adapter (`toNodeHandler(app)`).
+- `promisifyNodeListener` (removed).
+- `callNodeListener`: (removed).
+
+### Web Utils
+
+- `fromPlainHandler`: (removed) Migrate to Web API.
+- `toPlainHandler`: (removed) Migrate to Web API.
+- `fromPlainRequest` (removed) Migrate to Web API or use `mockEvent` util for testing.
+- `callWithPlainRequest` (removed) Migrate to Web API.
+- `fromWebRequest`: (removed) Migrate to Web API.
+- `callWithWebRequest`: (removed).
+
+### Body Utils
+
+- `readRawBody`: Migrate to `event.req.text()` or `event.req.arrayBuffer()`.
+- `getBodyStream` / `getRequestWebStream`: Migrate to `event.req.body`.
+- `readFormData` / `readMultipartFormData` / `readFormDataBody`: Migrate to `event.req.formData()`.
+
+### Other Utils
+
+- `isStream`: Migrate to `instanceof ReadableStream`.
+- `isWebResponse`: Migrate to `instanceof Response`.
+- `splitCookiesString`: Use `splitSetCookieString` from [cookie-es](https://github.com/unjs/cookie-es).
+- `MIMES`: (removed).
+
+### Type Exports
+
+> [!NOTE]
+There might be more type changes.
+
+- `App`: Migrate to `H3`.
+- `AppOptions`: Migrate to `H3Config`.
+- `_RequestMiddleware`: Migrate to `RequestMiddleware`.
+- `_ResponseMiddleware`: Migrate to `ResponseMiddleware`.
+- `NodeListener`: Migrate to `NodeHandler`.
+- `TypedHeaders`: Migrate to `RequestHeaders` and `ResponseHeaders`.
+- `HTTPHeaderName`: Migrate to `RequestHeaderName` and `ResponseHeaderName`.
+- `H3Headers`: Migrate to native `Headers`.
+- `H3Response`: Migrate to native `Response`.
+- `MultiPartData`: Migrate to native `FormData`.
+- `RouteNode`: Migrate to `RouterEntry`.
+  `CreateRouterOptions`: Migrate to `RouterOptions`.
+Removed type exports: `WebEventContext`, `NodeEventContext`, `NodePromisifiedHandler`, `AppUse`, `Stack`, `InputLayer`, `InputStack`, `Layer`, `Matcher`, `PlainHandler`, `PlainRequest`, `PlainResponse`, `WebHandler`.