weifuwu 0.2.1 → 0.2.3

package/dist/index.js

@@ -0,0 +1,1420 @@
+// serve.ts
+import http from "node:http";
+async function readBody(req) {
+  const chunks = [];
+  for await (const chunk of req) {
+    chunks.push(chunk);
+  }
+  return Buffer.concat(chunks);
+}
+function createRequest(req, body) {
+  const url = new URL(req.url ?? "/", "http://localhost");
+  const query = Object.fromEntries(url.searchParams);
+  const headers = {};
+  for (const [key, value] of Object.entries(req.headers)) {
+    if (value !== void 0) {
+      headers[key] = Array.isArray(value) ? value.join(", ") : value;
+    }
+  }
+  const request = new Request(url.href, {
+    method: req.method?.toUpperCase() ?? "GET",
+    headers,
+    body: req.method !== "GET" && req.method !== "HEAD" && body.length > 0 ? body : null
+  });
+  return [request, query];
+}
+async function sendResponse(res, response) {
+  const headers = {};
+  response.headers.forEach((value, key) => {
+    headers[key] = value;
+  });
+  res.writeHead(response.status, response.statusText, headers);
+  if (response.body) {
+    const reader = response.body.getReader();
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        res.write(value);
+      }
+    } finally {
+      reader.releaseLock();
+    }
+  }
+  res.end();
+}
+function serve(handler, options) {
+  const port = options?.port ?? 0;
+  const hostname = options?.hostname ?? "0.0.0.0";
+  const server = http.createServer(async (req, res) => {
+    try {
+      const body = await readBody(req);
+      const [request, query] = createRequest(req, body);
+      const response = await handler(request, { params: {}, query });
+      await sendResponse(res, response);
+    } catch {
+      res.writeHead(500, { "Content-Type": "text/plain" });
+      res.end("Internal Server Error");
+    }
+  });
+  if (options?.websocket) {
+    server.on("upgrade", options.websocket);
+  }
+  let resolveReady;
+  const ready = new Promise((r) => {
+    resolveReady = r;
+  });
+  if (options?.signal) {
+    if (options.signal.aborted) {
+      server.close();
+      resolveReady();
+      return {
+        stop: () => {
+        },
+        ready,
+        get port() {
+          return 0;
+        },
+        get hostname() {
+          return hostname;
+        }
+      };
+    }
+    options.signal.addEventListener("abort", () => {
+      server.close();
+    }, { once: true });
+  }
+  server.listen(port, hostname, () => {
+    resolveReady();
+  });
+  return {
+    stop: () => {
+      server.close();
+    },
+    ready,
+    get port() {
+      const addr = server.address();
+      if (!addr || typeof addr === "string") return 0;
+      return addr.port;
+    },
+    get hostname() {
+      const addr = server.address();
+      if (!addr) return hostname;
+      return typeof addr === "string" ? addr : addr.address;
+    }
+  };
+}
+
+// router.ts
+import { WebSocketServer } from "ws";
+import { buildSchema, graphql } from "graphql";
+import { makeExecutableSchema } from "@graphql-tools/schema";
+import { streamText } from "ai";
+var createTrieNode = () => ({
+  children: /* @__PURE__ */ new Map(),
+  handlers: /* @__PURE__ */ new Map(),
+  middlewares: /* @__PURE__ */ new Map(),
+  pathMws: []
+});
+var createWsNode = () => ({
+  children: /* @__PURE__ */ new Map(),
+  middlewares: []
+});
+var getTrieNode = (node, segment) => {
+  if (segment.startsWith(":")) {
+    if (!node.children.has(":")) {
+      const child2 = createTrieNode();
+      child2.param = segment.slice(1);
+      node.children.set(":", child2);
+    }
+    const child = node.children.get(":");
+    if (child.param !== segment.slice(1)) {
+      throw new Error(
+        `Param name conflict: ":${child.param}" already registered at this path position, cannot register ":"${segment.slice(1)}"`
+      );
+    }
+    return child;
+  }
+  if (!node.children.has(segment)) {
+    node.children.set(segment, createTrieNode());
+  }
+  return node.children.get(segment);
+};
+var matchTrieNode = (node, segment, params) => {
+  if (node.children.has(segment)) return node.children.get(segment);
+  if (node.children.has(":")) {
+    const child = node.children.get(":");
+    if (child.param) params[child.param] = segment;
+    return child;
+  }
+  return null;
+};
+var getWsNode = (node, segment) => {
+  if (segment.startsWith(":")) {
+    if (!node.children.has(":")) {
+      const child2 = createWsNode();
+      child2.param = segment.slice(1);
+      node.children.set(":", child2);
+    }
+    const child = node.children.get(":");
+    if (child.param !== segment.slice(1)) {
+      throw new Error(
+        `Param name conflict: ":${child.param}" already registered at this path position`
+      );
+    }
+    return child;
+  }
+  if (!node.children.has(segment)) {
+    node.children.set(segment, createWsNode());
+  }
+  return node.children.get(segment);
+};
+var matchWsNode = (node, segment, params) => {
+  if (node.children.has(segment)) return node.children.get(segment);
+  if (node.children.has(":")) {
+    const child = node.children.get(":");
+    if (child.param) params[child.param] = segment;
+    return child;
+  }
+  return null;
+};
+var Router = class _Router {
+  root = createTrieNode();
+  wsRoot = createWsNode();
+  globalMws = [];
+  errorHandler;
+  use(arg1, arg2) {
+    if (typeof arg1 === "string") {
+      if (arg2 instanceof _Router) {
+        let node = this.root;
+        for (const segment of this.splitPath(arg1)) {
+          node = getTrieNode(node, segment);
+        }
+        node.subRouter = arg2;
+      } else if (typeof arg2 === "function") {
+        let node = this.root;
+        for (const segment of this.splitPath(arg1)) {
+          node = getTrieNode(node, segment);
+        }
+        node.pathMws.push(arg2);
+      }
+    } else if (typeof arg1 === "function") {
+      this.globalMws.push(arg1);
+    }
+    return this;
+  }
+  get(path, ...args) {
+    return this.route("GET", path, ...args);
+  }
+  post(path, ...args) {
+    return this.route("POST", path, ...args);
+  }
+  put(path, ...args) {
+    return this.route("PUT", path, ...args);
+  }
+  delete(path, ...args) {
+    return this.route("DELETE", path, ...args);
+  }
+  patch(path, ...args) {
+    return this.route("PATCH", path, ...args);
+  }
+  head(path, ...args) {
+    return this.route("HEAD", path, ...args);
+  }
+  options(path, ...args) {
+    return this.route("OPTIONS", path, ...args);
+  }
+  all(path, ...args) {
+    return this.route("*", path, ...args);
+  }
+  onError(handler) {
+    this.errorHandler = handler;
+    return this;
+  }
+  route(method, path, ...args) {
+    const handler = args.pop();
+    const middlewares = args;
+    const segments = this.splitPath(path);
+    let node = this.root;
+    for (const segment of segments) {
+      if (segment === "*") {
+        node.wildcard = true;
+        node.handlers.set(method, handler);
+        if (middlewares.length > 0) node.middlewares.set(method, middlewares);
+        return this;
+      }
+      node = getTrieNode(node, segment);
+    }
+    node.handlers.set(method, handler);
+    if (middlewares.length > 0) node.middlewares.set(method, middlewares);
+    return this;
+  }
+  ws(path, ...args) {
+    const handler = args.pop();
+    const middlewares = args;
+    const segments = this.splitPath(path);
+    let node = this.wsRoot;
+    for (const segment of segments) {
+      node = getWsNode(node, segment);
+    }
+    node.handler = handler;
+    if (middlewares.length > 0) node.middlewares = middlewares;
+    return this;
+  }
+  graphql(path, ...args) {
+    const options = args.pop();
+    const middlewares = args;
+    const schema = typeof options.schema === "string" ? options.resolvers ? makeExecutableSchema({
+      typeDefs: options.schema,
+      resolvers: options.resolvers
+    }) : buildSchema(options.schema) : options.schema;
+    const handler = (req, ctx) => {
+      const url = new URL(req.url);
+      if (options.graphiql && req.method === "GET" && !url.searchParams.has("query")) {
+        return new Response(getGraphiQLHtml(url.pathname), {
+          status: 200,
+          headers: { "Content-Type": "text/html" }
+        });
+      }
+      if (req.method !== "GET" && req.method !== "POST") {
+        return new Response("Not Found", { status: 404 });
+      }
+      const paramsPromise = req.method === "GET" ? Promise.resolve(parseGraphQLParamsFromGet(url)) : parseGraphQLParamsFromPost(req);
+      return paramsPromise.then((params) => {
+        if (!params) {
+          return Response.json(
+            { errors: [{ message: "Missing query" }] },
+            { status: 400 }
+          );
+        }
+        return executeGraphQLQuery(schema, params, options, req, ctx);
+      });
+    };
+    return this.all(path, ...middlewares, handler);
+  }
+  ai(path, ...args) {
+    const handler = args.pop();
+    const middlewares = args;
+    const routeHandler = async (req, ctx) => {
+      const options = await handler(req, ctx);
+      const result = streamText(options);
+      return result.toTextStreamResponse();
+    };
+    return this.post(path, ...middlewares, routeHandler);
+  }
+  handler() {
+    return (req, ctx) => {
+      const url = new URL(req.url);
+      return this.handle(req, ctx, this.splitPath(url.pathname), Object.fromEntries(url.searchParams));
+    };
+  }
+  websocketHandler() {
+    const wss = new WebSocketServer({ noServer: true });
+    const wsRoot = this.wsRoot;
+    const router = this;
+    return (req, socket, head) => {
+      const url = new URL(req.url ?? "/", "http://localhost");
+      const segments = url.pathname.split("/").filter(Boolean);
+      const query = Object.fromEntries(url.searchParams);
+      const match = router.matchWsTrie(wsRoot, segments);
+      if (!match) {
+        socket.destroy();
+        return;
+      }
+      const webReq = new Request(url.href, {
+        method: req.method ?? "GET",
+        headers: Object.fromEntries(
+          Object.entries(req.headers).map(([k, v]) => [k, Array.isArray(v) ? v.join(", ") : v ?? ""])
+        )
+      });
+      const ctx = { params: match.params, query };
+      if (match.middlewares.length === 0) {
+        upgradeSocket(wss, req, socket, head, match.handler, ctx);
+        return;
+      }
+      let index = 0;
+      const dispatch = async (innerReq, ctx2) => {
+        if (index < match.middlewares.length) {
+          const mw = match.middlewares[index++];
+          return mw(innerReq, ctx2, dispatch);
+        }
+        return await new Promise((resolve3) => {
+          upgradeSocket(wss, req, socket, head, match.handler, ctx2);
+          resolve3(new Response(null, { status: 101 }));
+        });
+      };
+      Promise.resolve(dispatch(webReq, ctx)).then((result) => {
+        if (result.status !== 101) {
+          sendHttpResponseOnSocket(socket, result);
+        }
+      }).catch(() => {
+        socket.destroy();
+      });
+    };
+  }
+  splitPath(path) {
+    return path.split("/").filter(Boolean);
+  }
+  matchTrie(method, segments) {
+    let node = this.root;
+    const params = {};
+    const pathMws = [...this.root.pathMws];
+    let wildcardHandler = null;
+    let wildcardMws = [];
+    let wildcardIdx = -1;
+    for (let i = 0; i < segments.length; i++) {
+      pathMws.push(...node.pathMws);
+      if (node.wildcard) {
+        const h = node.handlers.get(method) || node.handlers.get("*");
+        if (h) {
+          wildcardHandler = h;
+          wildcardMws = node.middlewares.get(method) || node.middlewares.get("*") || [];
+          wildcardIdx = i;
+        }
+      }
+      const segment = segments[i];
+      if (!segment) break;
+      const next = matchTrieNode(node, segment, params);
+      if (!next) {
+        if (node.subRouter) {
+          return {
+            pathMws,
+            params,
+            middlewares: [],
+            subRouter: { router: node.subRouter, remainingIdx: i }
+          };
+        }
+        if (wildcardHandler) {
+          params["*"] = segments.slice(wildcardIdx).join("/");
+          return { handler: wildcardHandler, middlewares: wildcardMws, pathMws, params };
+        }
+        return null;
+      }
+      node = next;
+    }
+    if (node.subRouter) {
+      return {
+        pathMws,
+        params,
+        middlewares: [],
+        subRouter: { router: node.subRouter, remainingIdx: segments.length }
+      };
+    }
+    pathMws.push(...node.pathMws);
+    const handler = node.handlers.get(method) || node.handlers.get("*");
+    if (handler) {
+      if (node.wildcard) params["*"] = segments.slice(segments.length).join("/");
+      return {
+        handler,
+        middlewares: node.middlewares.get(method) || node.middlewares.get("*") || [],
+        pathMws,
+        params
+      };
+    }
+    if (wildcardHandler) {
+      params["*"] = segments.slice(wildcardIdx).join("/");
+      return { handler: wildcardHandler, middlewares: wildcardMws, pathMws, params };
+    }
+    return null;
+  }
+  matchWsTrie(root, segments) {
+    let node = root;
+    const params = {};
+    for (const segment of segments) {
+      const next = matchWsNode(node, segment, params);
+      if (!next) return null;
+      node = next;
+    }
+    return node.handler ? { handler: node.handler, middlewares: node.middlewares, params } : null;
+  }
+  async handle(req, ctx, segments, query) {
+    const match = this.matchTrie(req.method, segments);
+    if (match?.subRouter) {
+      const { router: sub, remainingIdx } = match.subRouter;
+      const remainingSegments = segments.slice(remainingIdx);
+      const delegate = (req2, ctx2) => sub.handle(req2, ctx2, remainingSegments, query);
+      const allMws = this.globalMws.length + match.pathMws.length === 0 ? [] : [...this.globalMws, ...match.pathMws];
+      try {
+        return await this.runChain(allMws, delegate, req, { ...ctx, params: { ...ctx.params, ...match.params } });
+      } catch (e) {
+        return this.errorHandler ? this.errorHandler(e, req, ctx) : new Response("Internal Server Error", { status: 500 });
+      }
+    }
+    if (match?.handler) {
+      const { handler, middlewares: routeMws, pathMws, params } = match;
+      const allMws = this.globalMws.length + pathMws.length + routeMws.length === 0 ? [] : [...this.globalMws, ...pathMws, ...routeMws];
+      const ctxWithMatch = { ...ctx, params: { ...ctx.params, ...params } };
+      try {
+        return await this.runChain(allMws, handler, req, ctxWithMatch);
+      } catch (e) {
+        return this.errorHandler ? this.errorHandler(e, req, ctxWithMatch) : new Response("Internal Server Error", { status: 500 });
+      }
+    }
+    if (this.globalMws.length > 0) {
+      try {
+        const delegate = () => new Response("Not Found", { status: 404 });
+        return await this.runChain(this.globalMws, delegate, req, ctx);
+      } catch (e) {
+        return this.errorHandler ? this.errorHandler(e, req, ctx) : new Response("Internal Server Error", { status: 500 });
+      }
+    }
+    return new Response("Not Found", { status: 404 });
+  }
+  async runChain(middlewares, finalHandler, req, ctx) {
+    let index = 0;
+    const dispatch = async (req2, ctx2) => {
+      if (index < middlewares.length) {
+        const mw = middlewares[index++];
+        return mw ? await mw(req2, ctx2, dispatch) : new Response("Middleware error", { status: 500 });
+      }
+      return await finalHandler(req2, ctx2);
+    };
+    return dispatch(req, ctx);
+  }
+};
+function upgradeSocket(wss, req, socket, head, handler, ctx) {
+  wss.handleUpgrade(req, socket, head, (ws) => {
+    if (handler.open) {
+      handler.open(ws, ctx);
+    }
+    ws.on("message", (data) => {
+      handler.message?.(ws, ctx, data);
+    });
+    ws.on("close", () => {
+      handler.close?.(ws, ctx);
+    });
+    ws.on("error", (err) => {
+      handler.error?.(ws, ctx, err);
+    });
+  });
+}
+function sendHttpResponseOnSocket(socket, response) {
+  const statusLine = `HTTP/1.1 ${response.status} ${response.statusText}`;
+  const headerLines = [statusLine];
+  response.headers.forEach((value, key) => {
+    headerLines.push(`${key}: ${value}`);
+  });
+  headerLines.push("Connection: close");
+  headerLines.push("");
+  const headerStr = headerLines.join("\r\n");
+  response.arrayBuffer().then((buf) => {
+    const body = Buffer.from(buf);
+    socket.write(headerStr + "\r\n" + body.toString());
+    socket.end();
+  }).catch(() => {
+    socket.write(headerStr + "\r\n");
+    socket.end();
+  });
+}
+function parseGraphQLParamsFromGet(url) {
+  const query = url.searchParams.get("query");
+  if (!query) return null;
+  const variablesStr = url.searchParams.get("variables");
+  let variables = {};
+  if (variablesStr) {
+    try {
+      variables = JSON.parse(variablesStr);
+    } catch {
+      return null;
+    }
+  }
+  return {
+    query,
+    variables,
+    operationName: url.searchParams.get("operationName") || void 0
+  };
+}
+async function parseGraphQLParamsFromPost(req) {
+  try {
+    const body = await req.json();
+    if (!body.query) return null;
+    return {
+      query: body.query,
+      variables: body.variables || {},
+      operationName: body.operationName
+    };
+  } catch {
+    return null;
+  }
+}
+async function executeGraphQLQuery(schema, params, options, req, ctx) {
+  const contextValue = options.context ? await options.context(req, ctx) : ctx;
+  const result = await graphql({
+    schema,
+    source: params.query,
+    rootValue: options.rootValue,
+    contextValue,
+    variableValues: params.variables,
+    operationName: params.operationName
+  });
+  return Response.json(result, { status: result.errors ? 400 : 200 });
+}
+function getGraphiQLHtml(endpoint) {
+  return `<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>GraphiQL</title>
+    <style>
+      body { margin: 0; }
+      #graphiql { height: 100dvh; }
+    </style>
+    <link rel="stylesheet" href="https://esm.sh/graphiql@5.2.2/dist/style.css" />
+    <script type="importmap">
+      {
+        "imports": {
+          "react": "https://esm.sh/react@19.2.5",
+          "react/": "https://esm.sh/react@19.2.5/",
+          "react-dom": "https://esm.sh/react-dom@19.2.5",
+          "react-dom/": "https://esm.sh/react-dom@19.2.5/",
+          "graphiql": "https://esm.sh/graphiql@5.2.2?standalone&external=react,react-dom,@graphiql/react,graphql",
+          "graphiql/": "https://esm.sh/graphiql@5.2.2/",
+          "@graphiql/react": "https://esm.sh/@graphiql/react@0.37.3?standalone&external=react,react-dom,graphql,@graphiql/toolkit,@emotion/is-prop-valid",
+          "@graphiql/toolkit": "https://esm.sh/@graphiql/toolkit@0.11.3?standalone&external=graphql",
+          "graphql": "https://esm.sh/graphql@16.13.2",
+          "@emotion/is-prop-valid": "data:text/javascript,"
+        }
+      }
+    </script>
+    <script type="module">
+      import React from 'react';
+      import ReactDOM from 'react-dom/client';
+      import { GraphiQL } from 'graphiql';
+      import { createGraphiQLFetcher } from '@graphiql/toolkit';
+      import 'graphiql/setup-workers/esm.sh';
+
+      const fetcher = createGraphiQLFetcher({ url: "${endpoint}" });
+
+      function App() {
+        return React.createElement(GraphiQL, { fetcher });
+      }
+
+      const container = document.getElementById('graphiql');
+      const root = ReactDOM.createRoot(container);
+      root.render(React.createElement(App));
+    </script>
+  </head>
+  <body>
+    <div id="graphiql">Loading\u2026</div>
+  </body>
+</html>`;
+}
+
+// tsx.ts
+import { createElement, createContext, useContext } from "react";
+import { renderToReadableStream } from "react-dom/server";
+import * as esbuild from "esbuild";
+import { readdirSync, statSync, existsSync, mkdirSync } from "node:fs";
+import { join, relative, resolve, sep, dirname } from "node:path";
+import { pathToFileURL } from "node:url";
+import { createHash } from "node:crypto";
+var TsxContext = createContext({ params: {}, query: {} });
+function useTsx() {
+  return useContext(TsxContext);
+}
+function id(s) {
+  return createHash("md5").update(s).digest("hex").slice(0, 8);
+}
+function concatUint8(chunks) {
+  const len = chunks.reduce((a, c) => a + c.length, 0);
+  const out = new Uint8Array(len);
+  let off = 0;
+  for (const c of chunks) {
+    out.set(c, off);
+    off += c.length;
+  }
+  return out;
+}
+async function readStream(stream) {
+  const chunks = [];
+  const reader = stream.getReader();
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    chunks.push(value);
+  }
+  return new TextDecoder().decode(concatUint8(chunks));
+}
+function scanPages(dir) {
+  const pages = [];
+  function walk(current) {
+    let entries;
+    try {
+      entries = readdirSync(current);
+    } catch {
+      return;
+    }
+    const dirs = [];
+    for (const name of entries) {
+      const full = join(current, name);
+      const st = statSync(full);
+      if (st.isDirectory()) {
+        if (!name.startsWith(".")) dirs.push(full);
+      }
+    }
+    const pagePath = join(current, "page.tsx");
+    const tsPagePath = join(current, "page.ts");
+    let entryPath = "";
+    if (existsSync(pagePath)) {
+      entryPath = pagePath;
+    } else if (existsSync(tsPagePath)) {
+      entryPath = tsPagePath;
+    }
+    if (entryPath) {
+      let relPath = relative(dir, entryPath).replace(sep, "/");
+      relPath = relPath.replace(/\/page\.tsx?$/, "");
+      relPath = relPath.replace(/^page\.tsx?$/, "");
+      const route = filePathToRoute(relPath);
+      const layouts = resolveLayouts(current, dir);
+      const loadPath = existsSync(join(current, "load.ts")) ? join(current, "load.ts") : void 0;
+      const rPath = existsSync(join(current, "route.ts")) ? join(current, "route.ts") : void 0;
+      pages.push({
+        route,
+        entryPath,
+        loadPath,
+        layouts,
+        routePath: rPath
+      });
+    }
+    for (const d of dirs) walk(d);
+  }
+  walk(dir);
+  return pages;
+}
+function filePathToRoute(relPath) {
+  let route = relPath.replace(/\\/g, "/");
+  route = route.replace(/\[\.\.\.(\w+)\]/g, "*");
+  route = route.replace(/\[(\w+)\]/g, ":$1");
+  return route.startsWith("/") ? route : "/" + route;
+}
+function resolveLayouts(dir, pagesDir) {
+  const layouts = [];
+  let current = dir;
+  while (current.startsWith(pagesDir)) {
+    const p = join(current, "layout.tsx");
+    if (existsSync(p)) {
+      layouts.push(p);
+    }
+    const parent = dirname(current);
+    if (parent === current) break;
+    current = parent;
+  }
+  return layouts.reverse();
+}
+async function compileAll(files, outDir, platform) {
+  const entryPoints = {};
+  for (const f of files) {
+    entryPoints[id(f)] = f;
+  }
+  const isBrowser = platform === "browser";
+  await esbuild.build({
+    entryPoints,
+    outdir: outDir,
+    format: "esm",
+    platform: "node",
+    jsx: "automatic",
+    jsxImportSource: "react",
+    bundle: true,
+    external: isBrowser ? void 0 : [
+      "react",
+      "react-dom",
+      "esbuild",
+      "graphql",
+      "ws",
+      "zod",
+      "@graphql-tools/schema",
+      "ai"
+    ],
+    write: true,
+    allowOverwrite: true
+  });
+}
+function compiledUrl(filePath, outDir) {
+  const hash = id(join(outDir, id(filePath)));
+  const p = join(outDir, id(filePath) + ".js");
+  return pathToFileURL(p).href;
+}
+var clientBundleCache = /* @__PURE__ */ new Map();
+var clientRouteLog = /* @__PURE__ */ new WeakMap();
+async function getOrBuildClientBundle(entryPath, layoutPaths, pagesDir, router) {
+  const key = id(entryPath);
+  const url = `/__wfw/client/${key}.js`;
+  if (!clientRouteLog.get(router)?.has(url)) {
+    let buf = clientBundleCache.get(key);
+    if (!buf) {
+      try {
+        const nested = layoutPaths.slice(1);
+        const layoutsImport = nested.map(
+          (p, i) => `import L${i} from${JSON.stringify(p)};`
+        ).join("");
+        const layoutsWrap = nested.map((_, i) => {
+          const idx = nested.length - 1 - i;
+          return `el=createElement(L${idx},null,el);`;
+        }).join("");
+        const code = [
+          `import{hydrateRoot}from'react-dom/client';`,
+          `import{createElement}from'react';`,
+          `import P from${JSON.stringify(entryPath)};`,
+          layoutsImport,
+          `const p=window.__WEIFUWU_PROPS;`,
+          `let el=createElement(P,p);`,
+          layoutsWrap,
+          `hydrateRoot(document.getElementById('__weifuwu_root'),el);`
+        ].join("");
+        const result = await esbuild.build({
+          stdin: { contents: code, loader: "tsx", resolveDir: pagesDir },
+          bundle: true,
+          format: "esm",
+          jsx: "automatic",
+          jsxImportSource: "react",
+          write: false,
+          minify: true
+        });
+        buf = result.outputFiles[0].contents;
+        clientBundleCache.set(key, buf);
+      } catch (err) {
+        console.error("hydration bundle failed:", err);
+        return null;
+      }
+    }
+    router.get(url, () => new Response(buf, {
+      headers: { "content-type": "application/javascript; charset=utf-8" }
+    }));
+    const set = clientRouteLog.get(router) ?? /* @__PURE__ */ new Set();
+    set.add(url);
+    clientRouteLog.set(router, set);
+  }
+  return { url };
+}
+function makeSsrHandler(Component, loadFn, layouts, entryPath, layoutPaths, pagesDir, router) {
+  return async (req, ctx) => {
+    const loadProps = loadFn ? await loadFn({ params: ctx.params, query: ctx.query }) : {};
+    const allProps = { ...loadProps, params: ctx.params, query: ctx.query };
+    let element = createElement(Component, allProps);
+    for (let i = layouts.length - 1; i >= 0; i--) {
+      const isRoot = i === 0;
+      element = createElement(
+        layouts[i],
+        isRoot ? { children: element, req, ctx } : { children: element }
+      );
+    }
+    element = createElement(TsxContext.Provider, {
+      value: { params: ctx.params, query: ctx.query, user: ctx.user, parsed: ctx.parsed }
+    }, element);
+    const stream = await renderToReadableStream(element);
+    const body = await readStream(stream);
+    const scripts = [];
+    scripts.push(`<script>window.__WEIFUWU_PROPS=${JSON.stringify(allProps)}</script>`);
+    const bundle = await getOrBuildClientBundle(entryPath, layoutPaths, pagesDir, router);
+    if (bundle) {
+      scripts.push(`<script type="module" src="${bundle.url}"></script>`);
+    }
+    const html = `<!DOCTYPE html>
+${body}
+${scripts.join("\n")}`;
+    return new Response(html, {
+      headers: { "content-type": "text/html; charset=utf-8" }
+    });
+  };
+}
+async function tsx(options) {
+  const pagesDir = resolve(options.dir);
+  const outDir = join(pagesDir, "..", ".weifuwu", "ssr");
+  const clientDir = join(pagesDir, "..", ".weifuwu", "client");
+  const pages = scanPages(pagesDir);
+  if (pages.length === 0) return new Router();
+  const allFiles = /* @__PURE__ */ new Set();
+  const loadMap = /* @__PURE__ */ new Map();
+  const layoutMap = /* @__PURE__ */ new Map();
+  for (const p of pages) {
+    allFiles.add(p.entryPath);
+    if (p.loadPath) {
+      allFiles.add(p.loadPath);
+      loadMap.set(p.entryPath, p.loadPath);
+    }
+    for (const lp of p.layouts) allFiles.add(lp);
+    layoutMap.set(p.entryPath, [...p.layouts]);
+    if (p.routePath) allFiles.add(p.routePath);
+  }
+  mkdirSync(outDir, { recursive: true });
+  await compileAll([...allFiles], outDir, "node");
+  const router = new Router();
+  for (const p of pages) {
+    const url = compiledUrl(p.entryPath, outDir);
+    const mod = await import(url);
+    const Component = mod.default;
+    let loadFn;
+    if (p.loadPath) {
+      const loadUrl = compiledUrl(p.loadPath, outDir);
+      const modLoad = await import(loadUrl);
+      loadFn = modLoad.default;
+    }
+    const layoutComponents = [];
+    for (const lp of p.layouts) {
+      const lUrl = compiledUrl(lp, outDir);
+      const modL = await import(lUrl);
+      layoutComponents.push(modL.default);
+    }
+    const handler = makeSsrHandler(
+      Component,
+      loadFn,
+      layoutComponents,
+      p.entryPath,
+      p.layouts,
+      pagesDir,
+      router
+    );
+    router.get(p.route, handler);
+    if (p.routePath) {
+      const rUrl = compiledUrl(p.routePath, outDir);
+      const modR = await import(rUrl);
+      const methods = ["POST", "PUT", "DELETE", "PATCH", "HEAD", "OPTIONS"];
+      for (const method of methods) {
+        if (modR[method]) {
+          router.route(method, p.route, modR[method]);
+        }
+      }
+    }
+  }
+  return router;
+}
+
+// middleware.ts
+function logger(options) {
+  return async (req, ctx, next) => {
+    const start = Date.now();
+    const url = new URL(req.url);
+    const res = await next(req, ctx);
+    const ms = Date.now() - start;
+    if (options?.format === "combined") {
+      console.log(`${req.method} ${url.pathname}${url.search} ${res.status} ${ms}ms`);
+    } else {
+      console.log(`${req.method} ${url.pathname} ${res.status} ${ms}ms`);
+    }
+    return res;
+  };
+}
+function cors(options) {
+  const opts = {
+    origin: "*",
+    methods: ["GET", "HEAD", "PUT", "PATCH", "POST", "DELETE"],
+    allowedHeaders: ["Content-Type", "Authorization"],
+    ...options
+  };
+  function resolveOrigin(requestOrigin) {
+    if (typeof opts.origin === "string") return opts.origin === "*" ? "*" : opts.origin;
+    if (Array.isArray(opts.origin)) {
+      return opts.origin.includes(requestOrigin) ? requestOrigin : "";
+    }
+    const result = opts.origin(requestOrigin);
+    if (typeof result === "boolean") return result ? requestOrigin : "";
+    if (typeof result === "string") return result;
+    return "";
+  }
+  function setCORSHeaders(res, acao) {
+    if (!acao) return res;
+    const headers = new Headers(res.headers);
+    headers.set("Access-Control-Allow-Origin", acao);
+    if (opts.credentials) headers.set("Access-Control-Allow-Credentials", "true");
+    if (opts.exposedHeaders?.length) headers.set("Access-Control-Expose-Headers", opts.exposedHeaders.join(", "));
+    headers.set("Vary", "Origin");
+    return new Response(res.body, { status: res.status, statusText: res.statusText, headers });
+  }
+  return (req, ctx, next) => {
+    const requestOrigin = req.headers.get("origin") ?? "";
+    const acao = resolveOrigin(requestOrigin);
+    if (req.method === "OPTIONS" && acao) {
+      const headers = new Headers();
+      headers.set("Access-Control-Allow-Origin", acao);
+      headers.set("Access-Control-Allow-Methods", opts.methods.join(", "));
+      headers.set("Access-Control-Allow-Headers", opts.allowedHeaders.join(", "));
+      if (opts.credentials) headers.set("Access-Control-Allow-Credentials", "true");
+      if (opts.maxAge != null) headers.set("Access-Control-Max-Age", String(opts.maxAge));
+      headers.set("Vary", "Origin");
+      return new Response(null, { status: 204, headers });
+    }
+    if (!acao) return next(req, ctx);
+    return Promise.resolve(next(req, ctx)).then((res) => setCORSHeaders(res, acao));
+  };
+}
+function auth(options) {
+  return async (req, ctx, next) => {
+    const headerName = options.header ?? "Authorization";
+    const header = req.headers.get(headerName);
+    if (!header) {
+      return new Response("Unauthorized", {
+        status: 401,
+        headers: headerName.toLowerCase() === "authorization" ? { "WWW-Authenticate": "Bearer" } : void 0
+      });
+    }
+    let token = header;
+    if (headerName.toLowerCase() === "authorization") {
+      const parts = header.split(" ");
+      if (parts[0]?.toLowerCase() === "bearer") {
+        token = parts.slice(1).join(" ");
+      }
+    }
+    if (options.proxy) {
+      const proxyUrl = typeof options.proxy === "string" ? new URL(options.proxy) : options.proxy;
+      const proxyHeaders = {};
+      if (headerName.toLowerCase() === "authorization") {
+        proxyHeaders["Authorization"] = header;
+      } else {
+        proxyUrl.searchParams.set("access_token", token);
+      }
+      for (const name of ["x-forwarded-for", "x-real-ip", "user-agent", "content-type"]) {
+        const v = req.headers.get(name);
+        if (v) proxyHeaders[name] = v;
+      }
+      const proxyRes = await fetch(proxyUrl.href, { headers: proxyHeaders });
+      if (proxyRes.status >= 400) {
+        return new Response(await proxyRes.text() || "Forbidden", { status: proxyRes.status });
+      }
+      let userData = void 0;
+      if (proxyRes.status === 200) {
+        const ct = proxyRes.headers.get("content-type");
+        if (ct?.includes("application/json")) {
+          try {
+            userData = await proxyRes.json();
+          } catch {
+          }
+        }
+      }
+      ctx.user = userData;
+      return next(req, ctx);
+    }
+    if (options.token) {
+      if (token !== options.token) {
+        return new Response("Forbidden", { status: 403 });
+      }
+      return next(req, ctx);
+    }
+    if (options.verify) {
+      const result = await options.verify(token, req);
+      if (!result) {
+        return new Response("Forbidden", { status: 403 });
+      }
+      if (typeof result === "object" && result !== null) {
+        ctx.user = result;
+      }
+      return next(req, ctx);
+    }
+    return next(req, ctx);
+  };
+}
+
+// static.ts
+import { createHash as createHash2 } from "node:crypto";
+import { open } from "node:fs/promises";
+import { extname, resolve as resolve2, normalize, sep as sep2 } from "node:path";
+function serveStatic(root, options) {
+  const rootDir = resolve2(root);
+  const opts = options ?? {};
+  return async (req, ctx) => {
+    const relativePath = ctx.params["*"] ?? new URL(req.url).pathname.slice(1);
+    const decoded = decodeURIComponent(relativePath);
+    if (decoded.includes("..") || decoded.includes("\0")) {
+      return new Response("Forbidden", { status: 403 });
+    }
+    let filePath = normalize(resolve2(rootDir, decoded));
+    if (!filePath.startsWith(rootDir + sep2) && filePath !== rootDir) {
+      return new Response("Forbidden", { status: 403 });
+    }
+    let fileHandle;
+    try {
+      fileHandle = await open(filePath, "r");
+      const stat = await fileHandle.stat();
+      if (stat.isDirectory()) {
+        await fileHandle.close();
+        const indexFile = opts.index ?? "index.html";
+        filePath = resolve2(filePath, indexFile);
+        if (!filePath.startsWith(rootDir + sep2)) {
+          return new Response("Forbidden", { status: 403 });
+        }
+        fileHandle = await open(filePath, "r");
+        const dirStat = await fileHandle.stat();
+        if (!dirStat.isFile()) {
+          await fileHandle.close();
+          return new Response("Not Found", { status: 404 });
+        }
+      }
+      const mimeType = MIME_TYPES[extname(filePath).toLowerCase()] ?? "application/octet-stream";
+      const etag = `"${createHash2("md5").update(`${stat.size}-${stat.mtimeMs}`).digest("hex")}"`;
+      const ifNoneMatch = req.headers.get("if-none-match");
+      if (ifNoneMatch === etag) {
+        await fileHandle.close();
+        return new Response(null, { status: 304 });
+      }
+      const ifModifiedSince = req.headers.get("if-modified-since");
+      if (ifModifiedSince && stat.mtimeMs <= new Date(ifModifiedSince).getTime()) {
+        await fileHandle.close();
+        return new Response(null, { status: 304 });
+      }
+      const headers = {
+        "Content-Type": mimeType,
+        "Content-Length": String(stat.size),
+        "ETag": etag,
+        "Last-Modified": stat.mtime.toUTCString(),
+        "Cache-Control": opts.immutable ? `public, max-age=${opts.maxAge ?? 31536e3}, immutable` : `public, max-age=${opts.maxAge ?? 0}`
+      };
+      const stream = fileHandle.readableWebStream();
+      return new Response(stream, { headers });
+    } catch (err) {
+      if (fileHandle) await fileHandle.close().catch(() => {
+      });
+      if (err?.code === "ENOENT") {
+        return new Response("Not Found", { status: 404 });
+      }
+      return new Response("Internal Server Error", { status: 500 });
+    }
+  };
+}
+var MIME_TYPES = {
+  ".html": "text/html; charset=utf-8",
+  ".htm": "text/html; charset=utf-8",
+  ".css": "text/css; charset=utf-8",
+  ".js": "application/javascript; charset=utf-8",
+  ".mjs": "application/javascript; charset=utf-8",
+  ".json": "application/json",
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".gif": "image/gif",
+  ".svg": "image/svg+xml",
+  ".ico": "image/x-icon",
+  ".webp": "image/webp",
+  ".avif": "image/avif",
+  ".woff": "font/woff",
+  ".woff2": "font/woff2",
+  ".ttf": "font/ttf",
+  ".otf": "font/otf",
+  ".eot": "application/vnd.ms-fontobject",
+  ".txt": "text/plain; charset=utf-8",
+  ".xml": "application/xml",
+  ".pdf": "application/pdf",
+  ".zip": "application/zip",
+  ".wasm": "application/wasm",
+  ".map": "application/json"
+};
+
+// validate.ts
+function validate(schemas) {
+  return async (req, ctx, next) => {
+    const parsed = {};
+    const issues = [];
+    if (schemas.params) {
+      const result = schemas.params.safeParse(ctx.params);
+      if (result.success) {
+        parsed.params = result.data;
+      } else {
+        issues.push(...result.error.issues.map((i) => ({
+          path: ["params", ...i.path.map(String)],
+          message: i.message
+        })));
+      }
+    }
+    if (schemas.query) {
+      const result = schemas.query.safeParse(ctx.query);
+      if (result.success) {
+        parsed.query = result.data;
+      } else {
+        issues.push(...result.error.issues.map((i) => ({
+          path: ["query", ...i.path.map(String)],
+          message: i.message
+        })));
+      }
+    }
+    if (schemas.headers) {
+      const rawHeaders = {};
+      req.headers.forEach((v, k) => {
+        rawHeaders[k] = v;
+      });
+      const result = schemas.headers.safeParse(rawHeaders);
+      if (result.success) {
+        parsed.headers = result.data;
+      } else {
+        issues.push(...result.error.issues.map((i) => ({
+          path: ["headers", ...i.path.map(String)],
+          message: i.message
+        })));
+      }
+    }
+    if (schemas.body) {
+      if (req.body === null) {
+        issues.push({ path: ["body"], message: "Request body is required" });
+      } else {
+        const bodyText = await req.text();
+        if (!bodyText && req.method !== "GET" && req.method !== "HEAD") {
+          issues.push({ path: ["body"], message: "Request body is required" });
+        } else {
+          let bodyValue;
+          try {
+            bodyValue = JSON.parse(bodyText);
+          } catch {
+            bodyValue = bodyText;
+          }
+          const result = schemas.body.safeParse(bodyValue);
+          if (result.success) {
+            parsed.body = result.data;
+          } else {
+            issues.push(...result.error.issues.map((i) => ({
+              path: ["body", ...i.path.map(String)],
+              message: i.message
+            })));
+          }
+        }
+      }
+    }
+    if (issues.length > 0) {
+      return Response.json({ error: "Validation failed", issues }, { status: 400 });
+    }
+    ctx.parsed = parsed;
+    return next(req, ctx);
+  };
+}
+
+// cookie.ts
+function getCookies(req) {
+  const header = req.headers.get("cookie");
+  if (!header) return {};
+  const cookies = {};
+  for (const pair of header.split(";")) {
+    const idx = pair.indexOf("=");
+    if (idx === -1) continue;
+    const name = pair.slice(0, idx).trim();
+    const value = pair.slice(idx + 1).trim();
+    if (name) {
+      cookies[name] = decodeURIComponent(value);
+    }
+  }
+  return cookies;
+}
+function serializeCookie(name, value, options) {
+  const parts = [`${encodeURIComponent(name)}=${encodeURIComponent(value)}`];
+  if (options?.maxAge != null) parts.push(`Max-Age=${options.maxAge}`);
+  if (options?.expires) parts.push(`Expires=${options.expires.toUTCString()}`);
+  if (options?.domain) parts.push(`Domain=${options.domain}`);
+  if (options?.path) parts.push(`Path=${options.path}`);
+  if (options?.httpOnly) parts.push("HttpOnly");
+  if (options?.secure) parts.push("Secure");
+  if (options?.sameSite) parts.push(`SameSite=${options.sameSite}`);
+  return parts.join("; ");
+}
+function setCookie(res, name, value, options) {
+  const headers = new Headers(res.headers);
+  headers.append("Set-Cookie", serializeCookie(name, value, options));
+  return new Response(res.body, {
+    status: res.status,
+    statusText: res.statusText,
+    headers
+  });
+}
+function deleteCookie(res, name, options) {
+  const headers = new Headers(res.headers);
+  headers.append("Set-Cookie", serializeCookie(name, "", { ...options, maxAge: 0 }));
+  return new Response(res.body, {
+    status: res.status,
+    statusText: res.statusText,
+    headers
+  });
+}
+
+// upload.ts
+import { writeFile, mkdir } from "node:fs/promises";
+import { randomUUID } from "node:crypto";
+import { join as join2 } from "node:path";
+function upload(options) {
+  const saveDir = options?.dir;
+  return async (req, ctx, next) => {
+    const ct = req.headers.get("content-type") ?? "";
+    if (!ct.includes("multipart/form-data")) {
+      return next(req, ctx);
+    }
+    const match = ct.match(/boundary=(?:"([^"]+)"|([^;]+))/i);
+    if (!match) {
+      return Response.json({ error: "Missing boundary" }, { status: 400 });
+    }
+    const boundary = match[1] ?? match[2];
+    const body = await req.text();
+    const rawParts = body.split(`--${boundary}`).filter((p) => p && !p.startsWith("--") && !p.startsWith("\r\n--"));
+    const files = {};
+    const fields = {};
+    for (const raw of rawParts) {
+      const trimmed = raw.replace(/^\r?\n/, "");
+      const lines = trimmed.split(/\r?\n/);
+      let i = 0;
+      const headers = {};
+      while (i < lines.length && lines[i].length > 0) {
+        const sep3 = lines[i].indexOf(": ");
+        if (sep3 !== -1) headers[lines[i].slice(0, sep3).toLowerCase()] = lines[i].slice(sep3 + 2);
+        i++;
+      }
+      i++;
+      const bodyValue = lines.slice(i).join("\r\n");
+      const disposition = headers["content-disposition"] ?? "";
+      const nameMatch = disposition.match(/name="([^"]*)"/);
+      if (!nameMatch) continue;
+      const name = nameMatch[1];
+      const filenameMatch = disposition.match(/filename="([^"]*)"/);
+      const filename = filenameMatch?.[1];
+      if (filename) {
+        const buf = Buffer.from(bodyValue.replace(/\r?\n$/, ""), "binary");
+        if (options?.allowedTypes) {
+          const mime = headers["content-type"] ?? "application/octet-stream";
+          if (!options.allowedTypes.includes(mime)) {
+            return Response.json({ error: `File type not allowed: ${mime}` }, { status: 415 });
+          }
+        }
+        if (options?.maxFileSize && buf.byteLength > options.maxFileSize) {
+          return Response.json({ error: `File too large: ${filename}` }, { status: 413 });
+        }
+        const uf = {
+          name: filename,
+          type: headers["content-type"] ?? "application/octet-stream",
+          size: buf.byteLength,
+          buffer: saveDir ? void 0 : buf
+        };
+        if (saveDir) {
+          const filePath = join2(saveDir, `${randomUUID()}-${filename}`);
+          await mkdir(saveDir, { recursive: true });
+          await writeFile(filePath, buf);
+          uf.path = filePath;
+        }
+        if (files[name]) {
+          const existing = files[name];
+          files[name] = Array.isArray(existing) ? [...existing, uf] : [existing, uf];
+        } else {
+          files[name] = uf;
+        }
+      } else {
+        fields[name] = bodyValue.replace(/\r?\n$/, "");
+      }
+    }
+    ctx.parsed = { ...ctx.parsed, files, fields };
+    return next(req, ctx);
+  };
+}
+
+// rate-limit.ts
+function rateLimit(options) {
+  const max = options?.max ?? 100;
+  const window = options?.window ?? 6e4;
+  const getKey = options?.key ?? ((req) => {
+    const forwarded = req.headers.get("x-forwarded-for");
+    if (forwarded) return forwarded.split(",")[0].trim();
+    return new URL(req.url).hostname;
+  });
+  const message = options?.message ?? "Too Many Requests";
+  const hits = /* @__PURE__ */ new Map();
+  const interval = setInterval(() => {
+    const now = Date.now();
+    for (const [key, entry] of hits) {
+      if (entry.reset < now) hits.delete(key);
+    }
+  }, window);
+  if (interval.unref) interval.unref();
+  return async (req, ctx, next) => {
+    const key = getKey(req);
+    const now = Date.now();
+    const entry = hits.get(key);
+    if (!entry || entry.reset < now) {
+      hits.set(key, { count: 1, reset: now + window });
+      const res2 = await next(req, ctx);
+      const headers2 = new Headers(res2.headers);
+      headers2.set("X-RateLimit-Limit", String(max));
+      headers2.set("X-RateLimit-Remaining", String(max - 1));
+      headers2.set("X-RateLimit-Reset", String(Math.ceil((now + window) / 1e3)));
+      return new Response(res2.body, { status: res2.status, statusText: res2.statusText, headers: headers2 });
+    }
+    entry.count++;
+    const remaining = Math.max(0, max - entry.count);
+    if (entry.count > max) {
+      return new Response(message, {
+        status: 429,
+        headers: {
+          "Retry-After": String(Math.ceil((entry.reset - now) / 1e3)),
+          "X-RateLimit-Limit": String(max),
+          "X-RateLimit-Remaining": "0",
+          "X-RateLimit-Reset": String(Math.ceil(entry.reset / 1e3))
+        }
+      });
+    }
+    const res = await next(req, ctx);
+    const headers = new Headers(res.headers);
+    headers.set("X-RateLimit-Limit", String(max));
+    headers.set("X-RateLimit-Remaining", String(remaining));
+    headers.set("X-RateLimit-Reset", String(Math.ceil(entry.reset / 1e3)));
+    return new Response(res.body, { status: res.status, statusText: res.statusText, headers });
+  };
+}
+
+// compress.ts
+import { gzipSync, brotliCompressSync, constants } from "node:zlib";
+function compress(options) {
+  const level = options?.level ?? 6;
+  const threshold = options?.threshold ?? 1024;
+  return async (req, ctx, next) => {
+    const accept = req.headers.get("accept-encoding") ?? "";
+    const useBrotli = accept.includes("br");
+    const useGzip = !useBrotli && accept.includes("gzip");
+    const useDeflate = !useBrotli && !useGzip && accept.includes("deflate");
+    if (!useBrotli && !useGzip && !useDeflate) {
+      return next(req, ctx);
+    }
+    const res = await next(req, ctx);
+    if (res.status === 304 || res.status === 204 || res.status < 200 || res.status >= 300) {
+      return res;
+    }
+    const ce = res.headers.get("content-encoding");
+    if (ce) return res;
+    const ct = res.headers.get("content-type") ?? "";
+    if (!ct || ct.startsWith("audio/") || ct.startsWith("video/") || ct.startsWith("image/") || ct === "application/zip") {
+      return res;
+    }
+    const body = await res.bytes();
+    if (body.byteLength < threshold) return res;
+    let compressed;
+    let encoding;
+    if (useBrotli) {
+      compressed = brotliCompressSync(body, {
+        params: { [constants.BROTLI_PARAM_QUALITY]: Math.min(level, 11) }
+      });
+      encoding = "br";
+    } else if (useGzip) {
+      compressed = gzipSync(body, { level: Math.min(level, 9) });
+      encoding = "gzip";
+    } else {
+      compressed = gzipSync(body, { level: Math.min(level, 9) });
+      encoding = "deflate";
+    }
+    const headers = new Headers(res.headers);
+    headers.set("Content-Encoding", encoding);
+    headers.set("Content-Length", String(compressed.byteLength));
+    headers.delete("Content-Range");
+    headers.set("Vary", "Accept-Encoding");
+    return new Response(compressed, {
+      status: res.status,
+      statusText: res.statusText,
+      headers
+    });
+  };
+}
+export {
+  Router,
+  TsxContext,
+  auth,
+  compress,
+  cors,
+  deleteCookie,
+  getCookies,
+  logger,
+  rateLimit,
+  serve,
+  serveStatic,
+  setCookie,
+  tsx,
+  upload,
+  useTsx,
+  validate
+};