jeasx 2.10.7 → 3.0.1

package/CHANGELOG.md

@@ -0,0 +1,1485 @@
+# Changelog
+
+## 2026-11-11 - Jeasx 3.0.1 released
+
+🔒 This patch release includes a security update for Fastify ([GHSA-3qgw-9275-xf8w](https://github.com/fastify/fastify/security/advisories/GHSA-3qgw-9275-xf8w)). Please update.
+
+### 🐛 Fixes
+
+- **`null` from a route now means "no response".** Before, a route returning
+  `null` sent an empty 200. Now it behaves like `undefined`: the next route
+  is tried and the 404 fallback applies.
+- **Dev server serves the same `dist` files as production.** In development,
+  a `dist` file is now hidden only when its last path segment is a route
+  output (`[name].ext`). Before, a file inside a bracketed directory, like
+  `[x].d/style.css`, was hidden in development but served in production.
+
+### 🐛 Fixes in `jsx-async-runtime`
+
+- **No more crash from deeply nested promises.** `jsx()` only guarded promises
+  one level deep in a plain object. A promise nested deeper (e.g.
+  `data={[{ p }]}`) could crash Node with an unhandled rejection when the
+  render failed on it. It is now marked as handled first.
+- **Streams are unlocked after rendering.** `readStream()` never called
+  `releaseLock()`, so a `ReadableStream` child stayed locked after it was
+  fully rendered. The lock is now released when the stream ends, like
+  `for await` does.
+
+### 📦 Dependency updates
+
+- `fastify@5.12.8`
+- `@fastify/send@4.2.1`
+- `jsx-async-runtime@3.0.1`
+
+## 2026-11-02 - Jeasx 3.0.0 released
+
+> **The promise you made.** Await anything, stream everything.
+
+🚀 Jeasx 3 streams your pages. JSX is now sent to the browser while it is
+still rendering, powered by `jsx-async-runtime@3`, which also renders about
+2x faster than v2. This release also hardens request routing, the build and
+the dev server.
+
+There are breaking changes in Jeasx and in `jsx-async-runtime`. Each one has
+a migration recipe below. Most projects only need these steps:
+
+1. Replace `{{ html: "..." }}` with `{html("...")}`.
+2. Replace `class`/`style` objects with strings.
+3. Move `this.errorHandler` to `setErrorHandler` in `jeasx.config.js`.
+4. If your `responseHandler` changes the HTML, read the stream into a string first.
+
+👀 Want to see it in action? [Jeasx Expo](https://expo.jeasx.dev) has many
+new examples that show off the new features, e.g.
+[Streaming HTML](https://expo.jeasx.dev/streaming),
+[Out-of-order streaming](https://expo.jeasx.dev/out-of-order) and
+[Server-Sent Events](https://expo.jeasx.dev/sse).
+
+### 💥 Breaking changes in Jeasx
+
+#### JSX responses are streamed, so `responseHandler` gets a stream
+
+Pages are rendered with `jsxToStream` instead of `jsxToString`. The browser
+gets the first bytes while slow parts of the page (e.g. awaited data) are
+still rendering. For JSX, the `payload` passed to `this.responseHandler` is
+now a `ReadableStream<string>` instead of a `string`.
+
+**Migration:** if your `responseHandler` only sets headers or passes the
+payload through, nothing changes. If it changes the HTML (e.g. to format or
+minify it), read the stream into a string first:
+
+```js
+this.responseHandler = async (payload) => {
+  if (payload instanceof ReadableStream) {
+    payload = (await Array.fromAsync(payload)).join("");
+  }
+  return typeof payload === "string" ? format(payload) : payload;
+};
+```
+
+Pages that are post-processed this way are not streamed.
+
+#### `this.errorHandler` was removed
+
+Errors thrown by routes and guards now go to Fastify's error handler. Jeasx
+no longer looks for `this.errorHandler`.
+
+**Migration:** register an error handler in `jeasx.config.js`. It runs for
+errors from all routes:
+
+```js
+// jeasx.config.js
+export default {
+  FASTIFY_SERVER: (fastify) =>
+    fastify.setErrorHandler(async (error, request, reply) => {
+      request.log.error(error);
+      reply.status(error.statusCode ?? 500).type("text/html; charset=utf-8");
+      return "<h1>Something went wrong</h1>";
+    }),
+};
+```
+
+Without your own handler, Fastify answers with a JSON error. `jeasx.config.js` is not compiled by esbuild by default, so it can't contain JSX. If you want JSX in your config, write it as `jeasx.config.jsx` and compile it with your own npm script:
+
+```sh
+esbuild jeasx.config.jsx --outfile=jeasx.config.js --platform=node --format=esm --jsx=automatic --jsx-import-source=jsx-async-runtime
+```
+
+**Errors while streaming:** the error handler only runs for errors thrown
+before the first chunk is sent, e.g. in a guard or before the route returns
+its JSX. Once streaming has started, the status and headers are already sent,
+and an error thrown by an async component cuts the page off. Wrap risky
+components in an error boundary that renders them to a string first:
+
+```jsx
+import { html, jsxToString } from "jsx-async-runtime";
+
+async function ErrorBoundary({ fallback, children }) {
+  try {
+    return html(await jsxToString.call(this, children));
+  } catch (error) {
+    this.request.log.error(error);
+    return fallback;
+  }
+}
+
+<ErrorBoundary fallback={<p>This section could not be loaded.</p>}>
+  <RiskyComponent />
+</ErrorBoundary>;
+```
+
+See [Catch errors](https://expo.jeasx.dev/error-handler) for all three cases.
+
+#### `request.path` is decoded
+
+`request.path` is now URL-decoded, e.g. `/caf%C3%A9` becomes `/café`.
+Backslashes become slashes, and repeated slashes are collapsed (`//a//b`
+becomes `/a/b`).
+
+**Migration:** remove `decodeURIComponent(request.path)` from your routes.
+Decoding twice fails for paths that contain a `%`. Use `request.url` if
+you need the raw path.
+
+#### The dev server only listens on `localhost`
+
+`jeasx dev` binds to `localhost`, so other machines on your network can't
+reach it. `jeasx start` still listens on all interfaces (`::`).
+
+**Migration:** if you run `jeasx dev` in a container or VM, or test from
+another device, set `HOST`:
+
+```sh
+HOST=:: npx jeasx dev
+```
+
+#### Missing imports in routes are errors
+
+Before, if a route imported a module that doesn't exist, the route was
+skipped as if it didn't exist (usually ending in a 404). Now the error is
+thrown, so you see the real cause.
+
+**Migration:** fix or remove the import that is reported.
+
+#### Changed responses
+
+- If no route answers and there is no `[404]` route, the response is a
+  `404` instead of an empty `200`.
+- Objects returned by guards are only used as props. They are never sent as
+  the response, even if no route answers.
+- Static files are only served for `GET` and `HEAD`. Other methods (e.g. a
+  `POST` to `/form`) go to your routes, even if a file with that path exists.
+- If a static file is missing or ignored (e.g. a dotfile), `[...path]` and
+  `[404]` routes answer instead of the plain error page of `@fastify/send`.
+- A `ReadableStream` or Node.js stream returned without a content type is
+  sent as `text/html; charset=utf-8`, like strings and buffers.
+
+**Migration:** set a status code or content type explicitly where you
+relied on the old behavior. For example, register a Fastify route in
+`FASTIFY_SERVER` for non-`GET` requests to a static file.
+
+#### `FASTIFY_SEND_OPTIONS.root` is always the project directory
+
+Jeasx passes file paths relative to the project directory, so a custom
+`root` broke file serving. It is now always set to the project directory.
+
+**Migration:** remove `root` from `FASTIFY_SEND_OPTIONS`.
+
+#### `dist` is cleaned before every build
+
+`jeasx build` and `jeasx dev` delete `dist` before building. This removes
+outputs of deleted routes, which could otherwise still be served.
+
+**Migration:** don't put files into `dist` by hand. Use `public` instead.
+
+### 🔒 Security
+
+- **Compiled routes were exposed in development:** server routes
+  (e.g. `/[index].js`), their sourcemaps and other outputs could be fetched
+  from `dist` as static files. This exposed server-side code. They are no
+  longer served, including Windows tricks like `/[index].js.` or
+  `/[index].js::$DATA`.
+- **Special routes can't be requested by name:** requests like `/[index]`,
+  `/[...guard]`, `/[...path]` or `/[--metadata--]` no longer call these
+  routes directly. The check ignores case, because case-insensitive file
+  systems (macOS, Windows) would otherwise resolve `/[--METADATA--]`.
+  `/a/404` is still answered by `/a/[404]`.
+- **Malformed paths are rejected:** paths with invalid URL encoding, null
+  bytes or `.`/`..` segments are rejected with `400`. Repeated slashes are
+  collapsed, so `//evil.com` can't be mistaken for another host
+  (e.g. in a `<base>` tag).
+- **Route and file lookups ignore inherited keys:** a path like
+  `/constructor` no longer matches properties of `Object.prototype`.
+- **Fewer leaked file handles:** file streams are closed when the response
+  ends or is aborted. This includes routes that send a stream with
+  `reply.send()`.
+- **In production, other outputs of server routes aren't static files:**
+  CSS or other files that esbuild writes for server routes
+  (e.g. `[index].css`) are no longer served. Before, only sourcemaps were
+  skipped.
+
+### ✨ New features
+
+- **Async config options:** all options in `jeasx.config.js`
+  (`ESBUILD_SERVER_OPTIONS`, `ESBUILD_BROWSER_OPTIONS`,
+  `FASTIFY_SERVER_OPTIONS`, `FASTIFY_SEND_OPTIONS`) and `FASTIFY_SERVER`
+  can be async. You can import build-only plugins lazily, so they aren't
+  loaded in production:
+
+  ```js
+  export default {
+    ESBUILD_BROWSER_OPTIONS: async () => ({
+      plugins: [(await import("esbuild-sass-plugin")).sassPlugin()],
+    }),
+  };
+  ```
+
+- **Dotfiles in production:** files like `public/.well-known/security.txt`
+  are now part of the production build. Whether they are served depends on
+  the `dotfiles` option of `FASTIFY_SEND_OPTIONS` (default: ignored), the
+  same as in development:
+
+  ```js
+  export default {
+    FASTIFY_SEND_OPTIONS: () => ({ dotfiles: "allow" }),
+  };
+  ```
+
+- **Graceful shutdown:** the server closes on `SIGINT` (Ctrl+C) and
+  `SIGTERM` and then exits. It stops cleanly in containers (where Node runs
+  as PID 1) and while the esbuild watcher is running. Press Ctrl+C a second
+  time to kill it if the shutdown hangs.
+
+### 🛠️ Fixes
+
+- `jeasx dev` waits for the first build before starting the server, so the
+  first requests don't fail on an empty `dist`. Build errors are logged and
+  the watcher keeps running.
+- If a file exists in both `dist` and `public`, `dist` wins in production,
+  as it does in development. Symbolic links are skipped in production builds.
+- Config, routes and metadata are imported with `pathToFileURL`, which
+  fixes paths on Windows and paths with special characters.
+- A directly requested `/a/404` page keeps its status only if it is answered
+  by `/a/[404]`. If a parent `[404]` route answers, the status is `404`.
+- File paths with special characters (e.g. `#` or `%`) are served correctly.
+- esbuild no longer forces colored output, so logs in CI and log files
+  don't contain color codes.
+- The docs in `env.js` explain the load order: a variable that is already
+  set is never overwritten, and `NODE_ENV` must come from the environment.
+
+### 📦 Updates to `jsx-async-runtime@3.0.0`
+
+Jeasx depends on `jsx-async-runtime` for all rendering, so these changes
+affect every Jeasx project. See the
+[full changelog](https://github.com/jeasx/jsx-async-runtime/blob/main/CHANGELOG.md)
+for every detail.
+
+#### 💥 Breaking changes
+
+**Raw markup needs `html()`**
+
+`{{ html: "..." }}` objects render nothing. This closes an injection path,
+e.g. through parsed JSON with an `html` key.
+
+```jsx
+// Before
+{
+  {
+    html: "<!DOCTYPE html>";
+  }
+}
+
+// After
+import { html } from "jsx-async-runtime";
+{
+  html("<!DOCTYPE html>");
+}
+```
+
+**Escaping can't be turned off**
+
+`this.jsxEscapeHTML = false` was removed.
+
+**Migration:** wrap trusted markup in `html()`. To pass trusted text through
+unescaped everywhere, use a `this.jsxToString` override that returns it as is.
+
+**`class` and `style` must be strings**
+
+Objects and arrays are no longer converted. They render as JSON, like other
+attributes, and TypeScript only accepts strings.
+
+```jsx
+// Before
+<div class={["card", { active }]} style={{ color, "font-size": "2em" }} />;
+
+// After (e.g. with clsx)
+import clsx from "clsx";
+<div class={clsx("card", { active })} style={`color: ${color}; font-size: 2em`} />;
+```
+
+**Components get `children` as written**
+
+As in React, a single child is passed as is, several children as an array,
+and there is no `children` prop without children. Before, `children` was
+always a flattened array without `null` and booleans.
+
+**Migration:** most components that only render `{children}` keep working.
+If you call array methods on `children`, normalize it first:
+
+```jsx
+function List({ children }) {
+  return (
+    <ul>
+      {[children ?? []].flat().map((child) => (
+        <li>{child}</li>
+      ))}
+    </ul>
+  );
+}
+```
+
+Generators passed as children are read at render time, so they can only be
+rendered once.
+
+**Other breaking changes**
+
+- **Text is plain values:** text children are strings, numbers or bigints
+  instead of `{ type: "textNode", text }`. The `textNode` type was removed.
+- **Only real elements render:** hand-built objects like
+  `{ type: "tag", tag: "b", props }` render nothing. Use `createElement`
+  instead. Copies of real elements (`{ ...element, tag: "i" }`) still render.
+- **Invalid component types throw:** a tag that is neither a string nor a
+  function (e.g. `undefined` from a missing import) fails with a `TypeError`
+  instead of rendering nothing. With the Jeasx error handling above, you now
+  see these errors.
+- **`jsxToString` can return synchronously:** it returns
+  `string | Promise<string>`. `await jsxToString(...)` keeps working.
+- **Void tags ignore children:** `<br>text</br>` renders `<br>`.
+- **Override scope:** a `this.jsxToString` override set by a component also
+  applies to the siblings that follow it.
+- **Exports:** the `Tag` type was renamed to `ElementNode`. `jsxsDEV` was
+  removed from `jsx-async-runtime/jsx-dev-runtime`.
+- **Stricter types:** `aria-*` attributes no longer accept booleans, and
+  `contenteditable`, `spellcheck`, `translate` and `writingsuggestions` no
+  longer accept `false`. Use strings like `aria-hidden="true"` or
+  `spellcheck="false"`. Add custom elements to `JSX.IntrinsicElementAttributes`
+  instead of `JSX.IntrinsicElements`.
+
+#### ✨ New features
+
+- **`jsxToStream`** renders to a `ReadableStream<string>`. Jeasx uses it for
+  all JSX responses. It sends what is rendered so far whenever rendering
+  waits for async work, splits large pages into ~16 KB chunks, waits for
+  slow clients and stops when the client disconnects.
+- **`isJsxNode`** checks whether a value is an element or `html()` markup
+  and narrows the type in TypeScript.
+- **More child types:**
+  - Promises: `<div>{fetchUser()}</div>`
+  - Iterables: `Set`, generators, `map.values().map(...)`
+  - Async iterables: async generator components and `ReadableStream`,
+    rendered in order as items arrive
+  - Bytes (`Uint8Array`, `Buffer`) as escaped UTF-8 text:
+    `<pre>{response.body}</pre>`
+  - Objects with their own `toString` (`Date`, `URL`, `Error`, your classes)
+    as escaped text
+  - Functions as render props:
+    `<Loader>{(data) => <p>{data}</p>}</Loader>`
+- **Promise attributes:** `<img src={loadImageUrl()} />`. All promise
+  attributes of a tag are awaited in parallel.
+- **Better types:** async components with a `Promise<JSX.Element>` return
+  type, `key` on every component, `null` attributes, and JSX types for
+  `"jsx": "react-jsxdev"`.
+
+#### 🔒 Security
+
+- Only markup created by `html()` is rendered raw.
+- Elements carry a Symbol marker, so JSON look-alikes such as
+  `{"type":"tag","tag":"script",...}` render nothing.
+- Attribute names with whitespace, quotes, `<`, `>`, `/`, `=`, `&` or control
+  characters are skipped, and so are invalid tag names (with their children).
+  Valid names like `onmouseover` or `script` still render, so allowlist
+  attributes and tags that come from untrusted input.
+- Keys inherited from a polluted `Object.prototype` are ignored.
+
+#### 🛠️ Fixes
+
+- Rejected promises in props no longer crash Node with an unhandled
+  rejection. The error goes to the render.
+- Streams that are never rendered (e.g. in a void tag or after a failed
+  render) are closed, so they don't keep connections or files open.
+- Functions and symbols in attributes are skipped. Event handlers no longer
+  print their source code.
+- `key` is never rendered, and components don't receive it in their props.
+- `createElement` no longer modifies the props you pass in.
+- Rendering without a context gives each render its own empty context, so
+  data no longer leaks between renders.
+- `escapeEntities` converts non-strings with `String()` before escaping.
+
+Dependency updates: `jsx-async-runtime@3.0.0`, `@types/node@26.6.6`
+
+## 2026-10-23 - Jeasx 2.10.7 released
+
+### Core changes
+
+- New: Routes and guards can return a web `Response` or `ReadableStream`,
+  which is served directly.
+
+- Fixed: File handles leaked when a guard or route responded before a
+  static file was served. The file stream is now always closed.
+
+- Security: Requesting a guard file by its literal path
+  (e.g. `/admin/[...guard]`) was treated as a static file request and
+  bypassed the guard. Guards now run for these requests as well.
+
+### Updates to `jsx-async-runtime`
+
+- Attribute rendering is about 1.5x faster, because it no longer builds
+  intermediate arrays.
+
+- Empty style objects and `null`, `undefined` or `false` style values
+  are no longer rendered.
+
+- `0` is now rendered when it is the only child (e.g. `<h1>{0}</h1>`).
+
+- `bigint` children are now rendered.
+
+- Arrays returned by components are now rendered.
+
+Dependency updates: `jsx-async-runtime@2.3.0`, `@fastify/send@4.2.0`
+
+## 2026-10-13 - Jeasx 2.10.6 released
+
+🎉 Security update for Fastify ([GHSA-389g-gv7q-r4x8](https://github.com/fastify/fastify/security/advisories/GHSA-389g-gv7q-r4x8)).
+
+This release adds a minor performance improvement by switching checks for guards which return additional props.
+
+Dependency updates: `fastify@5.12.7`, `@fastify/send@4.1.2`, `@types/node@26.6.5`
+
+## 2026-10-01 - Jeasx 2.10.5 released
+
+🎉 Security update for Fastify ([GHSA-4mh8-r7rc-xpvc](https://github.com/fastify/fastify/security/advisories/GHSA-4mh8-r7rc-xpvc)).
+
+Dependency updates: `fastify@5.12.5`, `@types/node@26.6.3`
+
+## 2026-09-11 - Jeasx 2.10.4 released
+
+🎉 Just some dependency updates...
+
+Dependency updates: `fastify@5.12.4`, `jsx-async-runtime@2.2.1`, `@types/node@26.5.1`
+
+## 2026-09-04 - Jeasx 2.10.3 released
+
+### 🚀 More efficient route handling
+
+The central method `generateRoutes` has been updated to use a JavaScript generator instead of building and checking an array of all routes. This change reduces unnecessary memory usage and computational overhead, as most routes are matched early in the sequence and no longer require being pushed to an array.
+
+### 🔒 Security updates
+
+This version addresses four security vulnerabilities in the `fastify` dependency:
+
+- [GHSA-9q9j-q6p8-xq58](https://github.com/fastify/fastify/security/advisories/GHSA-9q9j-q6p8-xq58)
+- [GHSA-hwr6-493r-vm6h](https://github.com/fastify/fastify/security/advisories/GHSA-hwr6-493r-vm6h)
+- [GHSA-p68q-wchp-6fh7](https://github.com/fastify/fastify/security/advisories/GHSA-p68q-wchp-6fh7)
+- [GHSA-667r-xxjv-c9mm](https://github.com/fastify/fastify/security/advisories/GHSA-667r-xxjv-c9mm)
+
+We strongly recommend updating to this version to ensure the security of your application.
+
+Dependency updates: `fastify@5.12.3`, `@types/node@26.4.1`
+
+## 2026-08-22 - Jeasx 2.10.2 released
+
+🎉 Security fixes for Fastify ([GHSA-w2qp-rph6-63g4](https://github.com/fastify/fastify/security/advisories/GHSA-w2qp-rph6-63g4) and [GHSA-3m5p-2c4r-xxw2](https://github.com/fastify/fastify/security/advisories/GHSA-3m5p-2c4r-xxw2))
+
+Dependency updates: `fastify@5.12.1`
+
+## 2026-08-15 - Jeasx 2.10.1 released
+
+🎉 Just a bunch of dependency updates...
+
+Dependency updates: `fastify@5.12.0`, `@fastify/send@4.1.1`, `esbuild@0.28.2`, `@types/node@26.2.0`
+
+## 2026-08-04 - Jeasx 2.10.0 released
+
+### 🎉 `BUILD_TIME` moved to userland
+
+As part of my ongoing goal to move features from the core into userland, I’ve removed the core-level `BUILD_TIME` variable. While this simplifies the core, I want to ensure your builds aren't affected. If you use `BUILD_TIME` for cache busting, you can now let `esbuild` handle it directly using the powerful [define option](https://esbuild.github.io/api/#define) in your `jeasx.config.js`:
+
+```js
+/** @type {() => import("esbuild").BuildOptions} */
+ESBUILD_SERVER_OPTIONS: () => ({
+  define: { "process.env.BUILD_TIME": `"${Date.now().toString(36)}"` },
+});
+```
+
+This configuration replaces all references to `process.env.BUILD_TIME` with a Base36 (a-z0-9) encoded timestamp as string (note the additional quotes above).
+
+I have also removed the automatic provision of `BROWSER_PUBLIC_` environment variables to frontend bundles. This gives you the freedom to define your own schema; simply add the appropriate define option to `ESBUILD_BROWSER_OPTIONS` to specify which variables should be available to the frontend.
+
+Dependency updates: `fastify@5.11.2`
+
+## 2026-07-30 - Jeasx 2.9.1 released
+
+### 🎉 Routine maintenance release.
+
+`BUILD_TIME` is now injected into the environment during the build process, before `jeasx.config.js` is loaded. This enables you to capture the build timestamp for use during runtime (e.g. for using it in [FASTIFY_SERVER_OPTIONS#rewriteUrl](https://fastify.dev/docs/latest/Reference/Server/#rewriteurl)).
+
+Dependency updates: `fastify@5.11.0`, `@types/node@26.1.2`
+
+## 2026-07-17 - Jeasx 2.9.0 released
+
+### ✨ Less is more... trimming the fat
+
+This release **removes** `@fastify/formbody`, `@fastify/cookie`, and `@fastify/multipart` as core dependencies. Since Jeasx is capable of powering serious, real-world projects without these dependencies, removing them keeps your project's footprint as small as possible. This allows you to enable them individually, only when your specific use case requires them.
+
+- **Forms:** Install `@fastify/formbody` if your project requires _POST_ form support.
+- **Cookies:** Install `@fastify/cookie` if you need to handle HTTP cookies.
+- **Uploads:** Install `@fastify/multipart` if your project handles file uploads.
+
+Jeasx is built on the philosophy of providing a powerful core while pushing customizations to the user level. By avoiding opinionated defaults, Jeasx gives you the freedom to build a setup that is uniquely your own.
+
+Need these features? No problem! Jeasx makes it easy to customize your stack. To get back to the exact setup from previous releases, just add these dependencies directly to your project:
+
+```bash
+npm install @fastify/formbody @fastify/cookie @fastify/multipart
+```
+
+Next, update your `jeasx.config.js` with the following configuration to customize your Fastify server instance:
+
+```js
+/** @type {(fastify: import("fastify").FastifyInstance) => import("fastify").FastifyInstance} */
+FASTIFY_SERVER: (fastify) =>
+  fastify
+    .register(import("@fastify/formbody"), {/* insert options from FASTIFY_FORMBODY_OPTIONS */})
+    .register(import("@fastify/multipart"), {/* insert options from FASTIFY_MULTIPART_OPTIONS */})
+    .register(import("@fastify/cookie"), {/* insert options from FASTIFY_COOKIE_OPTIONS */});
+```
+
+Because plugins like `@fastify/cookie` and `@fastify/multipart` extend the `request` and `reply` objects, you should add the following imports to `src/types.d.ts` (or a similar definition file in your project) to ensure proper TypeScript support for your editor:
+
+```js
+import "@fastify/cookie";
+import "@fastify/multipart";
+```
+
+This release also removes the additional encapsulation context from the Fastify initialization. This change allows for a more direct and flexible customization of the underlying Fastify instance.
+
+Dependency updates: `jsx-async-runtime@2.2.0`, `@types/node@26.1.1`
+
+## 2026-07-07 - Jeasx 2.8.1 released
+
+🎉 You can now access static file metadata in guards directly via `reply.file`. If a file exists for the requested path, this object will be pre-populated with `headers`, `statusCode`, and `stream` for the current file. This eliminates the need for manual checks when performing logic on static files, including:
+
+- Skipping basic authentication.
+- Dynamically modifying headers.
+- Replacing content on the fly.
+
+Check out the new [basic auth example](https://expo.jeasx.dev/basic-auth) for implementation details.
+
+Also refined type definitions in `serverless.ts` to improve code readability and maintainability.
+
+Dependency updates: `fastify@5.10.0`
+
+## 2026-07-03 - Jeasx 2.8.0 released
+
+### 🚀 Unified Asset & Route Handling
+
+This release completes the architectural transition of merging dynamic server routes and static browser assets into a common directory tree. While Jeasx 2.6 removed the strict directory separation, this version further unifies how these files are processed.
+
+Previously, browser assets were served directly by `@fastify/static`, while server routes were handled by the route handler. This created a limitation where server-side logic (like authentication or custom headers) couldn't be applied to static assets.
+
+With this release, all files - regardless of type - are now handled directly by the route handler. This introduces several major improvements:
+
+- **Enhanced Control:** You can now use guards to modify responses for static assets, such as adding security headers or implementing password protection.
+
+- **Hot-Reloading for Assets:** Static files in development mode are now picked up instantly. No application restarts are required to make new files accessible.
+
+- **Production Optimization & Security:** In production, static files are mapped into a metadata export at build time. This improves server startup performance by eliminating file globbing and provides robust protection against path traversal attacks.
+
+#### ⚠️ Important Migration Note
+
+To achieve these improvements, `@fastify/static` has been removed as a direct dependency in favor of `@fastify/send`. Since `@fastify/static` relied on `@fastify/send` internally, this change provides more flexibility while maintaining the same functionality with fewer dependencies.
+
+A minor configuration change is required to make your application work as expected. You'll need to change references in `jeasx.config.js` from `@fastify/static` to `@fastify/send` .
+
+```js
+  // BEFORE //
+    /** @type {() => import("@fastify/static").FastifyStaticOptions} */
+    FASTIFY_STATIC_OPTIONS: () => ({/* configuraton options */}),
+
+  // AFTER //
+  /** @type {() => import("@fastify/send").SendOptions} */
+  FASTIFY_SEND_OPTIONS: () => ({/* configuraton options */}),
+```
+
+Because the configuration options for `@fastify/static` and `@fastify/send` are almost identical, no configuration changes are required for most users.
+
+Dependency updates: `@fastify/send@4.1.0`, `@types/node@26.1.0`
+
+## 2026-06-28 - Jeasx 2.7.5 released
+
+🎉 This release focuses on internal improvements and codebase organization. I have renamed `esbuild.config.js` to `build.js` and `server.js` to `start.js` to more accurately reflect their roles within `cli.js`. The renamed scripts are intended for internal use and should not be called directly. If your current workflow requires calling them, please update your project configuration accordingly.
+
+Additionally, minor refactorings were applied to `cli.js` and `env.js` to improve maintainability.
+
+Dependency updates: `fastify@5.9.0`, `@types/node@26.0.1`
+
+## 2026-06-21 - Jeasx 2.7.4 released
+
+🎉 Introduced pre-calculation of all module paths during server startup for production environments. This provides a robust defense against path traversal attacks from malformed requests, even in scenarios where Fastify’s built-in path sanitization might fail.
+
+Optimized path processing by skipping empty segments directly, removing the overhead of filtering segments into new arrays before iteration.
+
+Improved the module loading logic for development mode to ensure better compatibility with Node.js and alternative JavaScript runtimes like Bun.
+
+Dependency updates: `@types/node@26.0.0`
+
+## 2026-06-12 - Jeasx 2.7.3 released
+
+🎉 Routine maintenance release.
+
+Dependency updates: `jsx-async-runtime@2.1.3`, `esbuild@0.28.1`, `@types/node@25.9.3`
+
+## 2026-06-10 - Jeasx 2.7.2 released
+
+🎉 This release introduces significant performance and memory optimizations:
+
+- The core `generateRoutes` method has been rewritten to improve execution speed and significantly reduce temporary array creation. This minimizes garbage collection overhead during high-load scenarios.
+
+- The internal cache has been migrated from a `Map` to a plain object to leverage engine-level optimizations for small, read-heavy collections. I've also added a missing type definition for the module cache.
+
+- The `.js` extension is now stripped from route export metadata during the build process, reducing the number of string operations required when resolving modules from the cache.
+
+## 2026-06-07 - Jeasx 2.7.1 released
+
+🎉 This patch release requires no changes to your project but introduces significant improvements to internal module handling: Previously, a dynamic runtime cache was used to resolve modules for routes. This cache stored entries for both existing and non-existent routes, leading to potential growth over time - despite a predefined maximum cache size.
+
+With this update, the cache strategy has been optimized for more efficient and sustainable memory usage: This release leverages [esbuild’s metadata](https://esbuild.github.io/api/#build-metadata) to generate a static metadata file at build time, containing all existing routes. This metadata is loaded during server startup, ensuring that only modules included in the routes list are loaded on the first request.
+
+The result? Fast cold starts, efficient handling of existing and non-existent routes (without caching overhead), and enhanced security. Since only modules generated at build time can be loaded, even in the unlikely case where a malformed request could bypass Fastify’s strict request sanitation, it cannot escape the `dist` directory.
+
+The changes above have no impact on your development workflow. You can continue creating new routes or modifying existing ones - your updates will be loaded automatically, without requiring a restart of the application.
+
+Dependency updates: `@types/node@25.9.2`
+
+## 2026-06-02 - Jeasx 2.7.0 released
+
+🎉 This release introduces an explicit configuration file named `jeasx.config.js`, replacing the previously used `.env.js`. This change improves clarity and usability for configuring `esbuild` and `Fastify` options, which could no longer be passed as environment variables in recent releases.
+
+To upgrade:
+
+- If you used `.env.js` before, just rename it to `jeasx.config.js`.
+- If you didn’t use `.env.js`, create a new file called `jeasx.config.js` in your project folder. Add the following code as default to get a reminder of all available configuration options:
+
+```js
+export default {
+  /** @type {() => import("esbuild").BuildOptions} */
+  // ESBUILD_SERVER_OPTIONS: () => ({}),
+  /** @type {() => import("esbuild").BuildOptions} */
+  // ESBUILD_BROWSER_OPTIONS: () => ({}),
+  /** @type {(fastify: import("fastify").FastifyInstance) => import("fastify").FastifyInstance} */
+  // FASTIFY_SERVER: (fastify) => fastify,
+  /** @type {() => import("fastify").FastifyServerOptions} */
+  // FASTIFY_SERVER_OPTIONS: () => ({}),
+  /** @type {() => import("@fastify/static").FastifyStaticOptions} */
+  // FASTIFY_STATIC_OPTIONS: () => ({}),
+  /** @type {() => import("@fastify/cookie").FastifyCookieOptions} */
+  // FASTIFY_COOKIE_OPTIONS: () => ({}),
+  /** @type {() => import("@fastify/formbody").FastifyFormbodyOptions} */
+  // FASTIFY_FORMBODY_OPTIONS: () => ({}),
+  /** @type {() => import("@fastify/multipart").FastifyMultipartOptions} */
+  // FASTIFY_MULTIPART_OPTIONS: () => ({}),
+};
+```
+
+If you’re using Docker, make sure to create an entry for `jeasx.config.js` in your `.dockerignore` file.
+
+**Please note:** Support for `.env.js` has been discontinued in this release to streamline and simplify the codebase. If you previously used `.env.js` to set or modify environment variables besides the existing configuration options, you can now do this directly in `jeasx.config.js` by modifying `process.env` using JavaScript.
+
+```js
+process.env.API_ENDPOINT = "https://expo.jeasx.dev/jokes/api/";
+
+export default {/* ... */};
+```
+
+Dependency updates: `@types/node@25.9.1`
+
+## 2026-05-14 - Jeasx 2.6.2 released
+
+🎉 This release moves the configuration for esbuild’s sourcemap settings from core to userland. Since there is no universal default that fits all environments and policies, this change allows for greater flexibility.
+
+To enable sourcemaps for debugging your code, configure `ESBUILD_SERVER_OPTIONS` or `ESBUILD_BROWSER_OPTIONS` in your `.env.js` file based on your specific needs. While I recommend using `inline` as the configuration value for simplicity, the optimal choice may depend on your setup and tooling.
+
+Please study the [esbuild documentation](https://esbuild.github.io/api/#sourcemap) for the different configuration options.
+
+```js
+/** @type {() => import("esbuild").BuildOptions} */
+ESBUILD_SERVER_OPTIONS: () => ({
+  sourcemap: "inline",
+});
+```
+
+## 2026-05-12 - Jeasx 2.6.1 released
+
+🎉 This release includes a small update to the `tsconfig.json` file: The `types` attribute has been adjusted from `["*"]` to `["node"]` to align with the TypeScript team’s best practices. This change ensures better type resolution and resolves a warning that appeared when using Zed as the editor.
+
+Dependency updates: `@types/node@25.7.0`
+
+## 2026-05-08 - Jeasx 2.6.0 released
+
+🎉 Back in the early days, Jeasx enforced a strict separation between browser and server code. This meant developers had to organize their projects into specific directories like `browser` and `routes`. Over time, this limitation was lifted, allowing for more flexible project structures. While you could freely arrange your application code in the `src` directory, the `dist` directory still maintained the separation between browser and server files.
+
+This created a significant challenge: [esbuild loaders](https://esbuild.github.io/api/#loader) (such as those for importing files or using CSS modules) couldn’t be applied to server routes. The reason? Assets generated for the server and stored in `dist/server` were inaccessible to the browser, making it impossible to leverage these powerful tools in server-side code.
+
+Here are the good news: everything in the `dist` folder is now organized exactly as you’ve structured your application, hard coded sub-directories for `browser` and `server` are gone for good. All files in the `dist` directory are delivered directly to the browser via `@fastify/static`, except the code for server routes (JavaScript files enclosed in square brackets) - this code is still handled on the server. Now you are free to utilize esbuild loaders for your routes and enjoy all the advanced esbuild configurations for bundling server-side code.
+
+### ⚠️ Required updates to `.env.js`
+
+Previously, common browser asset extensions (e.g., `.ttf, .woff2, .svg, .jpg`) were automatically treated as `external` by Jeasx. This meant they were excluded from the bundling process by esbuild. For example, font files or icons stored in the `public` directory and referenced in your bundled CSS files would not be processed by esbuild.
+
+Now, no extensions are marked as `external` by default anymore. If your build fails with an error like `ERROR: No loader is configured for ".woff2"`, you’ll need to explicitly mark the missing extensions as `external` in your `.env.js` configuration by updating the `ESBUILD_BROWSER_OPTIONS`.
+
+Also Jeasx no longer sets a default value for the esbuild `target` option. I recommend configuring it explicitly based on your project’s needs. If you don’t specify a value, esbuild will default to `esnext`.
+
+The example below restores the former esbuild settings used by Jeasx, ensuring a smooth transition to the current release.
+
+```js
+/** @type {() => import("esbuild").BuildOptions} */
+ESBUILD_BROWSER_OPTIONS: () => ({
+  // It’s best to start with an empty list and
+  // only add extensions that cause build errors.
+  external: [
+    "*.avif",
+    "*.gif",
+    "*.jpg",
+    "*.jpeg",
+    "*.png",
+    "*.svg",
+    "*.webp",
+    "*.eot",
+    "*.ttf",
+    "*.otf",
+    "*.woff",
+    "*.woff2",
+  ],
+  target: ["chrome130", "edge130", "firefox130", "safari18"],
+});
+```
+
+After the update, you should start using the [esbuild loader](https://esbuild.github.io/api/#loader) to handle assets. To help you get started, here’s an example of how you can import images directly in your server routes. Simply configure the `file` loader for `.jpg` files in your `.env.js` file:
+
+```js
+/** @type {() => import("esbuild").BuildOptions} */
+ESBUILD_SERVER_OPTIONS: () => ({
+  loader: { ".jpg": "file" },
+});
+```
+
+You can now import an image located next to your server route and reference it in your code. This way esbuild automatically hashes the image path, so you don’t need to manually update references - even with caching headers applied.
+
+```jsx
+import Image from "./image.jpg";
+
+export default function () {
+  return (
+    <figure>
+      <img src={Image} alt="Example image" />
+    </figure>
+  );
+}
+```
+
+If you encounter a TypeScript warning for the import, you can resolve it by adding a definition file (e.g., `jpg.d.ts`) to specify the correct typing.
+
+```ts
+declare module "*.jpg" {
+  const content: string;
+  export default content;
+}
+```
+
+Dependency updates: `jsx-async-runtime@2.1.2`, `@types/node@25.6.2`
+
+## 2026-04-24 - Jeasx 2.5.3 released
+
+🎉 Just dependency updates...
+
+Dependency updates: `@fastify/static@9.1.3`
+
+## 2026-04-20 - Jeasx 2.5.2 released
+
+🎉 This release resolves an issue where existing routes failed to load if a JavaScript error occurred during initialization (for example, when setting up a global scoped variable). Previously, this error was masked by returning a 404 route, causing the route to never be re-evaluated.
+
+## 2026-04-16 - Jeasx 2.5.1 released
+
+🎉 Upgrade to latest `@fastify/static` to fix [CVE-2026-6410](https://github.com/fastify/fastify-static/security/advisories/GHSA-pr96-94w5-mx2h) and [CVE-2026-6414](https://github.com/fastify/fastify-static/security/advisories/GHSA-x428-ghpx-8j92).
+
+Dependency updates: `@fastify/static@9.1.1`
+
+## 2026-04-15 - Jeasx 2.5.0 released
+
+🎉 This release removes all non-essential Fastify configuration options from the Jeasx core, aligning it more closely with Fastify’s well-chosen default settings.
+
+To maintain your previous behavior, I recommend making minor adjustments to your configuration via `.env.js`:
+
+```js
+export default {
+  // ...
+
+  FASTIFY_SERVER_OPTIONS: () => ({
+    logger: { level: process.env.NODE_ENV === "development" ? "error" : "info" },
+    // 'disableRequestLogging' should be removed.
+  }),
+
+  FASTIFY_MULTIPART_OPTIONS: () => ({
+    // Only relevant if you use file uploads in your project.
+    attachFieldsToBody: "keyValues",
+  }),
+
+  // ...
+};
+```
+
+Additionally, the configured Fastify logger is now used for error logging, replacing the previous use of `console.error`.
+
+This release also addresses [CVE-2026-33806](https://github.com/fastify/fastify/security/advisories/GHSA-247c-9743-5963) by upgrading to the latest Fastify version.
+
+Dependency updates: `fastify@5.8.5`, `@types/node@25.6.0`
+
+## 2026-04-09 - Jeasx 2.4.8 released
+
+🎉 Just some dependency updates...
+
+Dependency updates: `@fastify/multipart@10.0.0`, `@fastify/static@9.1.0`
+
+## 2026-04-04 - Jeasx 2.4.7 released
+
+🎉 Just some dependency updates...
+
+Dependency updates: `jsx-async-runtime@2.1.1`, `esbuild@0.28.0`, `@types/node@25.5.2`
+
+## 2026-04-02 - Jeasx 2.4.6 released
+
+🎉 This release updates the `tsconfig.json` settings to fully support the latest TypeScript 6 changes. Now, the latest version of VSCode runs smoothly without any warnings.
+
+Dependency updates: `esbuild@0.27.7`
+
+## 2026-03-25 - Jeasx 2.4.5 released
+
+🎉 Just a patch update to stay synced with latest `jsx-async-runtime`.
+
+Dependency updates: `jsx-async-runtime@2.1.0`
+
+## 2026-03-23 - Jeasx 2.4.4 released
+
+🎉 Just a patch release to update Fastify to fix [CVE-2026-3635](https://github.com/fastify/fastify/security/advisories/GHSA-444r-cwp2-x5xf).
+
+Dependency updates: `fastify@5.8.4`
+
+## 2026-03-14 - Jeasx 2.4.3 released
+
+🎉 Just some dependency updates...
+
+Dependency updates: `fastify@5.8.2`, `esbuild@0.27.4`, `@types/node@25.5.0`
+
+## 2026-03-05 - Jeasx 2.4.2 released
+
+🎉 Just a patch release to update Fastify to fix [CVE-2026-3419](https://github.com/fastify/fastify/security/advisories/GHSA-573f-x89g-hqp9).
+
+Jeasx uses from now on [trusted publishing for npm packages](https://docs.npmjs.com/trusted-publishers) to release new versions.
+
+Dependency updates: `fastify@5.8.1`, `jsx-async-runtime@2.0.3`
+
+## 2026-03-02 - Jeasx 2.4.1 released
+
+🎉 This release introduces route prop inheritance from guards. Guards can return objects whose entries are used as additional props for your routes. Previously, only props from the closest guard were used. With this update, props from all guards along the route are collected and passed down. If multiple guards provide props with the same key, the value from the guard nearest to the route takes precedence and overwrites earlier ones.
+
+Dependency updates: `@types/node@25.3.3`
+
+## 2026-02-20 - Jeasx 2.4.0 released
+
+🎉 This release is both a step forward and a step back: the recently introduced support for MDX has been removed from the core project. Jeasx aims to keep its core as lean as possible, so this change aligns with the project's overall goals. Since MDX is not essential for every Jeasx website or application, it makes sense to move it out of the core.
+
+Another key goal of Jeasx is to empower users to implement their own custom solutions in userland, providing the right tools to do so. In short, while MDX remains a fantastic technology for content-driven websites, Jeasx now lets you configure MDX support yourself through a much improved configuration system for its base technologies like esbuild and Fastify.
+
+For esbuild, two new configuration options are available: `ESBUILD_SERVER_OPTIONS` and `ESBUILD_BROWSER_OPTIONS`. These can be defined as functions in `.env.js` that return additional configuration settings for esbuild.
+
+Why use functions instead of plain objects for the configuration? Because using functions allows configurations to be created lazily - only when needed - which is especially helpful for more complex setups over time.
+
+If you want to use MDX with Jeasx, simply run `npm install @mdx-js/esbuild` and add the configuration below to `ESBUILD_SERVER_OPTIONS` in `.env.js`.
+
+If you've used `ESBUILD_BROWSER_TARGET` in the past, you have to move this configuration to `ESBUILD_BROWSER_OPTIONS` as shown below.
+
+```jsx
+import mdx from "@mdx-js/esbuild";
+
+export default {
+  /** @type {() => import("esbuild").BuildOptions} */
+  ESBUILD_SERVER_OPTIONS: () => ({
+    plugins: [
+      mdx({
+        development: process.env.NODE_ENV === "development",
+        jsxImportSource: "jsx-async-runtime",
+        elementAttributeNameCase: "html",
+        stylePropertyNameCase: "css",
+      }),
+    ],
+  }),
+
+  /** @type {() => import("esbuild").BuildOptions} */
+  ESBUILD_BROWSER_OPTIONS: () => ({
+    target: ["chrome130", "edge130", "firefox130", "safari18"],
+  }),
+};
+```
+
+The existing configuration options for Fastify (such as `FASTIFY_SERVER_OPTIONS`, `FASTIFY_COOKIE_OPTIONS`, `FASTIFY_MULTIPART_OPTIONS`, `FASTIFY_STATIC_OPTIONS`) now require a minor change: they must be defined as functions instead of plain objects.
+
+Additionally, you can now customize the fastify server instance using the optional `FASTIFY_SERVER` function. This function receives the created server instance and should return the modified version. This feature is especially useful when integrating existing Fastify plugins like `@fastify/compress`, as demonstrated below.
+
+```jsx
+import fastifyCompress from "@fastify/compress";
+
+const NODE_ENV_IS_DEVELOPMENT = process.env.NODE_ENV === "development";
+
+export default {
+  /** @type {(fastify: import("fastify").FastifyInstance) => import("fastify").FastifyInstance} */
+  FASTIFY_SERVER: (fastify) => fastify.register(fastifyCompress),
+
+  /** @type {() => import("fastify").FastifyServerOptions} */
+  FASTIFY_SERVER_OPTIONS: () => ({
+    disableRequestLogging: NODE_ENV_IS_DEVELOPMENT,
+    bodyLimit: 1024 * 1024,
+  }),
+
+  /** @type {() => import("@fastify/static").FastifyStaticOptions} */
+  FASTIFY_STATIC_OPTIONS: () => ({
+    immutable: !NODE_ENV_IS_DEVELOPMENT,
+    maxAge: NODE_ENV_IS_DEVELOPMENT ? 0 : "365d",
+  }),
+};
+```
+
+Another notable change is that the fallback content-type (`text/html`) for routes is now set as late as possible. This means you can return plain JavaScript objects from routes, which will be automatically sent as `application/json` by default - without needing to explicitly specify the content-type in your code. This update brings Jeasx in line with Fastify’s default behavior.
+
+Additionally, you can now define routes directly from simple `*.json` or `*.txt` files - perfect for creating static endpoints like a health check or a `robots.txt` file right in your routes folder.
+
+Dependency updates: `@types/node@25.3.0`
+
+## 2026-02-12 - Jeasx 2.3.2 released
+
+🎉 Upgraded to @types/node@25, enabling seamless development with Node 25 while maintaining compatibility for Node 24 users.
+
+Dependency updates: `esbuild@0.27.3`, `@types/node@25.2.3`
+
+## 2026-02-04 - Jeasx 2.3.1 released
+
+🎉 Just a patch release to update Fastify to fix [CVE-2026-25224](https://github.com/fastify/fastify/security/advisories/GHSA-mrq3-vjjr-p77c).
+
+Additionally, I performed minor refactorings identified by [oxlint](https://oxc.rs/docs/guide/usage/linter.html) and replaced `prettier` with [oxfmt](https://oxc.rs/docs/guide/usage/formatter), a high-performance formatter optimized for the JavaScript ecosystem.
+
+Dependency updates: `fastify@5.7.4`, `@types/node@24.10.10`
+
+## 2026-01-30 - Jeasx 2.3.0 released
+
+🎉 This release introduces support for [MDX](https://mdxjs.com), enabling you to seamlessly embed JSX within Markdown content. Just create a route with a `.mdx` extension, and you’re all set to enhance your websites and blogs with Markdown enriched by dynamic JSX components.
+
+```jsx
+import Layout from "./Layout";
+
+<Layout title="MDX - Markdown for the component era">
+  # MDX as content companion alongside JSX You can easily access existing `props` in MDX: - Current
+  url: {props.request.url}
+</Layout>;
+```
+
+You can also create MDX-based components for use within JSX by importing them with their full `.mdx` file extension into your JSX routes or components.
+
+Since MDX supports a variety of plugins - and Jeasx provides only the MDX core to stay focused on infrastructure while letting users handle customization - the overall configuration for Jeasx has been significantly improved. Now, the configuration object from an `.env.js` file is imported directly into both the build process and server runtime, allowing you to use package imports seamlessly. Previously, (de)serializing the configuration via `process.env` restricted this capability and limited advanced setups.
+
+**Please note:** Variables loaded from `.env.js` now consistently overwrite any existing environment variables. This ensures predictable and consistent behavior across your configuration.
+
+Here’s an example of how to configure the MDX engine: if you want to enable GitHub-flavored Markdown (`remark-gfm`), add syntax highlighting (`rehype-prism-plus`), and generate IDs for your headings (`rehype-slug`), you can install and configure these plugins accordingly in `.env.js`.
+
+```js
+import rehypePrismPlus from "rehype-prism-plus";
+import rehypeSlug from "rehype-slug";
+import remarkGFM from "remark-gfm";
+
+export default {
+  /** @type import("@mdx-js/esbuild").Options */
+  ESBUILD_MDX_OPTIONS: {
+    remarkPlugins: [[remarkGFM, { singleTilde: false }]],
+    rehypePlugins: [rehypePrismPlus, [rehypeSlug, { prefix: "jeasx-" }]],
+  },
+  //...
+};
+```
+
+For a full overview of available configuration options and plugins, check out the excellent documentation of [@mdx-js/esbuild](https://mdxjs.com/packages/esbuild).
+
+**Please note:** The update to the Jeasx configuration introduced a minor change in how `ESBUILD_BROWSER_TARGET` is specified to ensure consistency across the configuration. Previously, a comma-separated string was accepted and parsed as customization. Going forward, you must provide a proper JSON array (or its stringified form when using traditional `.env` files or the process environment).
+
+```js
+export default {
+  /** @type import("esbuild").BuildOptions["target"] */
+  ESBUILD_BROWSER_TARGET: ["chrome130", "edge130", "firefox130", "safari18"],
+  //...
+};
+```
+
+Dependency updates: `fastify@5.7.2`, `@fastify/multipart@9.4.0`
+
+## 2026-01-17 - Jeasx 2.2.2 released
+
+🎉 This release now preserves the original status code when a 404 page is accessed directly (defaults to 200). This improvement makes it easier to use Jeasx as a static site generator and to fetch the 404 page with common tools for saving it to a file system.
+
+While Jeasx is fundamentally a server-side rendering framework, there are valid use cases where serving a static page alone is sufficient. For example, you can use `wget` to download a Jeasx website to a www-directory with just a single line:
+
+```bash
+wget --mirror --page-requisites --no-host-directories --directory-prefix=www http://localhost:3000 http://localhost:3000/404
+```
+
+Have a look at the [Dockerfile](https://github.com/jeasx/jeasx-website/blob/main/Dockerfile) of the Jeasx website to see how things can be wired up for serving a static export with Caddy as web server.
+
+If you want to restore the old behaviour (directly calling /404 resulting in status code 404), you can simple add `reply.status(404)` to your `/[404]` handler.
+
+Dependency updates: `fastify@5.7.1`, `@fastify/static@9.0.0`, `@types/node@24.10.9`
+
+## 2025-12-21 - Jeasx 2.2.1 released
+
+🎉 Just a patch release with a minor cleanup for explicit path joins in `serverless.ts`.
+
+Dependency updates: `esbuild@0.27.2`, `jsx-async-runtime@2.0.2`, `@types/node@24.10.4`
+
+## 2025-12-01 - Jeasx 2.2.0 released
+
+🎉 This release introduces a more flexible configuration approach for the underlying Fastify server. You can now customize all Fastify options (including those for all used plugins) according to your needs, without having to use the formerly fixed and very restrictive set of environment variables. This change was made to eliminate the need for increasingly specific environment variables to customise the default behaviour of Jeasx.
+
+**Breaking change**: The previously supported environment variables (`FASTIFY_​BODY_​LIMIT, FASTIFY_​DISABLE_​REQUEST_​LOGGING, FASTIFY_​REWRITE_​URL, FASTIFY_​STATIC_​HEADERS, FASTIFY_​TRUST_​PROXY, FASTIFY_​MULTIPART_​ATTACH_​FIELDS_​TO_​BODY`) have been completely removed. While this may seem inconvenient for a minor release, the process of migrating your setup to the new configuration approach usually takes less than a minute. This streamlines the code base and documentation, as these features are presumably seldom used.
+
+To configure Fastify (or a specific plugin), you can now use simple JSON objects which mirror the corresponding Fastify options. Have a look at the linked Fastify documentation for a reference of all existing options:
+
+- [`FASTIFY_SERVER_OPTIONS`](https://fastify.dev/docs/latest/Reference/Server/)
+- [`FASTIFY_COOKIE_OPTIONS`](https://github.com/fastify/fastify-cookie#options)
+- [`FASTIFY_FORMBODY_OPTIONS`](https://github.com/fastify/fastify-formbody#options)
+- [`FASTIFY_MULTIPART_OPTIONS`](https://github.com/fastify/fastify-multipart#options)
+- [`FASTIFY_STATIC_OPTIONS`](https://github.com/fastify/fastify-static#options)
+
+To optimise the developer experience, it is highly recommended that you use the recently introduced `.env.js` file to provide these configuration options. Alternatively, you can also provide them via `.env` or your process environment. Jeasx comes with a minimal set of reasonable [Fastify defaults](https://github.com/jeasx/jeasx/blob/main/serverless.ts), but you can also overwrite them if necessary.
+
+Some Fastify options, such as `rewriteUrl` or `setHeaders`, take a function as a parameter. Jeasx supports this use case by deserialising the stringified function code when the server starts up.
+
+### Example configuration
+
+```js
+const NODE_ENV_IS_DEVELOPMENT = process.env.NODE_ENV === "development";
+
+export default {
+  /** @type import("fastify").FastifyServerOptions */
+  FASTIFY_SERVER_OPTIONS: {
+    disableRequestLogging: NODE_ENV_IS_DEVELOPMENT,
+    bodyLimit: 2 * 1024 * 1024,
+    rewriteUrl: (req) => String(req.url).replace(/^\/jeasx/, ""),
+  },
+
+  /** @type import("@fastify/static").FastifyStaticOptions */
+  FASTIFY_STATIC_OPTIONS: {
+    maxAge: NODE_ENV_IS_DEVELOPMENT ? 0 : "365d",
+  },
+
+  /** @type import("@fastify/cookie").FastifyCookieOptions */
+  // FASTIFY_COOKIE_OPTIONS: {},
+
+  /** @type import("@fastify/formbody").FastifyFormbodyOptions */
+  // FASTIFY_FORMBODY_OPTIONS: {},
+
+  /** @type import("@fastify/multipart").FastifyMultipartOptions */
+  // FASTIFY_MULTIPART_OPTIONS: {},
+};
+```
+
+Another improvement has been made by introducing an automatic approach to determine the maximum size of the internal route cache. Depending on the amount of free memory available at startup, the maximum number of cache entries is calculated. This approach strikes a balance, ensuring the cache is large enough for large-scale projects while keeping maximum memory consumption within reasonable limits given the available resources. This means that you no longer need to worry about providing ~~`JEASX_ROUTE_CACHE_LIMIT`~~ via the environment.
+
+Dependency updates: `@types/node@24.10.1`
+
+## 2025-11-10 - Jeasx 2.1.1 released
+
+🎉 Enhanced configuration for @fastify/static, so you can serve pre-compressed static files (see [fastify docs](https://github.com/fastify/fastify-static?tab=readme-ov-file#precompressed)) from `public` and `dist/browser`. Just run `gzip -rk public dist/browser` as post build for gzipping your static assets. This might be useful if you don't want to run a reverse proxy in front of your Jeasx application and serve compressed files nevertheless. Setting up compression for dynamic content can be wired up in userland via a root guard:
+
+```js
+import { promisify } from "node:util";
+import { gzip } from "node:zlib";
+
+export default function ({ request, reply }) {
+  this.responseHandler = (payload) => {
+    if (typeof payload === "string" && request.headers["accept-encoding"]?.includes("gzip")) {
+      reply.header("content-encoding", "gzip");
+      return promisify(gzip)(payload);
+    } else {
+      return payload;
+    }
+  };
+}
+```
+
+Updated `moduleResolution` to `bundler` in `tsconfig.json`.
+
+Dependency updates: `jsx-async-runtime@2.0.1`, `fastify@5.6.2`, `esbuild@0.27.0`, `@types/node@24.9.2`
+
+## 2025-10-28 - Jeasx 2.1.0 released
+
+🎉 Environment vars can now be loaded from a JavaScript file (`.env.js`) additionally to existing .env-files. This allows enhanced environment setups depending on your workflows.
+
+Node 24 (LTS) is the official default runtime from now on.
+
+Dependency updates: `@fastify/multipart@9.3.0`, `@fastify/static@8.3.0`, `@types/node@24.9.1`
+
+## 2025-10-15 - Jeasx 2.0.1 released
+
+🎉 This releases fixes status codes for fallback 404 routes. Due to an unnoticed bug introduced by a minor refactoring, 404-routes were delivered with `status=200`, now it is the correct `status=404` again. This might impact your SEO score, so an update is highly recommended.
+
+Dependency updates: `esbuild@0.25.11`
+
+## 2025-10-12 - Jeasx 2.0.0 released
+
+🎉 Approximately one year after the release of Jeasx 1.0 I'm proud to announce the release of Jeasx 2.0.
+
+It's a funny story... every time I think Jeasx is feature-complete, there is still some more room to improve. Although the main idea behind Jeasx development still holds true: focus on a lean and stable core and let developers do all their magic in userland.
+
+This release is focused on security and comes with a major breaking change: all HTML markup is escaped by default from now on, so you don't have to escape dangerous user input on your own anymore. This way the developer experience is improved and the actual performance costs for automatic escaping are neglible due to the reuse of the highly optimized fast-escape-html library.
+
+If you need to include literal HTML in your JSX templates (e.g. HTML snippets from a CMS), you can use a special object syntax to opt out of escaping: `{{ html: "<p>Some HTML from a CMS</p>" }}`
+
+If you want to migrate from Jeasx 1.0 to Jeasx 2.0 with automatic HTML escaping enabled, you'll need to remove all calls to #escapeEntities() and modify the HTML declaration in your layouts (`{{ html: <!DOCTYPE html>" }}`). Then you should check where you need to render literal HTML (or other code) and apply the required changes to opt out of escaping (e.g. `<div>{ wysiwygContent }</div>; to <div>{{ html: wysiwygContent }}</div>`).
+
+If you want to restore the non-escaping behaviour of Jeasx &lt; v2, you can set `jsxEscapeHTML = false` in the root guard. This way HTML escaping is disabled globally.
+
+Another internal change is the renaming of the directories in the output directory (`dist`): `routes` is now called `server` alongside the `browser` directory.
+
+Dependency updates: `jsx-async-runtime@2.0.0, @types/node@22.18.10`
+
+## 2025-09-29 - Jeasx 1.9.0 released
+
+🎉 This release drops the constraint that you had to put all routes into a dedicated routes-directory and all JavaScript & CSS into a dedicated browser-directory. From now on you can use any directory layout in your projects as you like. You can still use the proven `browser/routes` layout, but you don't have to.
+
+This feature enables the co-location of server and browser code in the same directory which might be a better default for your workflows.
+
+The only remaining constraint is to mark server routes with brackets (e.g. `[news].jsx`) and browser-bundled assets as index-files (e.g. `index.js` or `index.css`).
+
+Please note: This feature is enabled by dropping the hard coded outbase-directories in the esbuild configuration. If the outbase directory isn't specified, it defaults to the lowest common ancestor directory among all input entry point paths.
+
+If you run into an edge case (e.g. your browser bundles won't load anymore), here's how to fix it: if you store all your assets in browser/assets and request your assets via `/assets/...`, this won't work anymore, because assets is now the lowest common ancestor directory and is removed by esbuild. Simple fix: just put an empty `index.js` into browser directory, so this directory is lowest common ancestor directory again.
+
+Bumbed the default `ESBUILD_BROWSER_TARGET` to `"chrome130", "edge130", "firefox130", "safari18"`.
+
+Dependency updates: `fastify@5.6.1, esbuild@0.25.10, @types/node@22.18.6`
+
+## 2025-09-11 - Jeasx 1.8.6 released
+
+🎉 This release bumps dependencies to the latest and greatest versions.
+
+Dependency updates: `fastify@5.6.0, fastify/multipart@9.2.1, @types/node@22.18.1`
+
+## 2025-08-13 - Jeasx 1.8.5 released
+
+🎉 This release bumps dependencies to the latest and greatest versions.
+
+Dependency updates: `fastify@5.5.0, jsx-async-runtime@1.0.4, esbuild@0.25.9, @types/node@22.17.1`
+
+## 2025-08-03 - Jeasx 1.8.4 released
+
+🎉 This release bumps dependencies to the latest and greatest versions.
+
+Dependency updates: `esbuild@0.25.8, @types/node@22.17.0`
+
+## 2025-07-11 - Jeasx 1.8.3 released
+
+🎉 This release bumps dependencies to the latest and greatest versions.
+
+Dependency updates: `jsx-async-runtime@1.0.3, esbuild@0.25.6, @types/node@22.16.3`
+
+## 2025-06-13 - Jeasx 1.8.2 released
+
+🎉 This release changes the default options for @fastify/multipart. From now on the default for `attachFieldsToBody` is `keyValues` which provides all data for form body requests (e.g. uploads) directly via request.body. Have a look at the Fastify documentation for code examples and options.
+
+This change makes the required code for handling form body requests much easier:
+
+```js
+// Change this code...
+const file = await request.file();
+const upload = await file.toBuffer();
+const format = file.fields["format"]["value"];
+
+// ... to this code.
+const upload = request.body["upload"];
+const format = request.body["format"];
+```
+
+Please note: This change might break your code. If you want to revert to the old behaviour, you can set the following environment variable: `FASTIFY_​MULTIPART_​ATTACH_​FIELDS_​TO_​BODY=false`
+
+Dependency updates: `fastify@5.4.0, @types/node@22.15.31`
+
+## 2025-05-28 - Jeasx 1.8.1 released
+
+🎉 Just some dependency updates...
+
+Dependency updates: `jsx-async-runtime@1.0.2, fastify@5.3.3, fastify/static@8.2.0, esbuild@0.25.5, @types/node@22.15.23`
+
+## 2025-05-12 - Jeasx 1.8.0 released
+
+🎉 This release introduces a custom error handler to provide user-friendly error messages for internal server errors and to facilitate team notifications.
+
+To set up an error handler, simply register it in a route of your choice:
+
+```js
+this.errorHandler = async (error) => {
+  console.error("❌", error);
+  return <h1>Internal error</h1>;
+};
+```
+
+An error handler is called with this as context, allowing easy access to your context setup.
+
+**Breaking change:** If you use a response handler, you'll need to change the name from this.response to this.responseHandler. This aligns the response handler with the introduced error handler. We apologize for any inconvenience, but since this is a seldom-used feature, we aim to streamline the codebase by aligning it without maintaining deprecated code.
+
+As additional feature, a response handler is now called with this as the context, so you can access your existing context.
+
+Dependency updates: `esbuild@0.25.4, @types/node@22.15.17`
+
+## 2025-05-03 - Jeasx 1.7.3 released
+
+🎉 This release introduces a performance improvement by switching the internal route-to-module cache implementation from a JavaScript object to a Map. This change allows for better management of cache entries, enabling the configuration of a maximum cache limit. To take advantage of this, a new configuration option `JEASX_ROUTE_CACHE_LIMIT` has been added.
+
+Dependency updates: `jsx-async-runtime@1.0.1, esbuild@0.25.3, @types/node@22.15.3`
+
+## 2025-04-21 - Jeasx 1.7.2 released
+
+🎉 This release is brings only minor changes:
+
+`FASTIFY_STATIC_HEADERS`: Apply all matching headers to the current path. Use an empty string ("") as first rule to set default headers, which can be overridden by more specific rules later. Please checkout the updated configuration.
+
+Please note: You may need to adjust your existing configuration by moving the wildcard rule to the top of the JSON file to ensure it can be overridden by more specific rules defined below.
+env.sh: Removed logging of loaded environment files. Minor refactoring to clean up the code.
+
+Dependency updates: `fastify@5.3.2, @types/node@22.14.1`
+
+## 2025-03-31 - Jeasx 1.7.1 released
+
+🎉 This release enhances support for Bun as an alternative JavaScript runtime for both development and production. Use `bun -b dev` to start development with Jeasx and Bun. With Bun 1.2.8, the entire Jeasx expo functions without any issues. While Node.js remains the primary focus of the project, Bun support will continue to improve. Having multiple options is always beneficial.
+
+Route loading in development has been enhanced. It now relies on the modification time of the module, eliminating the need to calculate a hash for the file content. Additionally, a redundant file existence check for route handlers has been removed, resulting in more streamlined core code.
+
+From now on, source maps for `serverless.js` are provided to enhance debugging.
+
+Dependency updates: `esbuild@0.25.2`
+
+## 2025-03-27 - Jeasx 1.7.0 released
+
+🎉 This release removes `pm2` as a dependency and utilizes the powerful file watching capabilities of esbuild directly. This enhancement significantly improves build performance because esbuild only re-compiles linked files. Additionally, sharing code between the server and browser now works seamlessly without any additional configurations.
+
+As an added benefit, Jeasx now works with Bun as an alternative JavaScript runtime, although this setup is not yet recommended for development or production.
+
+Dependency updates: `@types/node@22.13.14`
+
+## 2025-03-26 - Jeasx 1.6.3 released
+
+🎉 This release fixes a bug with the recently introduced env file loading. The env files were loaded in the wrong order, so that overwriting existing env variables didn't work.
+
+Dependency updates: `fastify@5.2.2, @types/node@22.13.13`
+
+## 2025-03-19 - Jeasx 1.6.2 released
+
+🎉 This release introduces a `try/catch` block in the central request handler, ensuring that proper error messages are logged. Additionally, it enables sourcemaps for both server and browser code, making debugging a breeze.
+
+To enable sourcemap support for Node.js, add the following code to the root of your project as a .npmrc file:
+
+`node-options=--enable-source-maps`
+
+If you are using Docker, you need to modify the following lines in your Dockerfile to enable support for `.npmrc`:
+
+```bash
+# RUN npx jeasx build
+RUN npm run build
+# CMD ["npx","jeasx","start"]
+CMD ["npm","start"]
+```
+
+## 2025-03-15 - Jeasx 1.6.1 released
+
+🎉 This releases replaces the dependency on `dotenv-flow` with a native implementation provided by Node.js (using `process.loadEnvFile` introduced with Node v20.12.0) to load environment variables from .env-files. The order of loading .env-files is the same as before:
+
+```text
+.env.defaults
+.env
+.env.local
+.env.[NODE_ENV] (e.g. .env.development or .env.production)
+.env.[NODE_ENV].local (e.g. .env.development.local or .env.production.local)
+```
+
+**Breaking change:** If you use .env-files to configure Jeasx and deploy to Vercel, please update your `vercel.json`. You'll need to change `"includeFiles": "{node_modules,dist,public}/**/*"` to `"includeFiles": "./**/*"to` make sure Vercel includes the .env-files in the deployment.
+
+Additionally a fix for correctly parsing environment variables to configure Fastify (`FASTIFY_DISABLE_REQUEST_LOGGING, FASTIFY_TRUST_PROXY`) was implemented.
+
+Dependency updates: `jsx-async-runtime@1.0.0, esbuild@0.25.1, pm2@6.0.5`
+
+Please note: version 1.6.0 was unpublished from NPM right after the release due to a mistake.
+
+## 2025-03-09 - Jeasx 1.5.0 released
+
+🎉 This release features two new configurations:
+
+`FASTIFY_REWRITE_URL` allows you to rewrite incoming URLs. Useful when running behind proxies or when you want to fake URLs.
+`JEASX_BUILD_ROUTES_IGNORE_WATCH` allows watching for changes in src/browser when importing browser code into server code.
+
+Dependency updates: `@types/node@22.13.10`
+
+## 2025-03-01 - Jeasx 1.4.1 released
+
+🎉 This release features an updated `jsx-async-runtime@0.8.1` which brings typings for SVGs for a better developer experience in the IDE of your choice.
+
+3rd-party dependencies were updated to the latest versions: `@fastify/static@8.1.1, @types/node@22.13.5`
+
+## 2025-02-12 - Jeasx 1.4.0 released
+
+🎉 This release adds the route property to the current endpoint handler (e.g., `/[index]` or `/bar/[...path]`) to the request object (accessible via request.route). This makes it much easier to calculate trailing path segments for wildcard routes.
+
+Also several dependencies were updated to the latest versions: `esbuild@0.25.0, @fastify/static@8.1.0, @fastify/multipart@9.0.3, @fastify/formbody@8.0.3, @types/node@22.13.1`
+
+## 2025-01-18 - Jeasx 1.3.0 released
+
+🎉 We are excited to announce the release of `jsx-async-runtime@0.7.1`, which now includes proper typings for all HTML attributes in accordance with the Mozilla Developer Network. This ensures that code completion in your IDE for all HTML attributes works now as expected in Jeasx. Special thanks to Rebecca for highlighting this issue!
+
+The updated version of `jsx-async-runtime` now supports using an array of strings for the class attribute, making it easier to create complex classnames. You can now construct classnames using plain strings or template strings, an array of strings, or an object, covering most use-cases known from other libraries like classnames.
+
+As always, we've updated to the latest versions of our dependencies: `fastify/formbody@8.0.2, fastify/multipart@9.0.2, fastify/static@8.0.4, types/node@22.10.7`
+
+## 2025-01-06 - Jeasx 1.2.2 released
+
+🎉 This release is just a minor dependency update: `fastify@5.2.1, fastify/cookie@11.0.2, types/node@22.10.5`
+
+## 2024-12-12 - Jeasx 1.2.1 released
+
+🎉 This release fixes a bug introduced by the recently introduced route caching feature: if a guard returned different response types (e.g. JSX code for a forbidden route, otherwise props for the guarded routes), the guarded routes weren't resolved anymore.
+
+## 2024-12-07 - Jeasx 1.2.0 released
+
+🎉 This release brings a major performance boost (about 2-5 times faster in benchmarks) by introducing runtime caches for resolved routes and loaded JavaScript modules. The caches are only used in production and won't interfere with your development workflow. This change was triggered by a PR submitted by Bryce, Kudos to him for bringing this topic onto the radar.
+
+It also features an update to `jsx-async-runtime` which provides more accurate and also deprecated typings for HTML tags and attributes according to the fantastic HTML reference from the Mozilla Development Network.
+
+Added two new environment variables (`FASTIFY_DISABLE_REQUEST_LOGGING` and `FASTIFY_TRUST_PROXY`) to give you more control over how Jeasx should behave in different environments.
+
+## 2024-12-01 - Jeasx 1.1.0 released
+
+🎉 Migrated from dotenv to dotenv-flow, so you can use NODE_ENV-specific .env\* files (like `.env.development`) to configure different environments for production and development. This is useful to disable caching headers (e.g. via `FASTIFY_STATIC_HEADERS`) in development, as Jeasx applies `FASTIFY_STATIC_HEADERS` in development from now on for a more consistent developer experience. See updated .env-files in the quickstart-project for an example how to disable caching in development. This is only needed if you have configured `FASTIFY_STATIC_HEADERS` for your existing projects.
+
+Bumped default environment variable `ESBUILD_BROWSER_TARGET` to more recent browser versions (e.g. `chrome126, edge126, firefox128, safari17`). If you want to stick with older versions, you can override it via the environment. Learn more about possible values at the esbuild website.
+
+Updated `jsx-async-runtime` which fixes a bug in escapeEntities which escaped existing &amp; two times. This release also removes the deprecated `renderToString` function. Simply replace it with `jsxToString`.
+
+The default host is now :: which binds to all available network interfaces (e.g. `IPv6`). You can change it via the `HOST` environment variable (e.g. `HOST=0.0.0.0` for the old behaviour). The change is especially useful to connect to Jeasx via private networking on hosting platforms like Railway.
+
+## 2024-11-15 - Jeasx 1.0.2 released
+
+🎉 Disabled cache-control for fastify-static, so proper Cache-Control response header could be applied via the environment variable `FASTIFY_STATIC_HEADERS`. Have a look at the env-file in the quickstart project for an example.
+
+## 2024-11-01 - Jeasx 1.0.1 released
+
+🎉 This version brings official support for Node 22. Also dependencies were updated to latest versions of `fastify@5.0.1, fastify/static@8.0.2, fastify/cookie@11.0.1`. Added new examples for template fragments in combination with HTMX and image optimization with sharp.
+
+## 2024-10-04 - Jeasx 1.0.0 released
+
+It's finally here! Jeasx 1.0.0 is ready for production. We are proud to announce that the framework has reached feature completeness and is now ready for the masses. Lots of hours of work have been put into this project to make sure you have the best experience possible.
+
+## 2024-09-23 - Jeasx 0.15.2 released
+
+Updates to all `@fastify-plugins, esbuild@0.24.0`
+
+## 2024-09-21 - Jeasx 0.15.1 released
+
+Decorate the Fastify request object with `path` property, so you can easily access the route path without query parameters via request.path. This solves 99% of all use-cases for recently removed `@fastity/url-data`.
+
+## 2024-09-20 - Jeasx 0.15.0 released
+
+This release comes with Fastify 5. It also removes `@fastify/url-data` and `@fastify/accepts` as dependencies, therefore your code might break. The reason behind this removal is to depend on less dependencies in the long run which makes maintenance of the core easier.
+
+If you rely on either accepts or url-data, you must provide appropriate changes in userland code. For `@fastify/url-data` I would recommend to use `fast-uri` and for `@fastify/accepts` `jshttp/accepts` for parsing accept-header if needed.
+
+Please note: there were some intermediate releases since the past proper release which shouldn't be used (and are mostly unpublished from npm).
+
+## 2024-08-21 - Jeasx 0.11.2 released
+
+Added simple Dockerfile to quickstart template. Dependency updates: `esbuild@0.23.1, @fastify/cookie@9.4.0, @types/node@20.16.1`
+
+## 2024-07-27 - Jeasx 0.11.1 released
+
+Performance optimization: if response is string or buffer, break evaluation loop early. This allows to build caches for pages and binary assets in userland.
+
+## 2024-07-26 - Jeasx 0.11.0 released
+
+Updated to `jsx-async-runtime@0.5.0` which allows to override `jsxToString` from `jsx-async-runtime` to intercept / modify / replace JSX components via this context. Have a look at the example to see how it works.
+
+## 2024-07-19 - Jeasx 0.10.1 released
+
+Breaking change: removed `@fastify/request-context` in favor of the recently introduced this context. Changing your code should be straightforward. This change decouples userland code from Fastify. Additionally code for Jeasx and `jsx-async-runtime` is provided unminified, so debugging and testing is far easier now.
+
+## 2024-07-12 - Jeasx 0.9.1 released
+
+Updated to `jsx-async-runtime@0.4.1` which fixes a problem when running tests with Vitest.
+
+## 2024-07-10 - Jeasx 0.9.0 released
+
+Updated to `jsx-async-runtime@0.4.0` which allows to use `this` as context object to avoid prop drilling. Have a look at the demo to see how things work.
+
+## 2024-07-05 - Jeasx 0.8.0 released
+
+Updated to `jsx-async-runtime@0.3.0` (deprecated `renderToString` in favor of `jsxToString`)
+
+## 2024-07-03 - Jeasx 0.7.6 released
+
+Updated to `esbuild@0.23.0`
+
+## 2024-07-01 - Jeasx 0.7.5 released
+
+Updated to `fastify@4.28.1, esbuild@0.22.0, pm2@5.4.1`
+
+## 2024-05-28 - Jeasx 0.7.4 released
+
+Updated to `esbuild@0.21.4, pm2@5.4.0`
+
+## 2024-05-17 - Jeasx 0.7.3 released
+
+Updated to `esbuild@0.21.3, @types/node@20.12.12`
+
+## 2024-05-08 - Jeasx 0.7.2 released
+
+Updated to `fastify@4.27.0, esbuild@0.21.1, @fastify/static@7.0.4`
+
+## 2024-05-07 - Jeasx 0.7.1 released
+
+Updated `esbuild@0.21.0`
+
+## 2024-04-27 - Jeasx 0.7.0 released
+
+This release introduces a new feature that allows you to post-process the resulting payloads, such as prettifying the HTML output. You can now set up a response handler, for example, in a guard. The response handler takes the resulting payload as a parameter and returns the modified payload.
+
+```js
+import * as prettier from "prettier";
+
+export default function RootGuard({ request, reply }) {
+  this.response = async (payload) => {
+    return typeof payload === "string" &&
+      String(reply.getHeader("content-type")).startsWith("text/html")
+      ? await prettier.format(payload, { parser: "html" })
+      : payload;
+  };
+}
+```
+
+Shame on me... I have recently started writing news as we approach the 1.0 release. But you can study the changelog at GitHub to see what has happend in the past.
+
+## 2023-12-30 - First public commit
+
+Our Journey Begins! 🎉 Introducing Jeasx, a revolutionary web development framework born out of a summer experiment in 2023.
+
+Our mission?
+
+To simplify web development using server-rendered JSX as the cornerstone, bringing back the essence of the web: HTML, CSS, and progressive enhancing JavaScript. Join us as we redefine the future of web development together!