@depup/h3 2.0.1-rc.17-depup.0

package/skills/h3/docs/guide/basics/nested-apps.md

@@ -0,0 +1,57 @@
+# Nested Apps
+
+> H3 has a native `mount` method for adding nested sub-apps to the main instance.
+
+Typically, H3 projects consist of several [Event Handlers](/guide/basics/handler) defined in one or multiple files (or even [lazy loaded](/guide/basics/handler#lazy-handlers) for faster startup times).
+
+It is sometimes more convenient to combine multiple `H3` instances or even use another HTTP framework used by a different team and mount it to the main app instance. H3 provides a native [`.mount`](/guide/api/h3#h3mount) method to facilitate this.
+
+## Nested H3 Apps
+
+H3 natively allows mounting sub-apps. When mounted, sub-app routes and middleware are **merged** with the base url prefix into the main app instance.
+
+```js
+import { H3, serve } from "h3";
+
+const nestedApp = new H3()
+  .use((event) => {
+    event.res.headers.set("x-api", "1");
+  })
+  .get("/**:slug", (event) => ({
+    pathname: event.url.pathname,
+    slug: event.context.params?.slug,
+  }));
+
+const app = new H3().mount("/api", nestedApp);
+```
+
+In the example above, when fetching the `/api/test` URL, `pathname` will be `/api/test` (the real path), and `slug` will be `/test` (wildcard param).
+
+> [!NOTE]
+> Global config and hooks won't be inherited from the nested app. Consider always setting them from the main app.
+
+## Nested Web Standard Apps
+
+Mount a `.fetch` compatible server instance like [Hono](https://hono.dev/) or [Elysia](https://elysiajs.com/) under the base URL.
+
+> [!NOTE]
+> Base prefix will be removed from `request.url` passed to the mounted app.
+
+```js
+import { H3 } from "h3";
+import { Hono } from "hono";
+import { Elysia } from "elysia";
+
+const app = new H3()
+  .mount(
+    "/elysia",
+    new Elysia().get("/test", () => "Hello Elysia!"),
+  )
+  .mount(
+    "/hono",
+    new Hono().get("/test", (c) => c.text("Hello Hono!")),
+  );
+```
+
+> [!TIP]
+> Similarly, you can mount an H3 app in [Hono](https://hono.dev/docs/api/hono#mount) or [Elysia](https://elysiajs.com/patterns/mount#mount-1).

package/skills/h3/docs/guide/basics/response.md

@@ -0,0 +1,162 @@
+# Sending Response
+
+> H3 automatically converts any returned value into a web response.
+
+Values returned from [Event Handlers](/guide/basics/handler) are automatically converted to a web [Response](https://developer.mozilla.org/en-US/docs/Web/API/Response) by H3.
+
+**Example:** Simple event handler function.
+
+```js
+const handler = defineHandler((event) => ({ hello: "world" }));
+```
+
+H3 smartly converts handler into:
+
+```js
+const handler = (event) =>
+  new Response(JSON.stringify({ hello: "world" }), {
+    headers: {
+      "content-type": "application/json;charset=UTF-8",
+    },
+  });
+```
+
+> [!TIP]
+> 🚀 H3 uses srvx `FastResponse` internally to optimize performances in Node.js runtime.
+
+If the returned value from event handler is a [Promise](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise) or from an [async function](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/async_function), H3 will wait for it to resolve before sending the response.
+
+If an error is thrown, H3 automatically handles it with error handler.
+
+<read-more></read-more>
+
+## Preparing Response
+
+Before returning a response in main handler, you can prepare response headers and status using [`event.res`](/guide/api/h3event#eventres).
+
+```js
+defineHandler((event) => {
+  event.res.status = 200;
+  event.res.statusText = "OK";
+  event.res.headers.set("Content-Type", "text/html");
+  return "<h1>Hello, World</h1>";
+});
+```
+
+> [!NOTE]
+> If a full [Response](https://developer.mozilla.org/en-US/docs/Web/API/Response/Response) value is returned, prepared status is discarded and headers will be merged/overriden. For performance reasons, it is best to only set headers only from final Response in this case.
+
+> [!NOTE]
+> If an Error happens, prepared status and headers will be discarded. The recommended way to include headers in error responses is via `new HTTPError({ headers })`. As a last resort for headers that need to be set implicitly before the error is known (e.g., CORS), you can use `event.res.errHeaders` — these will be merged into error responses automatically.
+
+## Response Types
+
+H3 smartly converts JavaScript values into web [Response](https://developer.mozilla.org/en-US/docs/Web/API/Response/Response).
+
+### JSON Serializable Value
+
+Returning a [JSON](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/JSON) serializable value (**object**, **array**, **number** or **boolean**), it will be stringified using [JSON.stringify()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/JSON/stringify) and sent with default `application/json` content-type.
+
+**Example:**
+
+```ts
+app.get("/", (event) => ({ hello: "world" }));
+```
+
+> [!TIP]
+> Returned objects with `.toJSON()` property can customize serialization behavior. Check [MDN docs](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/JSON/stringify) for more info.
+
+### String
+
+Returning a string value, sends it as plain text body.
+
+> [!NOTE]
+> If not setting `content-type` header, it can default to `text/plain;charset=UTF-8`.
+
+**Example:** Send HTML response.
+
+```ts
+app.get("/", (event) => {
+  event.res.headers.set("Content-Type", "text/html;charset=UTF-8");
+  return "<h1>hello world</h1>";
+});
+```
+
+You can also use `html` utility as shortcut.
+
+```js
+import { html } from "h3";
+
+app.get("/", () => html("<h1>hello world</h1>"));
+```
+
+### `Response`
+
+Returning a web [Response](https://developer.mozilla.org/en-US/docs/Web/API/Response/Response), sends-it as final reponse.
+
+**Example:**
+
+```ts
+app.get("/", (event) => new Response("Hello, world!", { headers: { "x-powered-by": "H3" } }));
+```
+
+> [!IMPORTANT]
+> When sending a `Response`, any [prepared headers](#preparing-response) that set before, will be merged as default headers. `event.res.{status,statusText}` will be ignored. For performance reasons, it is best to only set headers only from final `Response`.
+
+### `ReadableStream` or `Readable`
+
+Returning a [`ReadableStream`](https://developer.mozilla.org/en-US/docs/Web/API/ReadableStream) or Node.js [`Readable`](https://nodejs.org/api/stream.html#readable-streams) sends it as stream.
+
+### `ArrayBuffer` or `Uint8Array` or `Buffer`
+
+Send binary [ArrayBuffer](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer), [Uint8Array](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint8Array) or node [Buffer](https://nodejs.org/api/buffer.html#buffer).
+
+`content-length` header will be automatically set.
+
+### `Blob`
+
+Send a [`Blob`](https://developer.mozilla.org/en-US/docs/Web/API/Blob) as stream.
+
+`Content-type` and `Content-Length` headers will be automatically set.
+
+### `File`
+
+Send a [`File`](https://developer.mozilla.org/en-US/docs/Web/API/File) as stream.
+
+`Content-type`, `Content-Length` and `Content-Disposition` headers will be automatically set.
+
+## Special Types
+
+Some less commonly possible values for response types.
+
+### `null` or `undefined`
+
+Sends a response with empty body.
+
+> [!TIP]
+> If there is no `return` statement in event handler, it is same as `return undefined`.
+
+### `Error`
+
+Retuning an [`Error`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error) instance will send it.
+
+> [!IMPORTANT]
+> It is better to `throw` errors instead of returning them. This allows proper propagation from any nested utility.
+
+<read-more></read-more>
+
+### `BigInt`
+
+Value will be sent as stringified version of BigInt number.
+
+> [!NOTE]
+> Returning a JSON object, does not allows BigInt serialization. You need to implement `.toJSON`. Check [MDN docs](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/JSON/stringify) for more info.
+
+### `Symbol` or `Function`
+
+**Returning Symbol or Function has undetermined behavior.** Currently, H3 sends a string-like representation of unknown Symbols and Functions but this behavior might be changed to throw an error in the future versions.
+
+There are some internal known Symbols H3 internally uses:
+
+- `Symbol.for("h3.notFound")`: Indicate no route is found to throw a 404 error.
+- `Symbol.for("h3.handled")`: Indicate request is somehow handled and H3 should not continue (Node.js specific).

package/skills/h3/docs/guide/basics/routing.md

@@ -0,0 +1,92 @@
+# Routing
+
+> Each request is matched to one (most specific) route handler.
+
+## Adding Routes
+
+You can register route [handlers](/guide/basics/handler) to [H3 instance](/guide/api/h3) using [`H3.on`](/guide/api/h3#h3on), [`H3.[method]`](/guide/api/h3#h3method), or [`H3.all`](/guide/api/h3#h3all).
+
+> [!TIP]
+> Router is powered by [🌳 Rou3](https://github.com/h3js/rou3), an ultra-fast and tiny route matcher engine.
+
+**Example:** Register a route to match requests to the `/hello` endpoint with HTTP **GET** method.
+
+- Using [`H3.[method]`](/guide/api/h3#h3method)
+
+  ```js
+  app.get("/hello", () => "Hello world!");
+  ```
+
+- Using [`H3.on`](/guide/api/h3#h3on)
+
+  ```js
+  app.on("GET", "/hello", () => "Hello world!");
+  ```
+
+
+You can register multiple event handlers for the same route with different methods:
+
+```js
+app
+  .get("/hello", () => "GET Hello world!")
+  .post("/hello", () => "POST Hello world!")
+  .all("/hello", () => "Any other method!");
+```
+
+You can also use [`H3.all`](/guide/api/h3#h3all) method to register a route accepting any HTTP method:
+
+```js
+app.all("/hello", (event) => `This is a ${event.req.method} request!`);
+```
+
+## Dynamic Routes
+
+You can define dynamic route parameters using `:` prefix:
+
+```js
+// [GET] /hello/Bob => "Hello, Bob!"
+app.get("/hello/:name", (event) => {
+  return `Hello, ${event.context.params.name}!`;
+});
+```
+
+Instead of named parameters, you can use `*` for unnamed **optional** parameters:
+
+```js
+app.get("/hello/*", (event) => `Hello!`);
+```
+
+## Wildcard Routes
+
+Adding `/hello/:name` route will match `/hello/world` or `/hello/123`. But it will not match `/hello/foo/bar`.
+When you need to match multiple levels of sub routes, you can use `**` prefix:
+
+```js
+app.get("/hello/**", (event) => `Hello ${event.context.params._}!`);
+```
+
+This will match `/hello`, `/hello/world`, `/hello/123`, `/hello/world/123`, etc.
+
+> [!NOTE]
+> Param `_` will store the full wildcard content as a single string.
+
+## Route Meta
+
+You can define optional route meta when registering them, accessible from any middleware.
+
+```js
+import { H3 } from "h3";
+
+const app = new H3();
+
+app.use((event) => {
+  console.log(event.context.matchedRoute?.meta); // { auth: true }
+});
+
+app.get("/", (event) => "Hi!", { meta: { auth: true } });
+```
+
+<read-more>
+
+It is also possible to add route meta when defining them using `defineHandler` object syntax.
+</read-more>

package/skills/h3/docs/guide/index.md

@@ -0,0 +1,117 @@
+# Getting Started
+
+> Get started with H3.
+
+> [!IMPORTANT]
+> You are currently reading H3 v2 docs. See [v1.h3.dev](https://v1.h3.dev/) for legacy docs.
+
+## Overview
+
+⚡ H3 (short for H(TTP), pronounced as /eɪtʃθriː/, like h-3) is a lightweight, fast, and composable server framework for modern JavaScript runtimes. It is based on web standard primitives such as [Request](https://developer.mozilla.org/en-US/docs/Web/API/Request), [Response](https://developer.mozilla.org/en-US/docs/Web/API/Response), [URL](https://developer.mozilla.org/en-US/docs/Web/API/URL), and [Headers](https://developer.mozilla.org/en-US/docs/Web/API/Headers). You can integrate H3 with any compatible runtime or [mount](/guide/api/h3#h3mount) other web-compatible handlers to H3 with almost no added latency.
+
+H3 is designed to be extendable and composable. Instead of providing one big core, you start with a lightweight [H3 instance](/guide/api/h3) and then import built-in, tree-shakable [utilities](/utils) or bring your own for more functionality.
+Composable utilities has several advantages:
+
+- The server only includes used code and runs them exactly where is needed.
+- Application size can scale better. Usage of utilities is explicit and clean, with less global impact.
+- H3 is minimally opinionated and won't limit your choices.
+All utilities, share an [H3Event](/guide/api/h3event) context.
+
+<read-more></read-more>
+
+## Quick Start
+
+> [!TIP]
+> You try H3 online [on ⚡️ Stackblitz ](https://stackblitz.com/github/h3js/h3/tree/main/playground?file=server.mjs).
+
+Install `h3` as a dependency:
+
+<pm-install></pm-install>
+
+Create a new file for server entry:
+
+```ts [server.mjs]
+import { H3, serve } from "h3";
+
+const app = new H3().get("/", (event) => "⚡️ Tadaa!");
+
+serve(app, { port: 3000 });
+```
+
+Then, run the server using your favorite runtime:
+
+<code-group>
+
+```bash [node]
+node --watch ./server.mjs
+```
+
+```bash [deno]
+deno run -A --watch ./server.mjs
+```
+
+```bash [bun]
+bun run --watch server.mjs
+```
+</code-group>
+
+And tadaa! We have a web server running locally.
+
+### What Happened?
+
+Okay, let's now break down our hello world example.
+
+We first created an [H3](/guide/api/h3) app instance using `new H3()`:
+
+```ts
+const app = new H3();
+```
+
+[H3](/guide/api/h3) is a tiny class capable of [matching routes](/guide/basics/routing), [generating responses](/guide/basics/response) and calling [middleware](/guide/basics/middleware) and [global hooks](/guide/api/h3#global-hooks).
+
+Then we add a route for handling HTTP GET requests to `/` path.
+
+```ts
+app.get("/", (event) => {
+  return { message: "⚡️ Tadaa!" };
+});
+```
+
+<read-more></read-more>
+
+We simply returned an object. H3 automatically [converts](/guide/basics/response#response-types) values into web responses.
+
+<read-more></read-more>
+
+Finally, we use `serve` method to start the server listener. Using `serve` method you can easily start an H3 server in various runtimes.
+
+```js
+serve(app, { port: 3000 });
+```
+
+> [!TIP]
+> The `serve` method is powered by [💥 srvx](https://srvx.h3.dev/), a runtime-agnostic universal server listener based on web standards that works seamlessly with [Deno](https://deno.com/), [Node.js](https://nodejs.org/) and [Bun](https://bun.sh/).
+
+We also have [`app.fetch`](/guide/api/h3#h3fetch) which can be directly used to run H3 apps in any web-compatible runtime or even directly called for testing purposes.
+
+<read-more></read-more>
+
+```js
+import { H3, serve } from "h3";
+
+const app = new H3().get("/", () => "⚡️ Tadaa!");
+
+// Test without listening
+const response = await app.request("/");
+console.log(await response.text());
+```
+
+You can directly import `h3` library from CDN alternatively. This method can be used for Bun, Deno and other runtimes such as Cloudflare Workers.
+
+```js
+import { H3 } from "https://esm.sh/h3";
+
+const app = new H3().get("/", () => "⚡️ Tadaa!");
+
+export const fetch = app.fetch;
+```

package/skills/h3/docs/migration/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`.

package/skills/h3/docs/utils/community.md

@@ -0,0 +1,42 @@
+# Community
+
+> H3 utils from community.
+
+You can use external H3 event utilities made by the community.
+
+This section is placeholder for any new H3 version 2 compatible community library.
+
+
+
+> [!TIP]
+> 💛 PR is more than welcome to list yours.
+
+## `apitally`
+
+[Apitally](https://apitally.io/h3) is a simple API monitoring, analytics, and request logging tool with a plugin for H3. See setup guide [here](https://docs.apitally.io/frameworks/h3).
+
+<read-more></read-more>
+
+## `H3ravel Framework`
+
+[H3ravel Framework](https://h3ravel.toneflix.net) is a modern TypeScript runtime-agnostic web framework built on top of H3, designed to bring the elegance and developer experience of Laravel PHP to the JavaScript ecosystem. See the getting started guide [here](https://h3ravel.toneflix.net/guide/get-started).
+
+<read-more></read-more>
+
+## `Intlify`
+
+[Intlify](https://intlify.dev/) is a project that aims to improve Developer Experience in software internationalization. That project provides server-side frameworks, middleware, and utilities. About those, see the [here](https://github.com/intlify/srvmid)
+
+<read-more></read-more>
+
+## `Clear Router`
+
+Laravel-style routing system for H3 and Express.js. Clean route definitions, middleware support, and controller bindings with full TypeScript support.
+
+<read-more></read-more>
+
+## `unjwt`
+
+`unjwt` is a collection of low-level JWT utilities (JWS, JWE, JWK) built on the Web Crypto API, with zero runtime dependencies. It includes a dedicated H3 v2 adapter for header and cookie-based session management with support for encrypted (JWE) and signed (JWS) tokens.
+
+<read-more></read-more>