weifuwu 0.31.1 → 0.32.0

package/dist/index.js

@@ -9,7 +9,7 @@ var HttpError = class extends Error {
 };
 
 // src/core/trace.ts
-import crypto from "node:crypto";
+import crypto2 from "node:crypto";
 import { AsyncLocalStorage } from "node:async_hooks";
 var als = new AsyncLocalStorage();
 function currentTraceId() {
@@ -19,7 +19,7 @@ function currentTrace() {
   return als.getStore();
 }
 function runWithTrace(incomingTraceId, fn) {
-  const traceId = incomingTraceId || crypto.randomUUID();
+  const traceId = incomingTraceId || crypto2.randomUUID();
   const startTime = Date.now();
   return als.run({ traceId, startTime }, fn);
 }
@@ -30,7 +30,7 @@ function traceElapsed() {
 }
 function trace(options) {
   const header = options?.header ?? "X-Request-ID";
-  const gen = options?.generator ?? (() => crypto.randomUUID());
+  const gen = options?.generator ?? (() => crypto2.randomUUID());
   return async (req, ctx, next) => {
     const existing = req.headers.get(header);
     const requestId = existing ?? gen();
@@ -225,14 +225,14 @@ function serve(router, options) {
     if (!server.listening) return;
     server.close();
     server.closeIdleConnections();
-    return new Promise((resolve2) => {
+    return new Promise((resolve6) => {
       const timer = setTimeout(() => {
         server.closeAllConnections();
-        resolve2();
+        resolve6();
       }, timeoutMs);
       server.on("close", () => {
         clearTimeout(timer);
-        resolve2();
+        resolve6();
       });
     });
   }
@@ -277,7 +277,7 @@ function createHub(opts) {
       }
     });
   }
-  function join2(key, ws) {
+  function join4(key, ws) {
     if (!channels.has(key)) {
       channels.set(key, /* @__PURE__ */ new Set());
       redisSub?.subscribe(`${prefix}${key}`);
@@ -339,7 +339,7 @@ function createHub(opts) {
     redisPub = void 0;
     redisSub = null;
   }
-  return { join: join2, leave, broadcast, close };
+  return { join: join4, leave, broadcast, close };
 }
 
 // src/core/ws.ts
@@ -503,6 +503,20 @@ var Router = class _Router {
     this._checkMiddlewareMeta(mw, "global");
     return this;
   }
+  /**
+   * Install a plugin — a function that configures the Router with
+   * routes, middleware, and error handlers. Use when `.use()` isn't
+   * enough because you need to call `app.get()`, `app.onError()`, etc.
+   *
+   * @example
+   * ```ts
+   * app.plugin(app => createReactApp(app, { pages: {...}, layout: '...', tailwind: {...} }))
+   * ```
+   */
+  plugin(fn) {
+    fn(this);
+    return this;
+  }
   mount(path, router) {
     this._mountRouter(path, router);
     return this;
@@ -892,6 +906,78 @@ function cors(options) {
   };
 }
 
+// src/middleware/auth.ts
+import { createHmac, timingSafeEqual } from "node:crypto";
+function base64urlDecode(str) {
+  return Buffer.from(str.replace(/-/g, "+").replace(/_/g, "/"), "base64").toString("utf-8");
+}
+function sign(payload, secret) {
+  return createHmac("sha256", secret).update(payload).digest("base64url");
+}
+function parseCookie(cookieHeader, name) {
+  if (!cookieHeader) return null;
+  for (const c of cookieHeader.split(";")) {
+    const [key, ...rest] = c.trim().split("=");
+    if (key === name) return rest.join("=");
+  }
+  return null;
+}
+function auth(opts) {
+  return async (req, ctx, next) => {
+    if (opts.jwt) {
+      const cookie = opts.jwt.cookie ?? "token";
+      const token = parseCookie(req.headers.get("cookie"), cookie) ?? req.headers.get("authorization")?.replace(/^Bearer\s+/i, "");
+      if (token) {
+        try {
+          const [headerB64, payloadB64, sigB64] = token.split(".");
+          const expectedSig = sign(`${headerB64}.${payloadB64}`, opts.jwt.secret);
+          const sigBuf = Buffer.from(sigB64, "base64url");
+          const expectedBuf = Buffer.from(expectedSig, "base64url");
+          if (sigBuf.length === expectedBuf.length && timingSafeEqual(sigBuf, expectedBuf)) {
+            const payload = JSON.parse(base64urlDecode(payloadB64));
+            ctx.user = {
+              id: payload.sub ?? payload.id ?? "unknown",
+              role: payload.role,
+              tenant: payload.tenant,
+              ...payload
+            };
+          }
+        } catch {
+        }
+      }
+    }
+    if (opts.session && !ctx.user) {
+      const cookie = opts.session.cookie ?? "session";
+      const raw = parseCookie(req.headers.get("cookie"), cookie);
+      if (raw) {
+        try {
+          const [dataB64, sigB64] = raw.split(".");
+          const expectedSig = sign(dataB64, opts.session.secret);
+          const sigBuf = Buffer.from(sigB64, "base64url");
+          const expectedBuf = Buffer.from(expectedSig, "base64url");
+          if (sigBuf.length === expectedBuf.length && timingSafeEqual(sigBuf, expectedBuf)) {
+            const data = JSON.parse(base64urlDecode(dataB64));
+            const user = await opts.session.loadUser(data);
+            if (user) ctx.user = user;
+          }
+        } catch {
+        }
+      }
+    }
+    if (opts.apiKey && !ctx.user) {
+      const header = opts.apiKey.header ?? "authorization";
+      const prefix = opts.apiKey.prefix ?? "Bearer ";
+      const raw = req.headers.get(header);
+      if (raw?.startsWith(prefix)) {
+        const key = raw.slice(prefix.length);
+        const user = await opts.apiKey.validate(key);
+        if (user) ctx.user = user;
+      }
+    }
+    return next(req, ctx);
+  };
+}
+
 // src/middleware/static.ts
 import { open, realpath } from "node:fs/promises";
 import { extname, resolve, normalize, sep } from "node:path";
@@ -912,13 +998,13 @@ function serveStatic(root, options) {
     let fileHandle;
     try {
       fileHandle = await open(filePath, "r");
-      let stat = await fileHandle.stat();
+      let stat3 = await fileHandle.stat();
       const realPath = await realpath(filePath);
       if (!realPath.startsWith(rootDir + sep) && realPath !== rootDir) {
         await fileHandle.close();
         return new Response("Forbidden", { status: 403 });
       }
-      if (stat.isDirectory()) {
+      if (stat3.isDirectory()) {
         await fileHandle.close();
         const indexFile = opts.index ?? "index.html";
         filePath = resolve(filePath, indexFile);
@@ -926,29 +1012,29 @@ function serveStatic(root, options) {
           return new Response("Forbidden", { status: 403 });
         }
         fileHandle = await open(filePath, "r");
-        stat = await fileHandle.stat();
-        if (!stat.isFile()) {
+        stat3 = await fileHandle.stat();
+        if (!stat3.isFile()) {
           await fileHandle.close();
           return new Response("Not Found", { status: 404 });
         }
       }
       const mimeType = MIME_TYPES[extname(filePath).toLowerCase()] ?? "application/octet-stream";
-      const etag = `"${stat.ino}-${stat.size}-${stat.mtimeMs}"`;
+      const etag = `"${stat3.ino}-${stat3.size}-${stat3.mtimeMs}"`;
       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()) {
+      if (ifModifiedSince && stat3.mtimeMs <= new Date(ifModifiedSince).getTime()) {
         await fileHandle.close();
         return new Response(null, { status: 304 });
       }
       const headers = {
         "Content-Type": mimeType,
-        "Content-Length": String(stat.size),
+        "Content-Length": String(stat3.size),
         ETag: etag,
-        "Last-Modified": stat.mtime.toUTCString(),
+        "Last-Modified": stat3.mtime.toUTCString(),
         "Cache-Control": opts.immutable ? `public, max-age=${opts.maxAge ?? 31536e3}, immutable` : `public, max-age=${opts.maxAge ?? 0}`
       };
       const readStream = fileHandle.createReadStream();
@@ -1099,6 +1185,604 @@ function upload(options) {
   return mw;
 }
 
+// src/middleware/sandbox.ts
+import { join as join2, resolve as resolve2, normalize as normalize2 } from "node:path";
+import { mkdir as mkdir2, readFile, writeFile as writeFile2, rm } from "node:fs/promises";
+import { exec as cpExec } from "node:child_process";
+import { promisify } from "node:util";
+var runExec = promisify(cpExec);
+function sandbox(opts = {}) {
+  const base = resolve2(opts.baseDir ?? "/tmp/weifuwu-sandboxes");
+  const defaultTimeout = opts.timeout ?? 3e4;
+  return async (req, ctx, next) => {
+    let sessionId;
+    if (opts.isolateBy === "user" && ctx.user) {
+      sessionId = ctx.user.id ?? "default";
+    } else {
+      sessionId = crypto.randomUUID();
+    }
+    const workDir = join2(base, encodeURIComponent(sessionId));
+    await mkdir2(workDir, { recursive: true });
+    function safePath(p) {
+      const resolved = resolve2(workDir, normalize2(p).replace(/^[/\\]+/, ""));
+      if (!resolved.startsWith(workDir + "/") && resolved !== workDir) {
+        throw new Error(`Path escape rejected: ${p}`);
+      }
+      return resolved;
+    }
+    ctx.sandbox = {
+      workDir,
+      async readFile(path) {
+        return readFile(safePath(path), "utf-8");
+      },
+      async writeFile(path, content) {
+        const resolved = safePath(path);
+        await mkdir2(join2(resolved, ".."), { recursive: true });
+        return writeFile2(resolved, content, "utf-8");
+      },
+      async exec(cmd, execOpts) {
+        const cwd = execOpts?.cwd ? safePath(execOpts.cwd) : workDir;
+        const { stdout, stderr } = await runExec(cmd, {
+          cwd,
+          timeout: execOpts?.timeout ?? defaultTimeout,
+          env: {
+            ...process.env,
+            HOME: workDir,
+            PATH: process.env.PATH ?? "/usr/local/bin:/usr/bin:/bin"
+          },
+          maxBuffer: 10 * 1024 * 1024
+          // 10MB
+        });
+        return { stdout, stderr };
+      },
+      async grep(pattern) {
+        const { stdout } = await runExec(
+          `grep -rn --include='*' "${pattern.replace(/"/g, '\\"')}" . 2>/dev/null || true`,
+          { cwd: workDir, timeout: 1e4 }
+        );
+        return stdout;
+      },
+      async destroy() {
+        await rm(workDir, { recursive: true, force: true });
+      }
+    };
+    try {
+      return await next(req, ctx);
+    } finally {
+    }
+  };
+}
+
+// src/middleware/esbuild-dev.ts
+import { resolve as resolve3, relative, dirname } from "node:path";
+import { stat, readFile as readFile2, realpath as realpath2 } from "node:fs/promises";
+function escapeHtml(s) {
+  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+function defaultErrorTemplate(errors) {
+  return `<!DOCTYPE html>
+<html>
+<head>
+  <meta charset="utf-8">
+  <title>Build Error</title>
+  <style>
+    * { margin: 0; padding: 0; box-sizing: border-box; }
+    body { font-family: system-ui; background: #1a1a2e; color: #e0e0e0; padding: 2rem; }
+    .overlay { position: fixed; inset: 0; display: flex; align-items: center; justify-content: center; }
+    .card { background: #16213e; border: 1px solid #e74c3c; border-radius: 12px; padding: 2rem; max-width: 800px; width: 100%; box-shadow: 0 8px 32px rgba(0,0,0,0.4); }
+    h1 { color: #e74c3c; font-size: 1.5rem; margin-bottom: 1rem; display: flex; align-items: center; gap: 0.5rem; }
+    pre { background: #0f0f23; padding: 1.5rem; border-radius: 8px; overflow: auto; font-size: 0.85rem; line-height: 1.6; white-space: pre-wrap; word-break: break-word; }
+  </style>
+</head>
+<body>
+  <div class="overlay">
+    <div class="card">
+      <h1>\u26A0 esbuild Build Error</h1>
+      <pre>${escapeHtml(errors)}</pre>
+    </div>
+  </div>
+</body>
+</html>`;
+}
+async function collectDeps(entryPath) {
+  const files = /* @__PURE__ */ new Map();
+  const visited = /* @__PURE__ */ new Set();
+  const queue2 = [entryPath];
+  while (queue2.length > 0) {
+    const p = queue2.shift();
+    try {
+      const real = await realpath2(p);
+      if (visited.has(real)) continue;
+      visited.add(real);
+      const s = await stat(real);
+      files.set(real, s.mtimeMs);
+    } catch {
+      continue;
+    }
+    try {
+      const content = await readFile2(p, "utf-8");
+      const importRe = /from\s+['"]([^'"]+)['"]|import\s+['"]([^'"]+)['"]/g;
+      let m;
+      while ((m = importRe.exec(content)) !== null) {
+        const spec = m[1] ?? m[2];
+        if (spec.startsWith(".") || spec.startsWith("/")) {
+          const dir = dirname(p);
+          const resolved = resolve3(dir, spec);
+          for (const ext of ["", ".ts", ".tsx", ".js", ".jsx", ".mjs", "/index.ts", "/index.tsx", "/index.js"]) {
+            const candidate = resolved + ext;
+            if (!visited.has(candidate)) {
+              queue2.push(candidate);
+              break;
+            }
+            break;
+          }
+          queue2.push(resolved);
+        }
+      }
+    } catch {
+    }
+  }
+  return files;
+}
+function esbuildDev(opts) {
+  const cache = opts.cache ?? "memory";
+  const importmap = opts.importmap ?? false;
+  const importmapOverrides = opts.importmapOverrides ?? {};
+  const errorTemplate = opts.errorTemplate ?? defaultErrorTemplate;
+  const entries = Object.entries(opts.entries).map(([p, e]) => {
+    const path = p.startsWith("/") ? p : "/" + p;
+    const config = typeof e === "string" ? { entry: e } : e;
+    return { path, config };
+  });
+  const cacheStore = /* @__PURE__ */ new Map();
+  const chunkMap = /* @__PURE__ */ new Map();
+  let esbuild_ = null;
+  let esbuildLoadError = null;
+  async function getEsbuild() {
+    if (esbuild_) return esbuild_;
+    try {
+      esbuild_ = await import("esbuild");
+      return esbuild_;
+    } catch (err) {
+      esbuildLoadError = `esbuild is not installed. Run: npm install -D esbuild
+
+${String(err)}`;
+      throw new Error(esbuildLoadError, { cause: err });
+    }
+  }
+  let importmapScript = null;
+  function buildImportmap() {
+    const mappings = {};
+    Object.assign(mappings, importmapOverrides);
+    for (const { path, config } of entries) {
+      const entryName = path.split("/").pop() ?? "";
+      if (entryName.includes("vendor") || config.external && config.external.length === 0 || !config.external && config.bundle !== false) {
+        if (!mappings["react"]) mappings["react"] = path;
+        if (!mappings["react/jsx-runtime"]) mappings["react/jsx-runtime"] = path;
+        if (!mappings["react-dom/client"]) mappings["react-dom/client"] = path;
+        if (!mappings["react-dom"]) mappings["react-dom"] = path;
+      }
+    }
+    const json = JSON.stringify({ imports: mappings });
+    return `<script type="importmap">${json}</script>`;
+  }
+  async function compile(entry) {
+    const esbuild = await getEsbuild();
+    const isClientRouter = !!entry.clientRouter;
+    let entryAbs;
+    let buildOpts;
+    if (isClientRouter) {
+      const cr = entry.clientRouter;
+      const virtualModule = "weifuwu:client-entry";
+      entryAbs = virtualModule;
+      const layoutImport = `import * as _layout from '${cr.layout}'
+const _lx = Object.entries(_layout).filter(([,v]) => typeof v === 'function')
+const Layout = _layout.default || (_lx[0]?.[1])`;
+      let routesCode;
+      if (cr.pages) {
+        const entries2 = Object.entries(cr.pages).map(
+          ([path, component]) => `  '${path}': () => import('${component}'),`
+        );
+        routesCode = `const routes = {
+${entries2.join("\n")}
+}`;
+      } else if (cr.routes) {
+        routesCode = `import { routes } from '${cr.routes}'`;
+      } else {
+        routesCode = "const routes = {}";
+      }
+      const fallbackLine = cr.fallback ? `const fallback = () => import('${cr.fallback}')` : "";
+      const fallbackOpt = cr.fallback ? "  fallback," : "";
+      const generatedCode = [
+        `import { createBrowserRouter } from 'weifuwu/react/client'`,
+        layoutImport,
+        routesCode,
+        fallbackLine,
+        "",
+        "createBrowserRouter({",
+        "  layout: Layout,",
+        "  routes,",
+        fallbackOpt,
+        "})"
+      ].filter(Boolean).join("\n");
+      buildOpts = {
+        entryPoints: [virtualModule],
+        bundle: entry.bundle ?? true,
+        external: entry.external ?? [],
+        minify: entry.minify ?? true,
+        platform: entry.platform ?? "browser",
+        format: entry.format ?? "esm",
+        sourcemap: entry.sourcemap ?? false,
+        splitting: entry.splitting ?? false,
+        ...entry.splitting ? { outdir: resolve3(".weifuwu-esbuild-out") } : {},
+        define: entry.define,
+        loader: entry.loader,
+        write: false,
+        logLevel: "silent",
+        plugins: [{
+          name: "weifuwu-client-router",
+          setup(build) {
+            build.onResolve({ filter: new RegExp(`^${virtualModule.replace(/:/g, "\\:")}$`) }, () => ({
+              path: virtualModule,
+              namespace: "weifuwu-client"
+            }));
+            build.onLoad({ filter: /.*/, namespace: "weifuwu-client" }, () => ({
+              contents: generatedCode,
+              loader: "ts",
+              resolveDir: process.cwd()
+            }));
+          }
+        }]
+      };
+    } else {
+      entryAbs = resolve3(entry.entry);
+      buildOpts = {
+        entryPoints: [entryAbs],
+        bundle: entry.bundle ?? true,
+        external: entry.external ?? [],
+        minify: entry.minify ?? true,
+        platform: entry.platform ?? "browser",
+        format: entry.format ?? "esm",
+        sourcemap: entry.sourcemap ?? false,
+        splitting: entry.splitting ?? false,
+        ...entry.splitting ? { outdir: dirname(entryAbs) } : {},
+        define: entry.define,
+        loader: entry.loader,
+        write: false,
+        logLevel: "silent"
+      };
+    }
+    const result = await esbuild.build(buildOpts);
+    const msgs = [];
+    for (const w of result.warnings) {
+      const loc = w.location ? ` at ${relative(".", w.location.file ?? "")}:${w.location.line}:${w.location.column}` : "";
+      msgs.push(`[warn] ${w.text}${loc}`);
+    }
+    for (const e of result.errors) {
+      const loc = e.location ? ` at ${relative(".", e.location.file ?? "")}:${e.location.line}:${e.location.column}` : "";
+      msgs.push(`[error] ${e.text}${loc}`);
+    }
+    if (result.errors.length > 0) {
+      throw new Error(msgs.join("\n"));
+    }
+    const outputFiles = result.outputFiles;
+    const entryFile = outputFiles.find((f) => f.path === entryAbs) ?? outputFiles[0];
+    const code = entryFile?.text ?? "";
+    let chunks;
+    if (outputFiles.length > 1) {
+      chunks = /* @__PURE__ */ new Map();
+      for (const f of outputFiles) {
+        if (f === entryFile) continue;
+        const chunkName = f.path.split("/").pop() ?? f.path;
+        chunks.set(chunkName, { code: f.text, etag: `"esbuild-${hashCode(f.text)}"` });
+      }
+    }
+    const etag = `"esbuild-${hashCode(code)}"`;
+    if (msgs.length > 0) {
+      console.error("[esbuildDev]", msgs.join("\n"));
+    }
+    return { code, etag, chunks };
+  }
+  function isCacheValid2(cached) {
+    return Promise.all(
+      [...cached.files].map(async ([file, mtime]) => {
+        try {
+          const s = await stat(file);
+          return s.mtimeMs === mtime;
+        } catch {
+          return false;
+        }
+      })
+    ).then((results) => results.every(Boolean));
+  }
+  return async (req, ctx, next) => {
+    const url = new URL(req.url);
+    const pathname = url.pathname;
+    if (importmap && pathname === "/assets/importmap") {
+      if (!importmapScript) importmapScript = buildImportmap();
+      return new Response(importmapScript, {
+        headers: {
+          "Content-Type": "application/javascript; charset=utf-8",
+          "Cache-Control": "no-cache"
+        }
+      });
+    }
+    const matched = entries.find((e) => e.path === pathname);
+    const chunkName = pathname.split("/").pop() ?? "";
+    const chunkOwner = chunkMap.get(chunkName);
+    if (!matched && !chunkOwner) return next(req, ctx);
+    if (!matched && chunkOwner) {
+      const ownerCache = cacheStore.get(chunkOwner);
+      const chunk = ownerCache?.chunks?.get(chunkName);
+      if (chunk) {
+        if (req.headers.get("if-none-match") === chunk.etag) {
+          return new Response(null, { status: 304 });
+        }
+        return new Response(chunk.code, {
+          headers: {
+            "Content-Type": "text/javascript; charset=utf-8",
+            ETag: chunk.etag,
+            "Cache-Control": "no-cache"
+          }
+        });
+      }
+      return next(req, ctx);
+    }
+    const { config } = matched;
+    try {
+      if (cache === "memory") {
+        const cached = cacheStore.get(pathname);
+        if (cached) {
+          const valid = await isCacheValid2(cached);
+          if (valid) {
+            if (req.headers.get("if-none-match") === cached.etag) {
+              return new Response(null, { status: 304 });
+            }
+            return new Response(cached.code, {
+              headers: {
+                "Content-Type": "text/javascript; charset=utf-8",
+                ETag: cached.etag,
+                "Cache-Control": "no-cache"
+              }
+            });
+          }
+          for (const [cn] of cached.chunks ?? []) chunkMap.delete(cn);
+          cacheStore.delete(pathname);
+        }
+      }
+      const { code, etag, chunks } = await compile(config);
+      const depEntry = config.clientRouter?.routes ?? (config.clientRouter?.pages ? Object.values(config.clientRouter.pages)[0] : void 0) ?? config.entry;
+      const deps = await collectDeps(resolve3(depEntry));
+      if (cache === "memory") {
+        cacheStore.set(pathname, { code, etag, files: deps, chunks });
+        if (chunks) {
+          for (const [cn] of chunks) chunkMap.set(cn, pathname);
+        }
+      }
+      return new Response(code, {
+        headers: {
+          "Content-Type": "text/javascript; charset=utf-8",
+          ETag: etag,
+          "Cache-Control": "no-cache"
+        }
+      });
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      const html = errorTemplate(message);
+      return new Response(html, {
+        status: 500,
+        headers: { "Content-Type": "text/html; charset=utf-8" }
+      });
+    }
+  };
+}
+function hashCode(s) {
+  let hash = 0;
+  for (let i = 0; i < s.length; i++) {
+    const ch = s.charCodeAt(i);
+    hash = (hash << 5) - hash + ch;
+    hash |= 0;
+  }
+  return Math.abs(hash).toString(36);
+}
+
+// src/middleware/tailwind-dev.ts
+import { resolve as resolve4 } from "node:path";
+import { stat as stat2, readFile as readFile3, glob } from "node:fs/promises";
+function escapeHtml2(s) {
+  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+function defaultErrorTemplate2(errors) {
+  return `<!DOCTYPE html>
+<html>
+<head>
+  <meta charset="utf-8">
+  <title>Tailwind Build Error</title>
+  <style>
+    * { margin: 0; padding: 0; box-sizing: border-box; }
+    body { font-family: system-ui; background: #1a1a2e; color: #e0e0e0; padding: 2rem; }
+    .overlay { position: fixed; inset: 0; display: flex; align-items: center; justify-content: center; }
+    .card { background: #16213e; border: 1px solid #06b6d4; border-radius: 12px; padding: 2rem; max-width: 800px; width: 100%; box-shadow: 0 8px 32px rgba(0,0,0,0.4); }
+    h1 { color: #06b6d4; font-size: 1.5rem; margin-bottom: 1rem; display: flex; align-items: center; gap: 0.5rem; }
+    pre { background: #0f0f23; padding: 1.5rem; border-radius: 8px; overflow: auto; font-size: 0.85rem; line-height: 1.6; white-space: pre-wrap; word-break: break-word; }
+  </style>
+</head>
+<body>
+  <div class="overlay">
+    <div class="card">
+      <h1>\u{1F3A8} Tailwind CSS Build Error</h1>
+      <pre>${escapeHtml2(errors)}</pre>
+    </div>
+  </div>
+</body>
+</html>`;
+}
+var TW_CANDIDATE_RE = /[a-z][\w-]*(?::[a-z][\w-]*)*(?:-\[[^\]]*\])*(?:\/[0-9]+)?/gi;
+var CLASS_CONTEXT_RE = /(?:class(?:Name)?\s*[=:]\s*["'`]([^"'`]+)["'`]|["'`]([^"'`\n]{2,})["'`])/g;
+async function extractCandidates(patterns, root) {
+  const seen = /* @__PURE__ */ new Set();
+  for (const pattern of patterns) {
+    const resolved = resolve4(root, pattern);
+    try {
+      for await (const file of glob(resolved)) {
+        try {
+          const content = await readFile3(file, "utf-8");
+          for (const m of content.matchAll(CLASS_CONTEXT_RE)) {
+            const str = m[1] ?? m[2];
+            if (!str) continue;
+            for (const c of str.matchAll(TW_CANDIDATE_RE)) {
+              seen.add(c[0]);
+            }
+          }
+        } catch {
+        }
+      }
+    } catch {
+    }
+  }
+  return [...seen];
+}
+async function collectFileMtimes(files) {
+  const map = /* @__PURE__ */ new Map();
+  await Promise.all(
+    files.map(async (f) => {
+      try {
+        const s = await stat2(f);
+        map.set(f, s.mtimeMs);
+      } catch {
+      }
+    })
+  );
+  return map;
+}
+function isCacheValid(cached) {
+  return Promise.all(
+    [...cached.files].map(async ([file, mtime]) => {
+      try {
+        const s = await stat2(file);
+        return s.mtimeMs === mtime;
+      } catch {
+        return false;
+      }
+    })
+  ).then((results) => results.every(Boolean));
+}
+function tailwindDev(opts) {
+  const cacheMode = opts.cache ?? "memory";
+  const errorTemplate = opts.errorTemplate ?? defaultErrorTemplate2;
+  const entries = Object.entries(opts.entries).map(([p, e]) => {
+    const path = p.startsWith("/") ? p : "/" + p;
+    const config = typeof e === "string" ? { entry: e } : e;
+    return { path, config };
+  });
+  const cacheStore = /* @__PURE__ */ new Map();
+  let compileFn = null;
+  let loadError = null;
+  async function getCompile() {
+    if (compileFn) return compileFn;
+    try {
+      const mod = await import("@tailwindcss/node");
+      compileFn = mod.compile;
+      return compileFn;
+    } catch (err) {
+      loadError = `@tailwindcss/node is not installed. Run: npm install -D tailwindcss @tailwindcss/node
+
+${String(err)}`;
+      throw new Error(loadError, { cause: err });
+    }
+  }
+  async function compileCss(entry) {
+    const compile = await getCompile();
+    const entryAbs = resolve4(entry.entry);
+    const cssSource = await readFile3(entryAbs, "utf-8");
+    const baseDir = resolve4(entry.entry, "..");
+    const deps = [entryAbs];
+    const result = await compile(cssSource, {
+      base: baseDir,
+      onDependency: (p) => {
+        if (!deps.includes(p)) deps.push(p);
+      }
+    });
+    const contentPatterns = entry.content ?? [];
+    for (const src of result.sources) {
+      if (!src.negated) {
+        contentPatterns.push(resolve4(src.base, src.pattern));
+      }
+    }
+    let candidates = [];
+    if (contentPatterns.length > 0) {
+      candidates = await extractCandidates(contentPatterns, baseDir);
+    }
+    const css = result.build(candidates);
+    for (const pattern of contentPatterns) {
+      try {
+        for await (const file of glob(resolve4(baseDir, pattern))) {
+          if (!deps.includes(file)) deps.push(file);
+        }
+      } catch {
+      }
+    }
+    const etag = `"tw-${hashCode2(css)}"`;
+    return { css, etag, files: deps };
+  }
+  return async (req, ctx, next) => {
+    const url = new URL(req.url);
+    const pathname = url.pathname;
+    const matched = entries.find((e) => e.path === pathname);
+    if (!matched) return next(req, ctx);
+    const { config } = matched;
+    try {
+      if (cacheMode === "memory") {
+        const cached = cacheStore.get(pathname);
+        if (cached) {
+          const valid = await isCacheValid(cached);
+          if (valid) {
+            if (req.headers.get("if-none-match") === cached.etag) {
+              return new Response(null, { status: 304 });
+            }
+            return new Response(cached.css, {
+              headers: {
+                "Content-Type": "text/css; charset=utf-8",
+                ETag: cached.etag,
+                "Cache-Control": "no-cache"
+              }
+            });
+          }
+          cacheStore.delete(pathname);
+        }
+      }
+      const { css, etag, files } = await compileCss(config);
+      if (cacheMode === "memory") {
+        const mtimes = await collectFileMtimes(files);
+        cacheStore.set(pathname, { css, etag, files: mtimes });
+      }
+      return new Response(css, {
+        headers: {
+          "Content-Type": "text/css; charset=utf-8",
+          ETag: etag,
+          "Cache-Control": "no-cache"
+        }
+      });
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      const html = errorTemplate(message);
+      return new Response(html, {
+        status: 500,
+        headers: { "Content-Type": "text/html; charset=utf-8" }
+      });
+    }
+  };
+}
+function hashCode2(s) {
+  let hash = 0;
+  for (let i = 0; i < s.length; i++) {
+    const ch = s.charCodeAt(i);
+    hash = (hash << 5) - hash + ch;
+    hash |= 0;
+  }
+  return Math.abs(hash).toString(36);
+}
+
 // src/middleware/rate-limit.ts
 function defaultKey(_req, _ctx) {
   const forwarded = _req.headers.get("x-forwarded-for");
@@ -1111,7 +1795,7 @@ function defaultKey(_req, _ctx) {
 }
 function rateLimit(options) {
   const max = options?.max ?? 100;
-  const window2 = options?.window ?? 6e4;
+  const window = options?.window ?? 6e4;
   const getKey = options?.key ?? defaultKey;
   const message = options?.message ?? "Too Many Requests";
   const storeType = options?.store ?? "memory";
@@ -1138,7 +1822,7 @@ function rateLimit(options) {
         }
       }
     },
-    Math.min(window2, 3e4)
+    Math.min(window, 3e4)
   ) : null;
   if (interval?.unref) interval.unref();
   async function checkAndIncrement(key) {
@@ -1147,16 +1831,16 @@ function rateLimit(options) {
       const redisKey = `${keyPrefix}${key}`;
       const count = await redis2.incr(redisKey);
       if (count === 1) {
-        await redis2.pexpire(redisKey, window2);
+        await redis2.pexpire(redisKey, window);
       }
       const pttl = await redis2.pttl(redisKey);
-      const reset = pttl > 0 ? now + pttl : now + window2;
+      const reset = pttl > 0 ? now + pttl : now + window;
       return { count, reset };
     }
     const entry = hits.get(key);
     if (!entry || entry.reset < now) {
-      hits.set(key, { count: 1, reset: now + window2 });
-      return { count: 1, reset: now + window2 };
+      hits.set(key, { count: 1, reset: now + window });
+      return { count: 1, reset: now + window };
     }
     entry.count++;
     return { count: entry.count, reset: entry.reset };
@@ -1202,10 +1886,10 @@ function addRateLimitHeaders(res, limit, remaining, reset) {
 
 // src/middleware/compress.ts
 import { constants, brotliCompress, gzip, deflate } from "node:zlib";
-import { promisify } from "node:util";
-var brotliCompressAsync = promisify(brotliCompress);
-var gzipAsync = promisify(gzip);
-var deflateAsync = promisify(deflate);
+import { promisify as promisify2 } from "node:util";
+var brotliCompressAsync = promisify2(brotliCompress);
+var gzipAsync = promisify2(gzip);
+var deflateAsync = promisify2(deflate);
 function compress(options) {
   const level = options?.level ?? 6;
   const threshold = options?.threshold ?? 1024;
@@ -1610,7 +2294,7 @@ function redis(opts) {
 }
 
 // src/queue/index.ts
-import crypto2 from "node:crypto";
+import crypto3 from "node:crypto";
 import { Redis as IORedis2 } from "ioredis";
 
 // src/queue/cron.ts
@@ -1724,7 +2408,7 @@ function queue(opts) {
     }
     if (job.schedule) {
       try {
-        await insert({ ...job, id: crypto2.randomUUID(), runAt: cronNext(job.schedule), createdAt: Date.now() });
+        await insert({ ...job, id: crypto3.randomUUID(), runAt: cronNext(job.schedule), createdAt: Date.now() });
       } catch {
       }
     }
@@ -1750,7 +2434,7 @@ function queue(opts) {
   });
   const q = mw;
   mw.add = function add(type, payload, opts2) {
-    const id = crypto2.randomUUID();
+    const id = crypto3.randomUUID();
     let runAt;
     if (opts2?.schedule) {
       try {
@@ -1868,7 +2552,7 @@ function queue(opts) {
     return r;
   };
   q.cron = function(pattern, handler) {
-    const id = "__cron_" + pattern.replace(/[^a-zA-Z0-9]/g, "_") + "_" + crypto2.randomUUID().slice(0, 8);
+    const id = "__cron_" + pattern.replace(/[^a-zA-Z0-9]/g, "_") + "_" + crypto3.randomUUID().slice(0, 8);
     q.process(id, async () => {
       await handler();
     });
@@ -1879,14 +2563,118 @@ function queue(opts) {
 }
 
 // src/react/index.ts
-import { Fragment as Fragment2 } from "react";
+import { createElement as createElement2 } from "react";
+import { renderToReadableStream } from "react-dom/server";
 
-// src/react/render.ts
-import {
-  createElement,
-  Fragment
-} from "react";
-import { renderToString, renderToReadableStream } from "react-dom/server";
+// src/react/compile.ts
+import { mkdir as mkdir3, writeFile as writeFile3, readFile as readFile4 } from "node:fs/promises";
+import { resolve as resolve5, join as join3, dirname as dirname2 } from "node:path";
+import { createHash } from "node:crypto";
+import { existsSync } from "node:fs";
+var EXTERNAL_PKGS = [
+  "react",
+  "react/jsx-runtime",
+  "react-dom",
+  "react-dom/server",
+  "react-dom/client",
+  "weifuwu",
+  "weifuwu/react"
+];
+var FRAMEWORK_IMPORTS = [
+  "react",
+  "react/jsx-runtime",
+  "react-dom",
+  "react-dom/server",
+  "react-dom/client",
+  "weifuwu",
+  "weifuwu/react"
+];
+var memCache = /* @__PURE__ */ new Map();
+function buildResolveMap() {
+  const map = {};
+  for (const spec of FRAMEWORK_IMPORTS) {
+    try {
+      map[spec] = import.meta.resolve(spec);
+    } catch {
+    }
+  }
+  return map;
+}
+var _resolveMap = null;
+function resolveMap() {
+  if (!_resolveMap) _resolveMap = buildResolveMap();
+  return _resolveMap;
+}
+function rewriteImports(code) {
+  const map = resolveMap();
+  let result = code;
+  for (const [spec, url] of Object.entries(map)) {
+    const quoted = JSON.stringify(spec);
+    const escaped = quoted.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    result = result.replace(new RegExp(`(from\\s+)${escaped}`, "g"), `$1${JSON.stringify(url)}`).replace(new RegExp(`(import\\s+)${escaped}(\\s*;)`, "g"), `$1${JSON.stringify(url)}$2`).replace(new RegExp(`(export\\s+.*?from\\s+)${escaped}`, "g"), `$1${JSON.stringify(url)}`);
+  }
+  return result;
+}
+var _cacheDir = null;
+function setReactCacheDir(dir) {
+  _cacheDir = dir;
+}
+function getCacheDir() {
+  if (_cacheDir) return _cacheDir;
+  _cacheDir = join3(process.cwd(), "node_modules", ".weifuwu", "react");
+  return _cacheDir;
+}
+async function loadTsxModule(entryPath) {
+  const abs = resolve5(entryPath);
+  let source;
+  try {
+    source = await readFile4(abs, "utf-8");
+  } catch {
+    throw new Error(`Cannot read file: ${entryPath}`);
+  }
+  const sourceHash = createHash("sha256").update(source).digest("hex").slice(0, 16);
+  const memCached = memCache.get(abs);
+  if (memCached && memCached.sourceHash === sourceHash) {
+    return memCached.mod;
+  }
+  const tmpDir = getCacheDir();
+  const tmpFile = join3(tmpDir, `${sourceHash}.mjs`);
+  if (existsSync(tmpFile)) {
+    try {
+      const mod2 = await import(tmpFile + "?" + sourceHash);
+      memCache.set(abs, { sourceHash, mod: mod2 });
+      return mod2;
+    } catch {
+    }
+  }
+  const esbuild = await import("esbuild");
+  const result = await esbuild.build({
+    entryPoints: [abs],
+    bundle: true,
+    write: false,
+    format: "esm",
+    platform: "node",
+    jsx: "automatic",
+    external: EXTERNAL_PKGS,
+    logLevel: "silent"
+  });
+  let code = result.outputFiles[0]?.text ?? "";
+  if (!code) throw new Error(`esbuild produced empty output for ${entryPath}`);
+  code = rewriteImports(code);
+  await mkdir3(dirname2(tmpFile), { recursive: true });
+  await writeFile3(tmpFile, code);
+  const mod = await import(tmpFile + "?" + sourceHash);
+  memCache.set(abs, { sourceHash, mod });
+  return mod;
+}
+async function loadTsxComponent(entryPath) {
+  const mod = await loadTsxModule(entryPath);
+  if (mod.default && typeof mod.default === "function") return mod.default;
+  for (const [, val] of Object.entries(mod)) {
+    if (typeof val === "function") return val;
+  }
+  throw new Error(`No component export found in ${entryPath}. Export a default or named component function.`);
+}
 
 // src/react/context.ts
 import { createContext } from "react";
@@ -1901,327 +2689,411 @@ function getServerDataContext() {
 }
 var ServerDataContext = getServerDataContext();
 
-// src/react/render.ts
-var encoder = new TextEncoder();
-var decoder = new TextDecoder();
-function escapeAttr(s) {
-  return s.replace(/&/g, "&amp;").replace(/"/g, "&quot;");
-}
-function buildHeadTags(head) {
-  if (!head) return "";
-  const tags = [];
-  if (head.title) tags.push(`<title>${escapeAttr(head.title)}</title>`);
-  if (head.meta) {
-    for (const [name, content] of Object.entries(head.meta)) {
-      tags.push(`<meta name="${escapeAttr(name)}" content="${escapeAttr(content)}">`);
-    }
+// src/react/error-boundary.ts
+import { createElement, Component } from "react";
+var ErrorBoundary = class extends Component {
+  state = { hasError: false, error: null };
+  static getDerivedStateFromError(error) {
+    return { hasError: true, error };
   }
-  if (head.links) {
-    for (const link of head.links) {
-      const attrs = Object.entries(link).map(([k, v]) => `${k}="${escapeAttr(v)}"`).join(" ");
-      tags.push(`<link ${attrs}>`);
-    }
+  componentDidCatch(error) {
+    this.props.onError?.(error);
   }
-  if (head.scripts) {
-    for (const script of head.scripts) {
-      const entries = Object.entries(script).filter(([, v]) => v !== void 0);
-      const attrs = entries.map(([k, v]) => `${k}="${escapeAttr(v)}"`).join(" ");
-      tags.push(`<script ${attrs}></script>`);
+  render() {
+    if (this.state.hasError) {
+      if (this.props.fallback) return this.props.fallback;
+      return createElement(
+        "div",
+        { style: { padding: "2rem", textAlign: "center" } },
+        createElement("h1", null, "Something went wrong"),
+        createElement("p", null, this.state.error?.message ?? "Unknown error")
+      );
     }
+    return this.props.children;
   }
-  return tags.join("");
+};
+
+// src/react/hooks.ts
+import { useContext } from "react";
+function useServerData() {
+  return useContext(ServerDataContext);
 }
-function injectHeadIntoHtml(html, headTags) {
-  if (!headTags) return html;
-  let result = html;
-  if (headTags.includes("<title>")) {
-    const titleMatch = headTags.match(/<title>[^<]*<\/title>/);
-    if (titleMatch) {
-      result = result.replace(/<title>[^<]*<\/title>/, titleMatch[0]);
-      headTags = headTags.replace(titleMatch[0], "");
-    }
+
+// src/react/index.ts
+function HtmlShell({ children, importMap, stylesheets, data }) {
+  const headChildren = [
+    createElement2("meta", { charSet: "utf-8", key: "charset" }),
+    createElement2("meta", { name: "viewport", content: "width=device-width, initial-scale=1", key: "viewport" })
+  ];
+  if (stylesheets) {
+    for (const href of stylesheets) {
+      headChildren.push(
+        createElement2("link", { rel: "stylesheet", href, key: `css-${href}` })
+      );
+    }
+  }
+  if (importMap) {
+    headChildren.push(
+      createElement2("script", {
+        type: "importmap",
+        key: "importmap",
+        dangerouslySetInnerHTML: { __html: JSON.stringify(importMap) }
+      })
+    );
   }
-  if (headTags) {
-    result = result.replace("</head>", headTags + "</head>");
+  const bodyChildren = [
+    createElement2("div", { id: "root", key: "root" }, children)
+  ];
+  if (data && Object.keys(data).length > 0) {
+    bodyChildren.push(
+      createElement2("script", {
+        id: "__WEIFUWU_DATA__",
+        type: "application/json",
+        key: "weifuwu-data",
+        dangerouslySetInnerHTML: { __html: JSON.stringify(data).replace(/</g, "\\u003c") }
+      })
+    );
   }
-  return result;
+  return createElement2(
+    "html",
+    { lang: "en" },
+    createElement2("head", null, ...headChildren),
+    createElement2("body", null, ...bodyChildren)
+  );
 }
-function injectHeadIntoStream(sourceStream, headTags) {
-  if (!headTags) return sourceStream;
-  let titleTag = "";
-  let rest = headTags;
-  const titleMatch = headTags.match(/<title>[^<]*<\/title>/);
-  if (titleMatch) {
-    titleTag = titleMatch[0];
-    rest = headTags.replace(titleMatch[0], "");
-  }
-  let titleInjected = !titleTag;
-  let headInjected = !rest;
-  return new ReadableStream({
-    async start(controller) {
-      const reader = sourceStream.getReader();
-      let buffer = "";
-      try {
-        while (true) {
-          const { done, value } = await reader.read();
-          if (done) break;
-          buffer += decoder.decode(value, { stream: true });
-          if (!titleInjected) {
-            const idx = buffer.indexOf("<title>");
-            const endIdx = buffer.indexOf("</title>", idx);
-            if (idx !== -1 && endIdx !== -1) {
-              controller.enqueue(
-                encoder.encode(buffer.slice(0, idx) + titleTag + buffer.slice(endIdx + 8))
-              );
-              buffer = "";
-              titleInjected = true;
-              continue;
-            }
-          }
-          if (!headInjected) {
-            const idx = buffer.indexOf("</head>");
-            if (idx !== -1) {
-              controller.enqueue(
-                encoder.encode(buffer.slice(0, idx) + rest + buffer.slice(idx))
-              );
-              buffer = "";
-              headInjected = true;
-              continue;
-            }
-          }
-          if (titleInjected && headInjected && buffer) {
-            controller.enqueue(encoder.encode(buffer));
-            buffer = "";
-          }
-        }
-        if (buffer) controller.enqueue(encoder.encode(buffer));
-        controller.close();
-      } catch (err) {
-        controller.error(err);
-      }
-    }
+async function renderComponent(Component2, data, layout, renderOpts) {
+  let element = createElement2(Component2, renderOpts.props ?? {});
+  if (layout) {
+    element = createElement2(layout, { children: element });
+  }
+  element = createElement2(ServerDataContext.Provider, { value: data }, element);
+  const page = createElement2(HtmlShell, {
+    children: element,
+    importMap: renderOpts.importMap,
+    stylesheets: renderOpts.stylesheets,
+    data: Object.keys(data).length > 0 ? data : void 0
   });
-}
-function wrapElement(element, layouts, data) {
-  let wrapped = element;
-  for (let i = layouts.length - 1; i >= 0; i--) {
-    wrapped = createElement(layouts[i], null, wrapped);
-  }
-  const json = JSON.stringify(data).replace(/</g, "\\u003c");
-  const dataScript = createElement("script", {
-    id: "__WEIFUWU_DATA__",
-    type: "application/json",
-    dangerouslySetInnerHTML: { __html: json }
+  const rstream = await renderToReadableStream(page, {
+    bootstrapScripts: renderOpts.bootstrapScripts,
+    bootstrapModules: renderOpts.bootstrapModules
   });
-  return createElement(
-    ServerDataContext.Provider,
-    { value: data },
-    createElement(Fragment, null, wrapped, dataScript)
-  );
-}
-function render(element, layouts, options = {}) {
-  const data = options.data ?? {};
-  const wrapped = wrapElement(element, layouts, data);
-  let html = renderToString(wrapped);
-  const headTags = buildHeadTags(options.head);
-  html = injectHeadIntoHtml(html, headTags);
-  return new Response("<!DOCTYPE html>\n" + html, {
-    status: options.status ?? 200,
-    headers: {
-      "content-type": "text/html; charset=utf-8",
-      ...options.headers
-    }
+  if (renderOpts.stream === false) {
+    await rstream.allReady;
+  }
+  return new Response(rstream, {
+    status: renderOpts.status ?? 200,
+    headers: { "content-type": "text/html; charset=utf-8", ...renderOpts.headers }
   });
 }
-async function renderStream(element, layouts, options = {}) {
-  const data = options.data ?? {};
-  const wrapped = wrapElement(element, layouts, data);
-  const headTags = buildHeadTags(options.head);
-  let stream = await renderToReadableStream(wrapped);
-  stream = injectHeadIntoStream(stream, headTags);
-  const doctype = encoder.encode("<!DOCTYPE html>\n");
-  const combined = new ReadableStream({
-    async start(controller) {
-      controller.enqueue(doctype);
-      try {
-        const reader = stream.getReader();
-        while (true) {
-          const { done, value } = await reader.read();
-          if (done) {
-            controller.close();
-            break;
-          }
-          controller.enqueue(value);
-        }
-      } catch (err) {
-        controller.error(err);
-      }
+function react(opts) {
+  if (opts && "pages" in opts) {
+    return (app) => createFullReactApp(app, opts);
+  }
+  if (opts?.cacheDir) setReactCacheDir(opts.cacheDir);
+  let LayoutComponent = null;
+  let layoutLoaded = false;
+  let layoutLoadError = null;
+  async function getLayout() {
+    if (!opts?.layout) return null;
+    if (layoutLoaded) {
+      if (layoutLoadError) throw layoutLoadError;
+      return LayoutComponent;
     }
-  });
-  return new Response(combined, {
-    status: options.status ?? 200,
-    headers: {
-      "content-type": "text/html; charset=utf-8",
-      "transfer-encoding": "chunked",
-      ...options.headers
+    try {
+      LayoutComponent = await loadTsxComponent(opts.layout);
+      layoutLoaded = true;
+      return LayoutComponent;
+    } catch (err) {
+      layoutLoadError = err instanceof Error ? err : new Error(String(err));
+      layoutLoaded = true;
+      throw layoutLoadError;
     }
-  });
+  }
+  return async (_req, ctx, next) => {
+    ctx.render = async (path, renderOpts) => {
+      let data = renderOpts?.data ?? {};
+      if (renderOpts?.loader) {
+        const loaderData = await renderOpts.loader(ctx);
+        data = { ...data, ...loaderData };
+      }
+      const Component2 = await loadTsxComponent(path);
+      const layout = await getLayout();
+      return renderComponent(Component2, data, layout, renderOpts ?? {});
+    };
+    return next(_req, ctx);
+  };
 }
-
-// src/react/hooks.ts
-import { useContext } from "react";
-function useServerData() {
-  return useContext(ServerDataContext);
+async function resolveLoader(modulePath) {
+  const mod = await loadTsxModule(modulePath);
+  return typeof mod.loader === "function" ? mod.loader : null;
 }
-
-// src/react/navigation.ts
-import {
-  createElement as createElement2,
-  createContext as createContext2,
-  useContext as useContext2
-} from "react";
-
-// src/react/error-boundary.ts
-import { Component } from "react";
-var ErrorBoundary = class extends Component {
-  state = { error: null };
-  static getDerivedStateFromError(error) {
-    return { error };
+async function callLoader(loader, ctx, data, rethrow = true) {
+  if (!loader) return data;
+  try {
+    return { ...data, ...await loader(ctx) };
+  } catch (err) {
+    if (rethrow) throw err;
+    return data;
   }
-  componentDidCatch(error, info) {
-    this.props.onError?.(error, info);
+}
+function createFullReactApp(app, opts) {
+  const stylesheets = [...opts.stylesheets ?? []];
+  if (opts.tailwind) {
+    const twPath = opts.tailwind.path ?? "/assets/tailwind.css";
+    const twEntry = opts.tailwind.entry ?? "./styles/input.css";
+    app.use(tailwindDev({ entries: { [twPath]: { entry: twEntry } } }));
+    if (!stylesheets.includes(twPath)) stylesheets.push(twPath);
+  }
+  app.use(react({ layout: opts.layout, cacheDir: opts.cacheDir }));
+  const layoutLoaderP = resolveLoader(opts.layout);
+  const notFoundLoaderP = opts.notFound ? resolveLoader(opts.notFound) : Promise.resolve(null);
+  const clientCfg = typeof opts.client === "object" ? opts.client : {};
+  const clientPath = clientCfg.path ?? "/assets/client.js";
+  const bootstrapModules = [...opts.bootstrapModules ?? []];
+  if (opts.client !== false && !bootstrapModules.includes(clientPath)) {
+    bootstrapModules.push(clientPath);
+  }
+  const renderOpts = {
+    stylesheets: stylesheets.length > 0 ? stylesheets : void 0,
+    bootstrapModules: bootstrapModules.length > 0 ? bootstrapModules : void 0,
+    stream: opts.stream
+  };
+  for (const [path, component] of Object.entries(opts.pages)) {
+    app.get(path, async (_req, ctx) => {
+      let data = {};
+      data = await callLoader(await layoutLoaderP, ctx, data);
+      const pageLoader = opts.loaders?.[path] ?? await resolveLoader(component);
+      data = await callLoader(pageLoader, ctx, data);
+      return ctx.render(component, { ...renderOpts, data });
+    });
   }
-  render() {
-    if (this.state.error) {
-      return this.props.fallback;
-    }
-    return this.props.children;
+  if (opts.notFound) {
+    const notFoundPath = opts.notFound;
+    app.onError(async (err, _req, ctx) => {
+      const status = typeof err === "object" && err !== null && "status" in err ? err.status : 500;
+      if (ctx.render) {
+        let data = { error: String(err) };
+        data = await callLoader(await layoutLoaderP, ctx, data, false);
+        data = await callLoader(await notFoundLoaderP, ctx, data, false);
+        return ctx.render(notFoundPath, { ...renderOpts, status, data });
+      }
+      return new Response("Internal Server Error", { status });
+    });
+  }
+  if (opts.client !== false) {
+    app.use(esbuildDev({
+      entries: {
+        [clientPath]: {
+          clientRouter: {
+            pages: opts.pages,
+            layout: opts.layout,
+            fallback: opts.notFound
+          },
+          bundle: true,
+          splitting: clientCfg.splitting ?? true,
+          minify: clientCfg.minify ?? false
+        }
+      }
+    }));
   }
-};
-
-// src/react/navigation.ts
-var RouterContext = createContext2(null);
-RouterContext.displayName = "ClientRouter";
-function useParams() {
-  return useContext2(RouterContext)?.params ?? {};
 }
-function useNavigate() {
-  const ctx = useContext2(RouterContext);
-  if (!ctx) throw new Error("useNavigate() must be used within a client router");
-  return ctx.navigate;
+function extractImportPath(fn) {
+  const src = fn.toString();
+  const m = src.match(/import\s*\(\s*['"]([^'"]+)['"]\s*\)/);
+  if (!m) throw new Error(`Cannot extract import path from: ${src}`);
+  return m[1];
 }
-function useNavigation() {
-  const ctx = useContext2(RouterContext);
-  return { state: ctx?.state ?? "idle" };
+function reactRouter(app, routes, opts = {}) {
+  let LayoutComponent = null;
+  let layoutPromise = null;
+  async function getLayout() {
+    if (!opts.layout) return null;
+    if (LayoutComponent) return LayoutComponent;
+    if (!layoutPromise) {
+      layoutPromise = loadTsxComponent(opts.layout).then((c) => {
+        LayoutComponent = c;
+        return c;
+      });
+    }
+    return layoutPromise;
+  }
+  for (const [path, importer] of Object.entries(routes)) {
+    app.get(path, async (_req, ctx) => {
+      const cmpPath = extractImportPath(importer);
+      const Component2 = await loadTsxComponent(cmpPath);
+      const layout = await getLayout();
+      let data = {};
+      const loader = opts.loaders?.[path];
+      if (loader) {
+        data = await loader(ctx);
+      }
+      return renderComponent(Component2, data, layout, opts);
+    });
+  }
 }
 function Link({ href, children, ...props }) {
-  const router = useContext2(RouterContext);
-  const isExternal = href.startsWith("http://") || href.startsWith("https://") || href.startsWith("//") || href.startsWith("mailto:") || href.startsWith("tel:");
-  if (!router || isExternal || props.target !== void 0) {
-    return createElement2("a", { href, ...props }, children);
-  }
-  const handleClick = (e) => {
-    if (e.ctrlKey || e.metaKey || e.altKey || e.shiftKey) return;
-    if (e.button !== 0) return;
-    e.preventDefault();
-    router.navigate(href);
-  };
-  return createElement2("a", { href, onClick: handleClick, ...props }, children);
-}
-function useRevalidate() {
-  const ctx = useContext2(RouterContext);
-  if (!ctx) throw new Error("useRevalidate() must be used within a client router");
-  return ctx.revalidate;
-}
-function Form({ method = "post", action, children, ...props }) {
-  const router = useContext2(RouterContext);
-  if (!router) {
-    return createElement2("form", { method, action, ...props }, children);
-  }
-  const handleSubmit = async (e) => {
-    e.preventDefault();
-    const form = e.target;
-    const formData = new FormData(form);
-    const url = action || window.location.pathname;
-    const fetchMethod = method === "get" ? "GET" : method.toUpperCase();
-    try {
-      const res = await fetch(url, {
-        method: fetchMethod,
-        body: fetchMethod === "GET" ? void 0 : formData,
-        redirect: "manual"
-      });
-      if (res.status >= 300 && res.status < 400) {
-        const loc = res.headers.get("Location");
-        if (loc) {
-          router.navigate(loc);
-          return;
+  return createElement2("a", { href, ...props }, children);
+}
+
+// src/ai/index.ts
+function ai(opts) {
+  let aiModule = null;
+  const model = opts.model;
+  async function getAi() {
+    if (!aiModule) aiModule = await import("ai");
+    return aiModule;
+  }
+  return async (_req, ctx, next) => {
+    ctx.ai = {
+      model,
+      system: opts.system,
+      async generateText(params) {
+        const { generateText } = await getAi();
+        const messages = [...params.messages ?? []];
+        const system = params.system ?? opts.system;
+        if (system) {
+          const hasSystem = messages.some((m) => m.role === "system");
+          if (!hasSystem) {
+            messages.unshift({ role: "system", content: system });
+          }
+        }
+        const baseOpts = {
+          model,
+          tools: opts.tools,
+          maxSteps: params.maxSteps ?? opts.maxSteps ?? 1,
+          temperature: params.temperature ?? opts.temperature,
+          maxTokens: params.maxTokens ?? opts.maxTokens,
+          abortSignal: _req.signal
+        };
+        if (messages.length > 0) {
+          baseOpts.messages = messages;
+        } else {
+          baseOpts.prompt = params.prompt;
         }
+        return generateText(baseOpts);
       }
-      await router.revalidate();
-    } catch (err) {
-      console.error("[weifuwu/react] Form submit failed:", err);
-    }
+    };
+    return next(_req, ctx);
   };
-  return createElement2(
-    "form",
-    { method, action, ...props, onSubmit: handleSubmit },
-    children
-  );
 }
 
-// src/react/index.ts
-var LAYOUTS_KEY = /* @__PURE__ */ Symbol.for("weifuwu:react:layouts");
-var SETUP_KEY = /* @__PURE__ */ Symbol.for("weifuwu:react:setup");
-function bag(ctx) {
-  return ctx;
-}
-function isDataRequest(req) {
-  try {
-    return new URL(req.url).searchParams.has("_data");
-  } catch {
-    return false;
+// src/ai/agent.ts
+function agent(opts) {
+  let aiModule = null;
+  async function getAi() {
+    if (!aiModule) aiModule = await import("ai");
+    return aiModule;
   }
-}
-function react(opts = {}) {
-  const layout = opts.layout ?? Fragment2;
-  const mw = (req, ctx, next) => {
-    const b = bag(ctx);
-    const layouts = b[LAYOUTS_KEY] ?? [];
-    b[LAYOUTS_KEY] = layouts;
-    layouts.push(layout);
-    if (!b[SETUP_KEY]) {
-      b[SETUP_KEY] = true;
-      ctx.render = (element, renderOpts) => {
-        if (renderOpts?.data && isDataRequest(req)) {
-          return Promise.resolve(Response.json(renderOpts.data));
+  return async (req, ctx, next) => {
+    ctx.agent = {
+      model: opts.model,
+      system: opts.system,
+      async chat(prompt, chatOpts = {}) {
+        const { generateText } = await getAi();
+        let knowledgeContext = "";
+        if (opts.knowledge) {
+          try {
+            const results = await opts.knowledge.search(prompt, ctx);
+            const topK = opts.knowledge.topK ?? 3;
+            const minScore = opts.knowledge.minScore ?? 0;
+            const filtered = results.filter((r) => (r.score ?? 1) >= minScore).slice(0, topK);
+            if (filtered.length > 0) {
+              knowledgeContext = "\n\n\u53C2\u8003\u4EE5\u4E0B\u77E5\u8BC6\uFF1A\n" + filtered.map((r, i) => `[${i + 1}] ${r.content}`).join("\n");
+            }
+          } catch {
+          }
         }
-        return Promise.resolve(render(element, layouts, renderOpts));
-      };
-      ctx.renderStream = (element, renderOpts) => {
-        if (renderOpts?.data && isDataRequest(req)) {
-          return Promise.resolve(Response.json(renderOpts.data));
+        const system = chatOpts.system ?? opts.system ?? "";
+        const messages = [...chatOpts.messages ?? []];
+        if (system) {
+          const hasSystem = messages.some((m) => m.role === "system");
+          if (!hasSystem) {
+            messages.unshift({
+              role: "system",
+              content: knowledgeContext ? system + knowledgeContext : system
+            });
+          } else if (knowledgeContext) {
+            const sysMsg = messages.find((m) => m.role === "system");
+            if (sysMsg) sysMsg.content += knowledgeContext;
+          }
         }
-        return renderStream(element, layouts, renderOpts);
-      };
-    }
+        if (prompt && !messages.some((m) => m.role === "user")) {
+          messages.push({ role: "user", content: prompt });
+        }
+        const result = await generateText({
+          model: opts.model,
+          messages,
+          tools: opts.tools,
+          maxSteps: chatOpts.maxSteps ?? opts.maxSteps ?? 1,
+          temperature: chatOpts.temperature ?? opts.temperature,
+          maxTokens: chatOpts.maxTokens ?? opts.maxTokens,
+          abortSignal: req.signal
+        });
+        return {
+          text: result.text,
+          toolCalls: result.toolCalls,
+          toolResults: result.toolResults,
+          steps: result.steps,
+          finishReason: result.finishReason,
+          usage: result.usage
+        };
+      },
+      chatStreamResponse(streamOpts) {
+        const encoder = new TextEncoder();
+        const stream = new ReadableStream({
+          async start(controller) {
+            try {
+              const result = await ctx.agent.chat(
+                streamOpts.messages.filter((m) => m.role === "user").pop()?.content ?? "",
+                {
+                  messages: streamOpts.messages,
+                  system: streamOpts.system
+                }
+              );
+              controller.enqueue(encoder.encode(`data: ${JSON.stringify({ type: "text", content: result.text })}
+
+`));
+              controller.enqueue(encoder.encode("data: [DONE]\n\n"));
+              controller.close();
+            } catch (err) {
+              controller.enqueue(encoder.encode(
+                `data: ${JSON.stringify({ type: "error", error: String(err) })}
+
+`
+              ));
+              controller.close();
+            }
+          }
+        });
+        return new Response(stream, {
+          headers: {
+            "Content-Type": "text/event-stream",
+            "Cache-Control": "no-cache",
+            Connection: "keep-alive"
+          }
+        });
+      }
+    };
     return next(req, ctx);
   };
-  return mw;
 }
 export {
   DEFAULT_MAX_BODY,
   ErrorBoundary,
-  Form,
   HttpError,
   Link,
   MIGRATIONS_TABLE,
   Router,
   ServerDataContext,
+  agent,
+  ai,
+  auth,
   compress,
   cors,
   createHub,
   currentTrace,
   currentTraceId,
+  esbuildDev,
   graphql,
   helmet,
   logger,
@@ -2229,16 +3101,15 @@ export {
   queue,
   rateLimit,
   react,
+  reactRouter,
   redis,
   runWithTrace,
+  sandbox,
   serve,
   serveStatic,
+  tailwindDev,
   trace,
   traceElapsed,
   upload,
-  useNavigate,
-  useNavigation,
-  useParams,
-  useRevalidate,
   useServerData
 };