weifuwu 0.18.0 → 0.18.2

package/dist/ssr/index.js

@@ -0,0 +1,936 @@
+// ssr/ssr.ts
+import { createElement } from "react";
+import { createHash as createHash2 } from "node:crypto";
+import { dirname as dirname2, resolve as resolve2 } from "node:path";
+import { AsyncLocalStorage } from "node:async_hooks";
+
+// ssr/compile.ts
+import * as esbuild from "esbuild";
+import { existsSync, mkdirSync, readFileSync } from "node:fs";
+import { join, resolve, dirname } from "node:path";
+import { pathToFileURL } from "node:url";
+import { createHash } from "node:crypto";
+var OUT_DIR = ".weifuwu/ssr";
+var cache = /* @__PURE__ */ new Map();
+var externals = [
+  "react",
+  "react-dom",
+  "esbuild",
+  "graphql",
+  "ws",
+  "zod",
+  "@graphql-tools/schema",
+  "ai"
+];
+var _alias = null;
+function resolveAliases() {
+  if (_alias) return _alias;
+  const configFiles = ["tsconfig.json", "jsconfig.json"];
+  for (const file of configFiles) {
+    const p = resolve(file);
+    if (existsSync(p)) {
+      try {
+        const config = JSON.parse(readFileSync(p, "utf-8"));
+        const paths = config.compilerOptions?.paths;
+        if (paths) {
+          const alias = {};
+          for (const [key, values] of Object.entries(paths)) {
+            const cleanKey = key.replace("/*", "");
+            const val = values[0]?.replace("/*", "");
+            if (val) alias[cleanKey] = resolve(dirname(p), val);
+          }
+          _alias = alias;
+          return alias;
+        }
+      } catch {
+      }
+    }
+  }
+  _alias = {};
+  return {};
+}
+function id(s) {
+  return createHash("md5").update(s).digest("hex").slice(0, 8);
+}
+function clearCompileCache() {
+  cache.clear();
+  _alias = null;
+}
+async function compileTsx(path) {
+  if (cache.has(path)) return cache.get(path);
+  const absPath = resolve(path);
+  mkdirSync(OUT_DIR, { recursive: true });
+  const hash = id(absPath);
+  const outPath = join(OUT_DIR, hash + ".js");
+  await esbuild.build({
+    entryPoints: { [hash]: absPath },
+    outdir: OUT_DIR,
+    format: "esm",
+    platform: "node",
+    jsx: "automatic",
+    jsxImportSource: "react",
+    bundle: true,
+    external: externals,
+    alias: resolveAliases(),
+    write: true,
+    allowOverwrite: true
+  });
+  const mod = await import(pathToFileURL(outPath).href);
+  cache.set(path, mod);
+  return mod;
+}
+
+// ssr/stream.ts
+import { TextDecoder, TextEncoder } from "node:util";
+var _publicEnv = null;
+function getPublicEnv() {
+  if (_publicEnv) return _publicEnv;
+  _publicEnv = {};
+  for (const key of Object.keys(process.env)) {
+    if (key.startsWith("WEIFUWU_PUBLIC_")) {
+      _publicEnv[key] = process.env[key];
+    }
+  }
+  return _publicEnv;
+}
+function buildHeadPayload(opts) {
+  const { ctx, base, compiledTailwindCss } = opts;
+  let result = "";
+  if (ctx.prefs?.theme) {
+    result += `<script>!function(){var t=(document.cookie.match(/(?:^|;\\s*)theme=([^;]+)/)||[])[1]||'system';if(t==='system'){t=window.matchMedia('(prefers-color-scheme:dark)').matches?'dark':'light'}document.documentElement.setAttribute('data-theme',t)}()</script>
+`;
+  }
+  if (compiledTailwindCss) {
+    result += `<link rel="stylesheet" href="${base}/__wfw/style.css" />
+`;
+  }
+  const localeData = ctx.parsed?.__localeData ?? globalThis.__LOCALE_DATA__;
+  if (localeData && Object.keys(localeData).length > 0) {
+    result += `<script>window.__LOCALE_DATA__=${JSON.stringify(localeData)}</script>
+`;
+  }
+  const loaderData = opts.loaderData || {};
+  const ctxData = {
+    params: ctx.params,
+    query: ctx.query,
+    user: ctx.user,
+    parsed: ctx.parsed,
+    prefs: ctx.prefs,
+    loaderData
+  };
+  const publicEnv = getPublicEnv();
+  if (Object.keys(publicEnv).length > 0) {
+    ctxData.env = publicEnv;
+  }
+  result += `<script>window.__WEIFUWU_CTX=${JSON.stringify(ctxData)}</script>
+`;
+  return result;
+}
+function buildBodyScripts(opts) {
+  const parts = [];
+  if (opts.loaderData && Object.keys(opts.loaderData).length > 0) {
+    parts.push(`<script>window.__WEIFUWU_PROPS=${JSON.stringify(opts.loaderData)}</script>`);
+  }
+  if (opts.bundle) {
+    parts.push(`<script type="module" src="${opts.base}${opts.bundle.url}"></script>`);
+  }
+  return parts.join("\n");
+}
+function streamResponse(reactStream, opts) {
+  const decoder = new TextDecoder();
+  const encoder = new TextEncoder();
+  const headPayload = buildHeadPayload(opts);
+  let buffer = "";
+  let headFlushed = false;
+  let extractedHead = "";
+  const output = new ReadableStream({
+    async start(controller) {
+      try {
+        const reader = reactStream.getReader();
+        async function push(chunk) {
+          buffer += decoder.decode(chunk, { stream: true });
+          if (!extractedHead) {
+            const m = buffer.match(/<template id="__wfw_head">([\s\S]*?)<\/template>/);
+            if (m) {
+              extractedHead = m[1];
+              buffer = buffer.replace(m[0], "");
+            }
+          }
+          if (!headFlushed) {
+            const idx = buffer.indexOf("</head>");
+            if (idx !== -1) {
+              const before = buffer.slice(0, idx);
+              let injection = "";
+              if (extractedHead) injection += "\n" + extractedHead;
+              injection += headPayload;
+              controller.enqueue(encoder.encode(before + injection));
+              buffer = buffer.slice(idx);
+              headFlushed = true;
+            }
+            return;
+          }
+          controller.enqueue(encoder.encode(buffer));
+          buffer = "";
+        }
+        while (true) {
+          const { done, value } = await reader.read();
+          if (done) break;
+          await push(value);
+        }
+        buffer = buffer.replace(/<template id="__wfw_head">[\s\S]*?<\/template>/g, "");
+        if (buffer) controller.enqueue(encoder.encode(buffer));
+        const body = buildBodyScripts(opts);
+        if (body) controller.enqueue(encoder.encode("\n" + body));
+        if (opts.isDev) {
+          controller.enqueue(encoder.encode(
+            `
+<script>(function(){var ws=new WebSocket((location.protocol==='https:'?'wss:':'ws:')+'//'+location.host+'${opts.base}/__weifuwu/livereload');ws.onmessage=function(e){if(e.data==='reload')location.reload()};ws.onclose=function(){setTimeout(function(){location.reload()},500)}})()</script>`
+          ));
+        }
+      } catch {
+        const fallback = `<!DOCTYPE html><html lang="en"><head><meta charset="utf-8"><title>500</title></head><body><h1>500 - Internal Server Error</h1></body></html>`;
+        controller.enqueue(encoder.encode(fallback));
+      } finally {
+        controller.close();
+      }
+    }
+  });
+  return new Response(output, {
+    status: opts.status ?? 200,
+    headers: { "content-type": "text/html; charset=utf-8" }
+  });
+}
+
+// tsx-context.ts
+import { createContext } from "react";
+var DEFAULT_CTX = { params: {}, query: {}, parsed: {}, prefs: {}, loaderData: {}, env: {}, user: {} };
+var KEY = "__WEIFUWU_CTX_STORE";
+function getStore() {
+  if (typeof globalThis !== "undefined" && globalThis[KEY]) {
+    return globalThis[KEY];
+  }
+  const s = {
+    _ctx: DEFAULT_CTX,
+    _snapshot: { params: DEFAULT_CTX.params, query: DEFAULT_CTX.query, user: DEFAULT_CTX.user, parsed: DEFAULT_CTX.parsed, prefs: DEFAULT_CTX.prefs, env: DEFAULT_CTX.env },
+    _listeners: /* @__PURE__ */ new Set(),
+    _alsGetStore: null
+  };
+  if (typeof globalThis !== "undefined") {
+    globalThis[KEY] = s;
+  }
+  return s;
+}
+var store = getStore();
+function __registerAls(getStore2) {
+  store._alsGetStore = getStore2;
+}
+function setCtx(value) {
+  store._ctx = { ...store._ctx, ...value };
+  store._snapshot = { params: store._ctx.params, query: store._ctx.query, user: store._ctx.user, parsed: store._ctx.parsed, prefs: store._ctx.prefs, env: store._ctx.env };
+  store._listeners.forEach((fn) => fn());
+}
+var TsxContext = createContext(DEFAULT_CTX);
+
+// ssr/ssr.ts
+var als = new AsyncLocalStorage();
+__registerAls(() => als.getStore());
+var isDev = process.env.NODE_ENV !== "production";
+function id2(s) {
+  return createHash2("md5").update(s).digest("hex").slice(0, 8);
+}
+async function buildClientBundle(entryPath, layoutPaths) {
+  try {
+    const absEntry = resolve2(entryPath);
+    const absLayouts = layoutPaths.map((p) => resolve2(p));
+    const layoutImports = absLayouts.map((p) => `import${JSON.stringify(p)};`).join("");
+    const _sc = `(function(){var k='__WEIFUWU_CTX_STORE';var s=typeof globalThis!='undefined'&&globalThis[k];if(!s)return function(){};return function(v){s._ctx={...s._ctx,...v};s._snapshot={params:s._ctx.params,query:s._ctx.query,user:s._ctx.user,parsed:s._ctx.parsed,prefs:s._ctx.prefs,env:s._ctx.env};s._listeners.forEach(function(fn){fn()})}})()`;
+    const code = [
+      layoutImports,
+      `import{hydrateRoot}from'react-dom/client';`,
+      `import{createElement,useState,useEffect}from'react';`,
+      `import{TsxContext}from'weifuwu/react';`,
+      `import P from${JSON.stringify(absEntry)};`,
+      `var setCtx=${_sc};`,
+      `const c=document.getElementById('__weifuwu_root');`,
+      `if(window.__WEIFUWU_PROPS)setCtx({loaderData:window.__WEIFUWU_PROPS});`,
+      `if(!window.__WFW_ROOT){`,
+      `function App(){`,
+      `const[p,setP]=useState({C:P});`,
+      `useEffect(()=>{window.__WFW_SET_PAGE=(C)=>{setCtx({loaderData:window.__WEIFUWU_PROPS});setP({C})}},[]);`,
+      `const ctx=window.__WEIFUWU_CTX||{};`,
+      `return createElement(TsxContext.Provider,{value:ctx},`,
+      `createElement(p.C,null))`,
+      `}`,
+      `window.__WFW_ROOT=hydrateRoot(c,createElement(App));`,
+      `}else{`,
+      `window.__WFW_SET_PAGE?.(P);`,
+      `}`
+    ].join("");
+    const { default: esbuild2 } = await import("esbuild");
+    const result = await esbuild2.build({
+      stdin: { contents: code, loader: "tsx", resolveDir: dirname2(absEntry) },
+      bundle: true,
+      format: "esm",
+      jsx: "automatic",
+      jsxImportSource: "react",
+      banner: { js: "self.process={env:{}};" },
+      loader: { ".node": "empty" },
+      write: false,
+      minify: true
+    });
+    return result.outputFiles[0].contents;
+  } catch (err) {
+    console.error("hydration bundle failed:", err);
+    return null;
+  }
+}
+var bundleRegistry = /* @__PURE__ */ new Map();
+function serializeLoaderData(ctx) {
+  const data = {};
+  for (const key of Object.keys(ctx)) {
+    if (!["params", "query", "mountPath", "layoutStack"].includes(key)) {
+      data[key] = ctx[key];
+    }
+  }
+  return data;
+}
+function ssr(path) {
+  const entryId = id2(resolve2(path));
+  const bundleKey = `/__ssr/${entryId}.js`;
+  let bundleBuilt = false;
+  return async (req, ctx) => {
+    const pageMod = await compileTsx(path);
+    const Component = pageMod.default;
+    if (!Component) return new Response("", { status: 500 });
+    const layouts = ctx.layoutStack || [];
+    const layoutComponents = layouts.map((l) => l.component);
+    const layoutPaths = layouts.map((l) => l.path);
+    const base = (ctx.mountPath || "").replace(/\/$/, "");
+    const loaderData = serializeLoaderData(ctx);
+    const ctxValue = {
+      params: ctx.params,
+      query: ctx.query,
+      user: ctx.user ?? {},
+      parsed: ctx.parsed ?? {},
+      prefs: ctx.prefs ?? {},
+      loaderData,
+      env: ctx.env ?? {}
+    };
+    return als.run(ctxValue, async () => {
+      setCtx(ctxValue);
+      let element = createElement(
+        TsxContext.Provider,
+        { value: ctxValue },
+        createElement(
+          "div",
+          { id: "__weifuwu_root" },
+          createElement(Component, null)
+        )
+      );
+      if (layoutComponents.length === 0) {
+        element = createElement(
+          "html",
+          { lang: "en" },
+          createElement(
+            "head",
+            null,
+            createElement("meta", { charSet: "utf-8" }),
+            createElement("meta", { name: "viewport", content: "width=device-width, initial-scale=1" }),
+            createElement("title", null, "weifuwu")
+          ),
+          createElement("body", null, element)
+        );
+      } else {
+        for (const L of layoutComponents.toReversed()) {
+          element = createElement(L, { children: element });
+        }
+      }
+      let bundle = null;
+      if (!bundleBuilt) {
+        const buf = await buildClientBundle(path, layoutPaths);
+        if (buf) {
+          bundleRegistry.set(bundleKey, buf);
+          bundleBuilt = true;
+        }
+      }
+      if (bundleRegistry.has(bundleKey)) {
+        bundle = { url: bundleKey };
+      }
+      const { renderToReadableStream } = await import("react-dom/server");
+      const stream = await renderToReadableStream(element);
+      return streamResponse(stream, {
+        ctx,
+        base,
+        isDev,
+        bundle,
+        loaderData
+      });
+    });
+  };
+}
+function ssrBundleHandler() {
+  return (req, ctx) => {
+    const url = new URL(req.url);
+    const buf = bundleRegistry.get(url.pathname);
+    return buf ? new Response(buf, {
+      headers: { "content-type": "application/javascript; charset=utf-8" }
+    }) : new Response("", { status: 404 });
+  };
+}
+
+// ssr/layout.ts
+function layout(path) {
+  return async (req, ctx, next) => {
+    const mod = await compileTsx(path);
+    const Component = mod.default;
+    if (!Component) throw new Error(`Layout ${path} has no default export`);
+    ctx.layoutStack = [...ctx.layoutStack || [], { path, component: Component }];
+    return next(req, ctx);
+  };
+}
+
+// ssr/tailwind.ts
+import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync } from "node:fs";
+import { relative, resolve as resolve3 } from "node:path";
+var isDev2 = process.env.NODE_ENV !== "production";
+function tailwind(cssPath, scanDir) {
+  let compiledCss = "";
+  let twWatcher = null;
+  return async (req, ctx, next) => {
+    const url = new URL(req.url);
+    if (url.pathname === "/__wfw/style.css") {
+      if (!compiledCss) compiledCss = await compile(cssPath, scanDir);
+      return new Response(compiledCss || "", {
+        headers: { "content-type": "text/css; charset=utf-8" }
+      });
+    }
+    ctx.compiledTailwindCss = compiledCss;
+    if (isDev2 && !twWatcher) {
+      twWatcher = watchFile(cssPath, () => {
+        compiledCss = "";
+      });
+    }
+    return next(req, ctx);
+  };
+}
+async function compile(cssPath, scanDir) {
+  try {
+    const inputFile = resolve3(cssPath);
+    if (!existsSync2(inputFile)) {
+      mkdirSync2(dirname3(inputFile), { recursive: true });
+      writeFileSync(inputFile, '@import "tailwindcss"\n', "utf-8");
+    }
+    const { default: tailwindPlugin } = await import("@tailwindcss/postcss");
+    const { default: postcss } = await import("postcss");
+    let src = readFileSync2(inputFile, "utf-8");
+    const scanSource = scanDir ? relative(dirname3(inputFile), scanDir) || "." : ".";
+    const sourcePath = scanSource === "." ? "./" : `./${scanSource}/`;
+    src = `@source "${sourcePath}";
+${src}`;
+    const result = await postcss([tailwindPlugin()]).process(src, { from: inputFile });
+    return result.css;
+  } catch (err) {
+    console.warn("Tailwind CSS processing failed:", err.message);
+    return "";
+  }
+}
+function dirname3(p) {
+  return p.substring(0, p.lastIndexOf("/")) || "/";
+}
+function watchFile(path, onChange) {
+  let watcher = null;
+  import("chokidar").then((chokidar2) => {
+    watcher = chokidar2.default.watch(resolve3(path), { persistent: false });
+    watcher.on("change", onChange);
+  });
+  return watcher;
+}
+
+// ssr/not-found.ts
+function notFound(path) {
+  return async (req, ctx) => {
+    if (!path) return new Response("Not Found", { status: 404 });
+    const mod = await compileTsx(path);
+    const Component = mod?.default;
+    const body = Component ? "404 - Not Found" : "404 - Not Found";
+    return new Response(body, {
+      status: 404,
+      headers: { "content-type": "text/html; charset=utf-8" }
+    });
+  };
+}
+
+// ssr/error-boundary.ts
+import { createElement as createElement2 } from "react";
+import { TextEncoder as TextEncoder2 } from "node:util";
+function errorBoundary(errorPath) {
+  return async (req, ctx, next) => {
+    try {
+      return await next(req, ctx);
+    } catch (err) {
+      const mod = await compileTsx(errorPath);
+      const ErrorComponent = mod.default;
+      if (!ErrorComponent) throw err;
+      const layouts = (ctx.layoutStack || []).map((l) => l.component);
+      const stream = await import("react-dom/server").then((m) => m.renderToReadableStream(
+        createElement2(ErrorComponent, {
+          error: err instanceof Error ? err : new Error(String(err)),
+          reset: () => {
+          }
+        })
+      ));
+      const reader = stream.getReader();
+      const chunks = [];
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        chunks.push(value);
+      }
+      const encoder = new TextEncoder2();
+      const body = chunks.reduce((acc, c) => {
+        const merged = new Uint8Array(acc.length + c.length);
+        merged.set(acc);
+        merged.set(c, acc.length);
+        return merged;
+      }, new Uint8Array(0));
+      return new Response(body, {
+        status: 500,
+        headers: { "content-type": "text/html; charset=utf-8" }
+      });
+    }
+  };
+}
+
+// ssr/live.ts
+import chokidar from "chokidar";
+
+// router.ts
+import { WebSocketServer } from "ws";
+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 === "*") {
+    node.wildcard = true;
+    return node;
+  }
+  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;
+  }
+  if (node.wildcard) return node;
+  return null;
+};
+var Router = class _Router {
+  root = createTrieNode();
+  wsRoot = createWsNode();
+  globalMws = [];
+  errorHandler;
+  wss = new WebSocketServer({ noServer: true });
+  use(arg1, arg2) {
+    if (typeof arg1 === "string") {
+      if (arg2 instanceof _Router) {
+        this._mountRouter(arg1, 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 (arg1 instanceof _Router) {
+      this._mountRouter("/", arg1);
+    } 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 === "*") {
+        const remaining = segments.indexOf("*") < segments.length - 1;
+        if (remaining) {
+          console.warn(`Route "${path}": segments after "*" are ignored`);
+        }
+        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;
+  }
+  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 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 match = router.matchWsTrie(wsRoot, segments);
+      if (match) {
+        const query = Object.fromEntries(url.searchParams);
+        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(router.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((resolve4) => {
+            try {
+              upgradeSocket(router.wss, req, socket, head, match.handler, ctx2);
+              resolve4(new Response(null, { status: 101 }));
+            } catch {
+              socket.destroy();
+              resolve4(new Response("WebSocket upgrade failed", { status: 500 }));
+            }
+          });
+        };
+        Promise.resolve(dispatch(webReq, ctx)).then((result) => {
+          if (result.status !== 101) {
+            sendHttpResponseOnSocket(socket, result);
+          }
+        }).catch(() => {
+          socket.destroy();
+        });
+        return;
+      }
+      socket.destroy();
+    };
+  }
+  _mountRouter(prefix, sub) {
+    const base = prefix === "/" ? "" : prefix.replace(/\/$/, "");
+    const mountMw = (req, ctx, next) => {
+      ctx.mountPath = (ctx.mountPath || "") + base;
+      return next(req, ctx);
+    };
+    const routes = [];
+    this._collect(sub.root, "", routes, []);
+    for (const { method, path, handler, middlewares } of routes) {
+      this.route(method, base + path, mountMw, ...sub.globalMws, ...middlewares, handler);
+    }
+    const wsRoutes = [];
+    this._collectWs(sub.wsRoot, "", wsRoutes);
+    for (const { path, handler } of wsRoutes) {
+      this.ws(base + path, handler);
+    }
+  }
+  _collect(node, prefix, result, pathMwsAcc) {
+    const mws = [...pathMwsAcc, ...node.pathMws];
+    if (node.wildcard) {
+      for (const [method, handler] of node.handlers) {
+        result.push({ method, path: prefix + "/*", handler, middlewares: [...mws, ...node.middlewares.get(method) || []] });
+      }
+    } else {
+      for (const [method, handler] of node.handlers) {
+        result.push({ method, path: prefix || "/", handler, middlewares: [...mws, ...node.middlewares.get(method) || []] });
+      }
+    }
+    for (const [seg, child] of node.children) {
+      if (seg === ":") this._collect(child, prefix + "/:" + child.param, result, mws);
+      else this._collect(child, prefix + "/" + seg, result, mws);
+    }
+  }
+  _collectWs(node, prefix, result) {
+    if (node.handler) result.push({ path: prefix || "/", handler: node.handler });
+    for (const [seg, child] of node.children) {
+      if (seg === ":") this._collectWs(child, prefix + "/:" + child.param, result);
+      else this._collectWs(child, prefix + "/" + seg, result);
+    }
+  }
+  splitPath(path) {
+    return path.split("/").filter(Boolean);
+  }
+  matchTrie(method, segments) {
+    let node = this.root;
+    const params = {};
+    const 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("*") || node.handlers.get(method);
+        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 (wildcardHandler) {
+          params["*"] = segments.slice(wildcardIdx).join("/");
+          return { handler: wildcardHandler, middlewares: wildcardMws, pathMws, params };
+        }
+        return null;
+      }
+      node = next;
+    }
+    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?.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) {
+        const err = e instanceof Error ? e : new Error(String(e));
+        return this.errorHandler ? this.errorHandler(err, 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) {
+        const err = e instanceof Error ? e : new Error(String(e));
+        return this.errorHandler ? this.errorHandler(err, 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();
+  });
+}
+
+// ssr/live.ts
+var clients = /* @__PURE__ */ new Set();
+function broadcastReload() {
+  for (const ws of clients) {
+    try {
+      ws.send("reload");
+    } catch {
+      clients.delete(ws);
+    }
+  }
+}
+function liveReload(opts) {
+  const r = new Router();
+  r.ws("/__weifuwu/livereload", {
+    open(ws) {
+      clients.add(ws);
+      ws.on("close", () => clients.delete(ws));
+      ws.on("error", () => clients.delete(ws));
+    }
+  });
+  const watcher = chokidar.watch(opts.dirs, {
+    ignored: /(^|[/\\])\.|node_modules|[/\\]\.weifuwu[/\\]/,
+    ignoreInitial: true
+  });
+  watcher.on("change", (path) => {
+    if (!/\.tsx?$/.test(path)) return;
+    clearCompileCache();
+    setTimeout(broadcastReload, 50);
+  });
+  r.close = () => {
+    watcher.close();
+    clients.clear();
+  };
+  return r;
+}
+export {
+  clearCompileCache,
+  errorBoundary,
+  layout,
+  liveReload,
+  notFound,
+  ssr,
+  ssrBundleHandler,
+  tailwind
+};