evikit 2.7.3 → 2.8.1

package/server.js

@@ -1,536 +1,668 @@
-import { Busboy } from "@fastify/busboy";
-import { toJsonSchema } from "@valibot/to-json-schema";
-import acceptLanguage from "accept-language";
-import { po } from "gettext-parser";
-import cluster from "node:cluster";
-import { readFile } from "node:fs/promises";
-import { availableParallelism } from "node:os";
-import { h } from "preact";
-import { renderToString } from "preact-render-to-string";
-import {
-  object,
-  optional,
-  parse,
-  picklist,
-  record,
-  string,
-  union,
-  ValiError,
-} from "valibot";
-
-import { Po } from "./i18n.js";
-
-/** @param {() => () => void} callback */
-export function daemon(callback) {
-  if (
-    (process.env["npm_command"] == "start" && cluster.isPrimary) ||
-    process.env["npm_lifecycle_event"] == "dev"
-  ) {
-    /** @type {any} */
-    const self = globalThis;
-    if (self.clearDaemon) {
-      self.clearDaemon();
-    }
-    self.clearDaemon = callback();
-  }
-}
-
-/** @type {import("./server-generic.js").ServerEndpoint} */
-export function endpoint({ input, outputs }, handler) {
-  const arrayOf = ArrayOf(input);
-  const schema = union(
-    Object.entries(outputs).map(([status, schema]) =>
-      object({
-        contentType: optional(string()),
-        cookies: optional(record(string(), object({ value: string() }))),
-        headers: optional(record(string(), string())),
-        output: schema,
-        status: picklist([Number(status)]),
-      }),
-    ),
-  );
-  return {
-    handler: async (req, res) => {
-      try {
-        /** @type {Record<string, string | File | (string | File)[]>} */
-        const body = {};
-        if (req.headers["content-type"]) {
-          const busboy = new Busboy({
-            headers: /** @type {any} */ (req.headers),
-          });
-          busboy.on("field", (name, value) => {
-            body[name] =
-              typeof body[name] == "undefined"
-                ? value
-                : Array.isArray(body[name])
-                  ? [...body[name], value]
-                  : [body[name], value];
-          });
-
-          if (
-            Object.values(input.entries).some(
-              (entry) => entry.type == "file" || arrayOf(entry, "file"),
-            )
-          ) {
-            busboy.on("file", (name, stream, filename) => {
-              const entry = input.entries[name];
-              if (entry && (entry.type == "file" || arrayOf(entry, "file"))) {
-                /** @type {ArrayBuffer[]} */
-                const buffers = [];
-                stream.on("data", (data) => {
-                  buffers.push(data);
-                });
-                stream.on("end", () => {
-                  const value = new File(buffers, filename);
-                  body[name] =
-                    typeof body[name] == "undefined"
-                      ? value
-                      : Array.isArray(body[name])
-                        ? [...body[name], value]
-                        : [body[name], value];
-                });
-              } else {
-                stream.resume();
-              }
-            });
-          }
-
-          await new Promise((resolve, reject) => {
-            busboy.on("error", reject).on("finish", resolve);
-            req.pipe(busboy);
-          });
-        }
-
-        const { contentType, cookies, headers, output, status } = parse(
-          schema,
-          await handler({
-            input: parse(input, {
-              ...(req.headers.cookie
-                ? Object.fromEntries(
-                    req.headers.cookie
-                      .split("; ")
-                      .map((row) => row.split("=").map(decodeURIComponent)),
-                  )
-                : undefined),
-              ...Object.fromEntries(
-                Object.entries(
-                  Object.groupBy(
-                    [
-                      ...new URL(
-                        `http://${req.headers.host}${req.url}`,
-                      ).searchParams.entries(),
-                    ],
-                    ([name]) => name || "",
-                  ),
-                ).map(([name, group]) => {
-                  const values = (group || []).map((value) => value[1]);
-                  return [name, values.length == 1 ? values[0] : values];
-                }),
-              ),
-              ...body,
-            }),
-          }),
-        );
-
-        const location = headers
-          ? Object.entries(headers).find(
-              ([name]) => name.toLowerCase() == "location",
-            )?.[1]
-          : undefined;
-        const opaqueRedirectWorkaround =
-          req.headers.accept == "application/json" && location
-            ? { location, status }
-            : undefined;
-        const workaroundHeaders = headers
-          ? Object.entries(headers).filter(([name]) => {
-              const lower = name.toLowerCase();
-              return (
-                lower != "content-type" &&
-                (lower != "location" || !opaqueRedirectWorkaround)
-              );
-            })
-          : [];
-
-        if (cookies) {
-          workaroundHeaders.push([
-            "set-cookie",
-            Object.entries(cookies || "")
-              .map(
-                ([name, { value }]) =>
-                  `${encodeURIComponent(name)}=${encodeURIComponent(value)}`,
-              )
-              .join("; "),
-          ]);
-        }
-
-        if (contentType == "application/json") {
-          res.statusCode = status;
-          res.setHeader("content-type", "application/json; charset=utf-8");
-          for (const [name, value] of workaroundHeaders) {
-            res.setHeader(name, value);
-          }
-          res.end(JSON.stringify(output));
-        } else if (opaqueRedirectWorkaround) {
-          res.setHeader("content-type", "application/json; charset=utf-8");
-          for (const [name, value] of workaroundHeaders) {
-            res.setHeader(name, value);
-          }
-          res.end(JSON.stringify({ opaqueRedirectWorkaround }));
-        } else {
-          res.statusCode = status;
-          res.setHeader("content-type", "text/plain; charset=utf-8");
-          for (const [name, value] of workaroundHeaders) {
-            res.setHeader(name, value);
-          }
-          res.end(output);
-        }
-      } catch (/** @type {any} */ error) {
-        console.error(error);
-        res.statusCode = error instanceof ValiError ? 400 : 500;
-        res.setHeader("content-type", "text/plain; charset=utf-8");
-        res.end(error.message);
-      }
-    },
-    input,
-    outputs,
-  };
-}
-
-/** @type {import("./server-generic.js").ServerJson} */
-export function json(output) {
-  return {
-    contentType: /** @type {any} */ ("application/json"),
-    output,
-    status: 200,
-  };
-}
-
-/** @param {{ listen: (port: number, callback: () => void) => { close(): void, on(event: "error", callback: (error: unknown) => void ): void } }} app */
-export function listen(app) {
-  const parallelism =
-    Number(process.env["PARALLELISM"]) || availableParallelism();
-  const port = Number(process.env["PORT"]) || 5173;
-  if (cluster.isPrimary && parallelism > 1) {
-    for (let i = 0; i < parallelism; i++) {
-      cluster.fork({ i });
-    }
-  } else {
-    const server = app.listen(port, () => {
-      if (cluster.isPrimary || process.env["i"] == "0") {
-        console.log(
-          `Server started at ${process.env["ORIGIN"] || `http://localhost:${port}`}`,
-        );
-      }
-    });
-    server.on("error", (error) => {
-      console.error(error);
-      process.exitCode = 1;
-    });
-    process.on("SIGTERM", () => {
-      server.close();
-    });
-  }
-}
-
-/** @param {{ html: string, prerender({ lang, url }: { lang: string, url: string }): Promise<{ data: {}, head: { elements: Set<{ props: { [k: string]: string }, type: string }>, lang: string, title: string }, html: string }> }} props */
-export function production({ html, prerender }) {
-  /**
-   * @param {import("node:http").IncomingMessage} req
-   * @param {import("node:http").ServerResponse<import("node:http").IncomingMessage>} res
-   */
-  return async function onRequest(req, res) {
-    try {
-      const rendered = await prerender({
-        lang: acceptLanguage.get(req.headers["accept-language"]) || "en",
-        url: req.url || "/",
-      });
-      res.statusCode =
-        // https://indieweb.org/meta_http-equiv_status
-        Number(
-          [...rendered.head.elements.values()]
-            .find(
-              ({ props, type }) =>
-                type == "meta" && props["http-equiv"] == "status",
-            )
-            ?.props["content"]?.replace(/ .*/, ""),
-        ) || 200;
-      res.setHeader("content-type", "text/html; charset=utf-8");
-      res.end(
-        html
-          .replace(/lang=".+?"/, () => `lang="${rendered.head.lang}"`)
-          .replace(/<title>.+<\/title>/, () =>
-            renderToString(h("title", null, rendered.head.title)),
-          )
-          .replace(/<!--app-head-->[\s\S]+?<body/, (match) =>
-            match
-              .replace(/<link[^>]+>/g, (link) =>
-                /data-hoofd/.test(link) ? "" : link,
-              )
-              .replace(/<meta[^>]+>/g, ""),
-          )
-          .replace(
-            `<!--app-head-->`,
-            [...rendered.head.elements.values()]
-              .map(
-                ({ props, type }) =>
-                  `<${type} ` +
-                  Object.entries(props)
-                    .map(([name, value]) => `${name}="${value}"`)
-                    .join(" ") +
-                  (type == "script" ? `</${type}>` : " />"),
-              )
-              .join(""),
-          )
-          .replace(
-            /(<div id="app">)[\s\S]+<!--app-html-->/,
-            (_, div) =>
-              div +
-              rendered.html +
-              '<script type="application/json" id="preact-prerender-data">' +
-              JSON.stringify(rendered.data).replace(/\//g, "\\/") +
-              "</script>",
-          ),
-      );
-    } catch (error) {
-      console.error(error);
-      res.statusCode = 500;
-      res.end("Internal Server Error");
-    }
-  };
-}
-
-/** @type {import("./server-generic.js").ServerRedirect} */
-export function redirect(location, status, init) {
-  return {
-    contentType: /** @type {any} */ ("text/plain"),
-    cookies: init?.cookies,
-    headers: { location },
-    output: location,
-    status,
-  };
-}
-
-/**
- * @param {string} path
- * @param {import("./server-generic.js").MethodServer} controller */
-export function route(path, controller) {
-  return { controller, path, pattern: new URLPattern(`http://*:*${path}`) };
-}
-
-/**
- * @param {{ pkg: { name: string, version: string } }} props
- * @param {ReturnType<typeof route>[]} routes
- */
-export function router({ pkg }, ...routes) {
-  const openapi = {
-    info: { title: pkg.name, version: pkg.version },
-    openapi: "3.1.0",
-    paths: Object.fromEntries(
-      Object.values(routes).map(({ controller, path }) => [
-        path.replace(/:(\w+)/g, "{$1}"),
-        Object.fromEntries(
-          Object.entries(controller).map(([method, { input, outputs }]) => {
-            const arrayOf = ArrayOf(input);
-            const parameters = path
-              .split("/")
-              .filter((component) => /^:/.test(component))
-              .map((component) => component.slice(1));
-            return [
-              method,
-              {
-                parameters: [
-                  ...parameters.map((name) => ({
-                    in: "path",
-                    name,
-                    required: true,
-                    schema: { type: "string" },
-                  })),
-                  ...(method == "post"
-                    ? []
-                    : Object.entries(input.entries)
-                        .filter(
-                          ([name]) =>
-                            name != "lang" && !parameters.includes(name),
-                        )
-                        .map(([name, entry]) => ({
-                          in: "query",
-                          name,
-                          required: !entry.expects.includes("undefined"),
-                          schema: { type: "string" },
-                        }))),
-                ],
-                ...(method == "post"
-                  ? {
-                      requestBody: {
-                        content: {
-                          [Object.values(input.entries).some(
-                            (entry) =>
-                              entry.type == "file" || arrayOf(entry, "file"),
-                          )
-                            ? "multipart/form-data"
-                            : "application/x-www-form-urlencoded"]: {
-                            schema: toJsonSchema(
-                              object(
-                                Object.fromEntries(
-                                  Object.entries(input.entries).filter(
-                                    ([name]) =>
-                                      name != "lang" &&
-                                      !parameters.includes(name),
-                                  ),
-                                ),
-                              ),
-                              {
-                                ignoreActions: ["trim"],
-                                overrideSchema: (context) =>
-                                  context.valibotSchema.type == "file"
-                                    ? { format: "binary", type: "string" }
-                                    : context.jsonSchema,
-                              },
-                            ),
-                          },
-                        },
-                      },
-                    }
-                  : undefined),
-                responses: Object.fromEntries(
-                  Object.entries(outputs).map(([status, schema]) => [
-                    status,
-                    {
-                      content: {
-                        ["application/json"]: { schema: toJsonSchema(schema) },
-                      },
-                      description:
-                        status == "200"
-                          ? "OK"
-                          : status == "302"
-                            ? "Found"
-                            : "Bad Request",
-                    },
-                  ]),
-                ),
-              },
-            ];
-          }),
-        ),
-      ]),
-    ),
-    servers: [{ url: process.env["ORIGIN"] || "" }],
-  };
-
-  Po.set(async (lang) =>
-    po.parse(await readFile(`po/${encodeURIComponent(lang)}.po`, "utf-8")),
-  );
-
-  const poPattern = new URLPattern(`http://*:*/po/:lang`);
-
-  /**
-   * @param {import("node:http").IncomingMessage} req
-   * @param {import("node:http").ServerResponse<import("node:http").IncomingMessage>} res
-   * @param {() => void} [next]
-   */
-  async function onRequest(req, res, next) {
-    const lowercase = req.method?.toLowerCase();
-    const url = new URL(`http://${req.headers.host}${req.url}`);
-
-    const pathname = poPattern.exec(url)?.pathname;
-    if (pathname) {
-      const lang = acceptLanguage.get(pathname.groups["lang"]) || "en";
-      if (lang != "en") {
-        res.setHeader("content-type", "application/json");
-        res.end(JSON.stringify(await Po.get(lang)));
-        return;
-      }
-    }
-
-    for (const { controller, pattern } of Object.values(routes)) {
-      const pathname = pattern.exec(url)?.pathname;
-      if (pathname) {
-        for (const [method, { handler }] of Object.entries(controller)) {
-          if (method == lowercase) {
-            const lang =
-              acceptLanguage.get(req.headers["accept-language"]) || "en";
-            if (!url.searchParams.has(lang)) {
-              url.searchParams.set("lang", lang);
-            }
-            for (const [name, value] of Object.entries(pathname.groups)) {
-              if (!url.searchParams.has(name)) {
-                url.searchParams.set(name, value || "");
-              }
-            }
-            req.url = url.pathname + (url.search || "");
-            handler(req, res);
-            return;
-          }
-        }
-
-        if (lowercase == "options") {
-          res.statusCode = 204;
-          res.setHeader(
-            "allow",
-            [
-              ...new Set([
-                "OPTIONS",
-                ...Object.keys(controller).map((x) => x.toUpperCase()),
-              ]),
-            ].join(", "),
-          );
-          res.end();
-          return;
-        }
-
-        res.statusCode = 405;
-        res.end("Method Not Allowed");
-        return;
-      }
-    }
-
-    if (req.url == "/api" || req.url?.startsWith("/api/")) {
-      res.statusCode = 404;
-      res.end("Not Found");
-      return;
-    }
-
-    if (req.url == "/openapi.json") {
-      res.setHeader("content-type", "application/json");
-      res.end(JSON.stringify(openapi));
-      return;
-    }
-
-    if (!next) {
-      res.statusCode = 404;
-      res.end("Not Found");
-      return;
-    }
-
-    next();
-  }
-
-  return { onRequest, openapi };
-}
-
-/** @type {import("./server-generic.js").ServerText} */
-export function text(output, status) {
-  return {
-    contentType: /** @type {any} */ ("text/plain"),
-    output,
-    status,
-  };
-}
-
-/** @param {import("valibot").ObjectSchema<any, any>} input */
-function ArrayOf(input) {
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  const entries = Object.values(input);
-  /**
-   * @param {typeof entries[0]} entry
-   * @param {string} type
-   */
-  return function arrayOf(entry, type) {
-    if (entry.type != "array") {
-      return false;
-    }
-    /** @type {import("valibot").ArraySchema<any, any>} */
-    const array = /** @type {any} */ (entry);
-    return array.item.type == type;
-  };
-}
+import { Busboy } from "@fastify/busboy";
+import { toJsonSchema } from "@valibot/to-json-schema";
+import acceptLanguage from "accept-language";
+import { po } from "gettext-parser";
+import cluster from "node:cluster";
+import { createHash } from "node:crypto";
+import { readFile } from "node:fs/promises";
+import { availableParallelism } from "node:os";
+import { h } from "preact";
+import { renderToString } from "preact-render-to-string";
+import {
+  object,
+  optional,
+  parse,
+  picklist,
+  record,
+  string,
+  union,
+  ValiError,
+} from "valibot";
+
+import { Po } from "./i18n.js";
+
+/** @param {() => () => void} callback */
+export function daemon(callback) {
+  if (
+    (process.env["npm_command"] == "start" &&
+      (parallelism() == 1 ? cluster.isPrimary : process.env["i"] == "0")) ||
+    process.env["npm_lifecycle_event"] == "dev"
+  ) {
+    /** @type {any} */
+    const self = globalThis;
+    if (self.clearDaemon) {
+      self.clearDaemon();
+    }
+    self.clearDaemon = callback();
+  }
+}
+
+/** @type {import("./server-generic.js").ServerEndpoint} */
+export function endpoint({ input, outputs }, handler) {
+  const arrayOf = ArrayOf(input);
+  const schema = union(
+    Object.entries(outputs).map(([status, schema]) =>
+      object({
+        contentType: optional(string()),
+        cookies: optional(record(string(), object({ value: string() }))),
+        headers: optional(record(string(), string())),
+        output: schema,
+        status: picklist([Number(status)]),
+      }),
+    ),
+  );
+  return {
+    handler: async (req, res) => {
+      try {
+        /** @type {Record<string, string | File | (string | File)[]>} */
+        const body = {};
+        if (req.headers["content-type"]) {
+          const busboy = new Busboy({
+            headers: /** @type {any} */ (req.headers),
+          });
+          busboy.on("field", (name, value) => {
+            body[name] =
+              typeof body[name] == "undefined"
+                ? value
+                : Array.isArray(body[name])
+                  ? [...body[name], value]
+                  : [body[name], value];
+          });
+
+          if (
+            Object.values(input.entries).some(
+              (entry) => entry.type == "file" || arrayOf(entry, "file"),
+            )
+          ) {
+            busboy.on("file", (name, stream, filename) => {
+              const entry = input.entries[name];
+              if (entry && (entry.type == "file" || arrayOf(entry, "file"))) {
+                /** @type {ArrayBuffer[]} */
+                const buffers = [];
+                stream.on("data", (data) => {
+                  buffers.push(data);
+                });
+                stream.on("end", () => {
+                  const value = new File(buffers, filename);
+                  body[name] =
+                    typeof body[name] == "undefined"
+                      ? value
+                      : Array.isArray(body[name])
+                        ? [...body[name], value]
+                        : [body[name], value];
+                });
+              } else {
+                stream.resume();
+              }
+            });
+          }
+
+          await new Promise((resolve, reject) => {
+            busboy.on("error", reject).on("finish", resolve);
+            req.pipe(busboy);
+          });
+        }
+
+        const { contentType, cookies, headers, output, status } = parse(
+          schema,
+          await handler({
+            input: parse(input, {
+              ...(req.headers.cookie
+                ? Object.fromEntries(
+                    req.headers.cookie
+                      .split("; ")
+                      .map((row) => row.split("=").map(decodeURIComponent)),
+                  )
+                : undefined),
+              ...Object.fromEntries(
+                Object.entries(
+                  Object.groupBy(
+                    [
+                      ...new URL(
+                        `http://${req.headers.host}${req.url}`,
+                      ).searchParams.entries(),
+                    ],
+                    ([name]) => name || "",
+                  ),
+                ).map(([name, group]) => {
+                  const values = (group || []).map((value) => value[1]);
+                  return [name, values.length == 1 ? values[0] : values];
+                }),
+              ),
+              ...body,
+            }),
+          }),
+        );
+
+        const location = headers
+          ? Object.entries(headers).find(
+              ([name]) => name.toLowerCase() == "location",
+            )?.[1]
+          : undefined;
+        const opaqueRedirectWorkaround =
+          req.headers.accept == "application/json" && location
+            ? { location, status }
+            : undefined;
+        const workaroundHeaders = headers
+          ? Object.entries(headers).filter(([name]) => {
+              const lower = name.toLowerCase();
+              return (
+                lower != "content-type" &&
+                (lower != "location" || !opaqueRedirectWorkaround)
+              );
+            })
+          : [];
+
+        if (cookies) {
+          workaroundHeaders.push([
+            "set-cookie",
+            Object.entries(cookies || "")
+              .map(
+                ([name, { value }]) =>
+                  `${encodeURIComponent(name)}=${encodeURIComponent(value)}; path=/`,
+              )
+              .join("; "),
+          ]);
+        }
+
+        if (contentType == "application/json") {
+          res.statusCode = status;
+          res.setHeader("content-type", "application/json; charset=utf-8");
+          for (const [name, value] of workaroundHeaders) {
+            res.setHeader(name, value);
+          }
+          res.end(JSON.stringify(output));
+        } else if (opaqueRedirectWorkaround) {
+          res.setHeader("content-type", "application/json; charset=utf-8");
+          for (const [name, value] of workaroundHeaders) {
+            res.setHeader(name, value);
+          }
+          res.end(JSON.stringify({ opaqueRedirectWorkaround }));
+        } else {
+          res.statusCode = status;
+          res.setHeader("content-type", "text/plain; charset=utf-8");
+          for (const [name, value] of workaroundHeaders) {
+            res.setHeader(name, value);
+          }
+          res.end(output);
+        }
+      } catch (/** @type {any} */ error) {
+        console.error(error);
+        res.statusCode = error instanceof ValiError ? 400 : 500;
+        res.setHeader("content-type", "text/plain; charset=utf-8");
+        res.end(error.message);
+      }
+    },
+    input,
+    outputs,
+  };
+}
+
+/** @type {import("./server-generic.js").ServerJson} */
+export function json(output) {
+  return {
+    contentType: /** @type {any} */ ("application/json"),
+    output,
+    status: 200,
+  };
+}
+
+/** @param {{ listen: (port: number, callback: () => void) => { close(): void, on(event: "error", callback: (error: unknown) => void ): void } }} app */
+export function listen(app) {
+  const port = Number(process.env["PORT"]) || 5173;
+  if (cluster.isPrimary && parallelism() > 1) {
+    /** @type {{ on(event: "message", callback: (message: any) => void): void, send(message: any, _: any, options: { keepOpen: boolean }): void }[]} */
+    const forks = [];
+    for (let i = 0; i < parallelism(); i++) {
+      forks.push(cluster.fork({ i }));
+    }
+    for (const fork of forks) {
+      fork.on("message", (maybeMessage) => {
+        const message = /** @type {any} */ (maybeMessage);
+        for (let i = 0; i < forks.length; i++) {
+          if (i != message.i) {
+            forks[i]?.send(message, undefined, { keepOpen: true });
+          }
+        }
+      });
+    }
+  } else {
+    const server = app.listen(port, () => {
+      if (cluster.isPrimary || process.env["i"] == "0") {
+        console.log(
+          `Server started at ${process.env["ORIGIN"] || `http://localhost:${port}`}`,
+        );
+      }
+    });
+    server.on("error", (error) => {
+      console.error(error);
+      process.exitCode = 1;
+    });
+    process.on("SIGTERM", () => {
+      server.close();
+    });
+  }
+}
+
+/** @param {{ html: string, prerender({ cookie, lang, url }: { cookie?: string | undefined, lang: string, url: string }): Promise<{ data: {}, head: { elements: Set<{ props: { [k: string]: string }, type: string }>, lang: string, title: string }, html: string }> }} props */
+export function production({ html, prerender }) {
+  /**
+   * @param {import("node:http").IncomingMessage} req
+   * @param {import("node:http").ServerResponse<import("node:http").IncomingMessage>} res
+   */
+  return async function onRequest(req, res) {
+    try {
+      const rendered = await prerender({
+        cookie: req.headers.cookie,
+        lang: acceptLanguage.get(req.headers["accept-language"]) || "en",
+        url: req.url || "/",
+      });
+      res.statusCode =
+        // https://indieweb.org/meta_http-equiv_status
+        Number(
+          [...rendered.head.elements.values()]
+            .find(
+              ({ props, type }) =>
+                type == "meta" && props["http-equiv"] == "status",
+            )
+            ?.props["content"]?.replace(/ .*/, ""),
+        ) || 200;
+      res.setHeader("content-type", "text/html; charset=utf-8");
+      res.end(
+        html
+          .replace(/lang=".+?"/, () => `lang="${rendered.head.lang}"`)
+          .replace(/<title>.+<\/title>/, () =>
+            renderToString(h("title", null, rendered.head.title)),
+          )
+          .replace(/<!--app-head-->[\s\S]+?<body/, (match) =>
+            match
+              .replace(/<link[^>]+>/g, (link) =>
+                /data-hoofd/.test(link) ? "" : link,
+              )
+              .replace(/<meta[^>]+>/g, ""),
+          )
+          .replace(
+            `<!--app-head-->`,
+            [...rendered.head.elements.values()]
+              .map(
+                ({ props, type }) =>
+                  `<${type} ` +
+                  Object.entries(props)
+                    .map(([name, value]) => `${name}="${value}"`)
+                    .join(" ") +
+                  (type == "script" ? `</${type}>` : " />"),
+              )
+              .join(""),
+          )
+          .replace(
+            /(<div id="app">)[\s\S]+<!--app-html-->/,
+            (_, div) =>
+              div +
+              rendered.html +
+              '<script type="application/json" id="preact-prerender-data">' +
+              JSON.stringify(rendered.data).replace(/\//g, "\\/") +
+              "</script>",
+          ),
+      );
+    } catch (error) {
+      console.error(error);
+      res.statusCode = 500;
+      res.end("Internal Server Error");
+    }
+  };
+}
+
+/** @type {import("./server-generic.js").ServerRedirect} */
+export function redirect(location, status, init) {
+  return {
+    contentType: /** @type {any} */ ("text/plain"),
+    cookies: init?.cookies,
+    headers: { location },
+    output: location,
+    status,
+  };
+}
+
+/**
+ * @param {string} path
+ * @param {import("./server-generic.js").MethodServer} controller */
+export function route(path, controller) {
+  return { controller, path, pattern: new URLPattern(`http://*:*${path}`) };
+}
+
+/**
+ * // eslint-disable-next-line @typescript-eslint/no-explicit-any
+ * @param {{ db?: import("./db.js").Db<any>, pkg: { name: string, version: string } }} props
+ * @param {ReturnType<typeof route>[]} routes
+ */
+export function router({ db, pkg }, ...routes) {
+  const openapi = {
+    info: { title: pkg.name, version: pkg.version },
+    openapi: "3.1.0",
+    paths: Object.fromEntries(
+      Object.values(routes).map(({ controller, path }) => [
+        path.replace(/:(\w+)/g, "{$1}"),
+        Object.fromEntries(
+          Object.entries(controller).map(([method, { input, outputs }]) => {
+            const arrayOf = ArrayOf(input);
+            const parameters = path
+              .split("/")
+              .filter((component) => /^:/.test(component))
+              .map((component) => component.slice(1));
+            return [
+              method,
+              {
+                parameters: [
+                  ...parameters.map((name) => ({
+                    in: "path",
+                    name,
+                    required: true,
+                    schema: { type: "string" },
+                  })),
+                  ...(method == "post"
+                    ? []
+                    : Object.entries(input.entries)
+                        .filter(
+                          ([name]) =>
+                            name != "lang" && !parameters.includes(name),
+                        )
+                        .map(([name, entry]) => ({
+                          in: "query",
+                          name,
+                          required: !entry.expects.includes("undefined"),
+                          schema: { type: "string" },
+                        }))),
+                ],
+                ...(method == "post"
+                  ? {
+                      requestBody: {
+                        content: {
+                          [Object.values(input.entries).some(
+                            (entry) =>
+                              entry.type == "file" || arrayOf(entry, "file"),
+                          )
+                            ? "multipart/form-data"
+                            : "application/x-www-form-urlencoded"]: {
+                            schema: toJsonSchema(
+                              object(
+                                Object.fromEntries(
+                                  Object.entries(input.entries).filter(
+                                    ([name]) =>
+                                      name != "lang" &&
+                                      !parameters.includes(name),
+                                  ),
+                                ),
+                              ),
+                              {
+                                ignoreActions: ["trim"],
+                                overrideSchema: (context) =>
+                                  context.valibotSchema.type == "file"
+                                    ? { format: "binary", type: "string" }
+                                    : context.jsonSchema,
+                              },
+                            ),
+                          },
+                        },
+                      },
+                    }
+                  : undefined),
+                responses: Object.fromEntries(
+                  Object.entries(outputs).map(([status, schema]) => [
+                    status,
+                    {
+                      content: {
+                        ["application/json"]: { schema: toJsonSchema(schema) },
+                      },
+                      description:
+                        status == "200"
+                          ? "OK"
+                          : status == "302"
+                            ? "Found"
+                            : "Bad Request",
+                    },
+                  ]),
+                ),
+              },
+            ];
+          }),
+        ),
+      ]),
+    ),
+    servers: [{ url: process.env["ORIGIN"] || "" }],
+  };
+
+  Po.set(async (lang) =>
+    po.parse(await readFile(`po/${encodeURIComponent(lang)}.po`, "utf-8")),
+  );
+
+  const poPattern = new URLPattern(`http://*:*/po/:lang`);
+
+  /** @type {Map<(req: any, res: any) => void, string[]>} */
+  const TablesInOutput = new Map();
+  for (const { controller } of Object.values(routes)) {
+    for (const [method, { handler, outputs }] of Object.entries(controller)) {
+      if (method == "get") {
+        /** @type {string[]} */
+        let tablesInOutput = [];
+
+        /** @param {import("valibot").ArraySchema<any, any> | import("valibot").ObjectSchema<import("valibot").ObjectEntries, any> | import("valibot").StringSchema<any>} schema */
+        function walk(schema) {
+          if (schema.type == "array") {
+            walk(schema.item);
+          } else if (schema.type == "object") {
+            for (const entry of Object.values(schema.entries)) {
+              walk(/** @type {any} */ (entry));
+            }
+          } else if (db) {
+            for (const [name, table] of Object.entries(
+              /** @type {Record<string, import("valibot").ObjectSchema<import("valibot").ObjectEntries, any>>} */ (
+                db.schema
+              ),
+            )) {
+              for (const column of Object.values(table.entries)) {
+                if (column == schema) {
+                  tablesInOutput.push(name);
+                }
+              }
+            }
+          }
+        }
+        for (const schema of Object.values(outputs)) {
+          walk(schema);
+        }
+        if (tablesInOutput.length) {
+          TablesInOutput.set(handler, [...new Set(tablesInOutput)]);
+        }
+      }
+    }
+  }
+
+  /**
+   * @param {import("node:http").IncomingMessage} req
+   * @param {import("node:http").ServerResponse<import("node:http").IncomingMessage>} res
+   * @param {() => void} [next]
+   */
+  async function onRequest(req, res, next) {
+    const lowercase = req.method?.toLowerCase();
+    const url = new URL(`http://${req.headers.host}${req.url}`);
+
+    const pathname = poPattern.exec(url)?.pathname;
+    if (pathname) {
+      const lang = acceptLanguage.get(pathname.groups["lang"]) || "en";
+      if (lang != "en") {
+        res.setHeader("content-type", "application/json");
+        res.end(JSON.stringify(await Po.get(lang)));
+        return;
+      }
+    }
+
+    for (const { controller, pattern } of Object.values(routes)) {
+      const pathname = pattern.exec(url)?.pathname;
+      if (pathname) {
+        for (const [method, { handler }] of Object.entries(controller)) {
+          if (method == lowercase) {
+            const lang =
+              acceptLanguage.get(req.headers["accept-language"]) || "en";
+            if (!url.searchParams.has(lang)) {
+              url.searchParams.set("lang", lang);
+            }
+            for (const [name, value] of Object.entries(pathname.groups)) {
+              if (!url.searchParams.has(name)) {
+                url.searchParams.set(name, value || "");
+              }
+            }
+            req.url = url.pathname + (url.search || "");
+
+            if (method == "get" && req.headers.accept == "text/event-stream") {
+              res.setHeader("x-accel-buffering", "no");
+              res.setHeader("content-type", "text/event-stream");
+              res.setHeader("cache-control", "no-cache");
+              const tablesInOutput = TablesInOutput.get(handler);
+              if (tablesInOutput && db) {
+                let busy = false;
+                let queue = 0;
+                let startedAt = 0;
+                let endedAt = 0;
+                let lastHash = "";
+                const interval = setInterval(() => {
+                  const now = Date.now();
+                  if (
+                    !busy &&
+                    queue &&
+                    endedAt < now - (endedAt - startedAt) * 3
+                  ) {
+                    busy = true;
+                    queue = 0;
+                    startedAt = now;
+                    /** @type {Record<string, string>} */
+                    const headers = {};
+                    let statusCode = 200;
+                    handler(req, {
+                      end(body) {
+                        const data = JSON.stringify({
+                          body,
+                          headers,
+                          statusCode,
+                        });
+                        const hash = createHash("sha256")
+                          .update(data)
+                          .digest("hex");
+                        if (lastHash != hash) {
+                          lastHash = hash;
+                          res.write(`data: ${data}\n\n`);
+                          const expressCompressionResponse =
+                            /** @type {any} */ (res);
+                          if (
+                            typeof expressCompressionResponse.flush ==
+                            "function"
+                          ) {
+                            expressCompressionResponse.flush();
+                          }
+                        }
+                        endedAt = Date.now();
+                        busy = false;
+                      },
+                      setHeader(name, value) {
+                        headers[name] = value;
+                      },
+                      set statusCode(/** @type {number} */ value) {
+                        statusCode = value;
+                      },
+                    });
+                  }
+                }, 100);
+                const unsubscribe = db.subscribe(({ table }) => {
+                  if (tablesInOutput.includes(table)) {
+                    queue++;
+                  }
+                });
+                req.on("close", () => {
+                  unsubscribe();
+                  clearInterval(interval);
+                });
+              } else {
+                res.end("data: null\n\n");
+              }
+              return;
+            }
+
+            handler(req, res);
+            return;
+          }
+        }
+
+        if (lowercase == "options") {
+          res.statusCode = 204;
+          res.setHeader(
+            "allow",
+            [
+              ...new Set([
+                "OPTIONS",
+                ...Object.keys(controller).map((x) => x.toUpperCase()),
+              ]),
+            ].join(", "),
+          );
+          res.end();
+          return;
+        }
+
+        res.statusCode = 405;
+        res.end("Method Not Allowed");
+        return;
+      }
+    }
+
+    if (req.url == "/api" || req.url?.startsWith("/api/")) {
+      res.statusCode = 404;
+      res.end("Not Found");
+      return;
+    }
+
+    if (req.url == "/openapi.json") {
+      res.setHeader("content-type", "application/json");
+      res.end(JSON.stringify(openapi));
+      return;
+    }
+
+    if (!next) {
+      res.statusCode = 404;
+      res.end("Not Found");
+      return;
+    }
+
+    next();
+  }
+
+  return { onRequest, openapi };
+}
+
+/** @type {import("./server-generic.js").ServerText} */
+export function text(output, status) {
+  return {
+    contentType: /** @type {any} */ ("text/plain"),
+    output,
+    status,
+  };
+}
+
+/** @param {import("valibot").ObjectSchema<any, any>} input */
+function ArrayOf(input) {
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  const entries = Object.values(input);
+  /**
+   * @param {typeof entries[0]} entry
+   * @param {string} type
+   */
+  return function arrayOf(entry, type) {
+    if (entry.type != "array") {
+      return false;
+    }
+    /** @type {import("valibot").ArraySchema<any, any>} */
+    const array = /** @type {any} */ (entry);
+    return array.item.type == type;
+  };
+}
+
+function parallelism() {
+  return Number(process.env["PARALLELISM"]) || availableParallelism();
+}