evikit 2.3.2 → 2.4.0

package/server.js

@@ -1,487 +1,498 @@
-import { Busboy } from "@fastify/busboy";
-import { toJsonSchema } from "@valibot/to-json-schema";
-import acceptLanguage from "accept-language";
-import { po } from "gettext-parser";
-import { readFile } from "node:fs/promises";
-import { Fragment, 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";
-
-/** @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 port = Number(process.env["PORT"]) || 5173;
-  const server = app.listen(port, () => {
-    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(/<meta[^>]+>/g, ""),
-          )
-          .replace(
-            `<!--app-head-->`,
-            renderToString(
-              h(
-                Fragment,
-                null,
-                [...rendered.head.elements.values()].map(({ props, type }) =>
-                  h(type, props),
-                ),
-              ),
-            ),
-          )
-          .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"
-                  ? {
-                      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]) => !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 { 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";
+
+/** @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 port = Number(process.env["PORT"]) || 5173;
+  if (cluster.isPrimary && availableParallelism() > 1) {
+    for (let i = 0; i < availableParallelism(); 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(/<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"
+                  ? {
+                      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]) => !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;
+  };
+}