weifuwu 0.30.0 → 0.30.2

package/dist/index.js

@@ -9,7 +9,7 @@ var HttpError = class extends Error {
 };
 
 // src/core/trace.ts
-import crypto2 from "node:crypto";
+import crypto 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 || crypto2.randomUUID();
+  const traceId = incomingTraceId || crypto.randomUUID();
   const startTime = Date.now();
   return als.run({ traceId, startTime }, fn);
 }
@@ -30,14 +30,14 @@ function traceElapsed() {
 }
 function trace(options) {
   const header = options?.header ?? "X-Request-ID";
-  const gen = options?.generator ?? (() => crypto2.randomUUID());
+  const gen = options?.generator ?? (() => crypto.randomUUID());
   return async (req, ctx, next) => {
     const existing = req.headers.get(header);
-    const requestId2 = existing ?? gen();
+    const requestId = existing ?? gen();
     const tc = als.getStore();
     ctx.trace = {
-      requestId: requestId2,
-      traceId: tc?.traceId ?? requestId2,
+      requestId,
+      traceId: tc?.traceId ?? requestId,
       startTime: tc?.startTime ?? Date.now(),
       elapsed: () => {
         const t = als.getStore();
@@ -47,71 +47,11 @@ function trace(options) {
     const res = await next(req, ctx);
     if (res.headers.has(header)) return res;
     const h = new Headers(res.headers);
-    h.set(header, requestId2);
+    h.set(header, requestId);
     return new Response(res.body, { status: res.status, statusText: res.statusText, headers: h });
   };
 }
 
-// src/core/env.ts
-import { readFileSync } from "node:fs";
-import { resolve } from "node:path";
-var PUBLIC_PREFIX = "WEIFUWU_PUBLIC_";
-function getPublicEnv() {
-  const result = {};
-  for (const [key, value] of Object.entries(process.env)) {
-    if (key.startsWith(PUBLIC_PREFIX) && value !== void 0) {
-      result[key.slice(PUBLIC_PREFIX.length)] = value;
-    }
-  }
-  return result;
-}
-function isBundled() {
-  return typeof __WFW_BUNDLED__ !== "undefined" ? __WFW_BUNDLED__ : false;
-}
-function isDev() {
-  const env2 = process.env.NODE_ENV;
-  return env2 !== "production" && env2 !== "test";
-}
-function isProd() {
-  return process.env.NODE_ENV === "production";
-}
-function loadEnv(path) {
-  const filePath = resolve(process.cwd(), path ?? ".env");
-  let content;
-  try {
-    content = readFileSync(filePath, "utf-8");
-  } catch {
-    return;
-  }
-  for (const line of content.split("\n")) {
-    const trimmed = line.trim();
-    if (!trimmed || trimmed.startsWith("#")) continue;
-    const eqIdx = trimmed.indexOf("=");
-    if (eqIdx === -1) continue;
-    const key = trimmed.slice(0, eqIdx).trim();
-    if (!key) continue;
-    if (process.env[key] !== void 0) continue;
-    let value = trimmed.slice(eqIdx + 1).trim();
-    if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
-      value = value.slice(1, -1);
-    } else {
-      const commentIdx = value.search(/\s#/);
-      if (commentIdx !== -1) {
-        value = value.slice(0, commentIdx).trimEnd();
-      }
-    }
-    process.env[key] = value;
-  }
-}
-function env() {
-  const entries = getPublicEnv();
-  return async (req, ctx, next) => {
-    ;
-    ctx.env = entries;
-    return next(req, ctx);
-  };
-}
-
 // src/core/serve.ts
 import http from "node:http";
 var DEFAULT_MAX_BODY = 10 * 1024 * 1024;
@@ -180,11 +120,6 @@ async function sendResponse(res, response, opts) {
   }
   res.end();
 }
-async function createTestServer(router, options) {
-  const server = serve(router, { ...options, port: options?.port ?? 0, shutdown: false });
-  await server.ready;
-  return { server, url: `http://localhost:${server.port}` };
-}
 function serve(router, options) {
   const ws = router.websocketHandler();
   const handler = router.handler();
@@ -204,9 +139,6 @@ function serve(router, options) {
           res.end("Request Body Too Large");
           return;
         }
-        const msg = err instanceof Error ? err.message : String(err);
-        console.error(`[${currentTraceId()}] unhandled error: ${msg}`);
-        if (err instanceof Error && err.stack) console.error(err.stack);
         res.writeHead(500, { "Content-Type": "text/plain" });
         res.end("Internal Server Error");
       }
@@ -269,7 +201,7 @@ function serve(router, options) {
     );
   }
   server.on("error", (err) => {
-    console.error("Failed to start server:", err.message);
+    throw err;
     server.close();
     _cachedPort = 0;
     resolveReady();
@@ -293,14 +225,14 @@ function serve(router, options) {
     if (!server.listening) return;
     server.close();
     server.closeIdleConnections();
-    return new Promise((resolve4) => {
+    return new Promise((resolve2) => {
       const timer = setTimeout(() => {
         server.closeAllConnections();
-        resolve4();
+        resolve2();
       }, timeoutMs);
       server.on("close", () => {
         clearTimeout(timer);
-        resolve4();
+        resolve2();
       });
     });
   }
@@ -345,7 +277,7 @@ function createHub(opts) {
       }
     });
   }
-  function join3(key, ws) {
+  function join2(key, ws) {
     if (!channels.has(key)) {
       channels.set(key, /* @__PURE__ */ new Set());
       redisSub?.subscribe(`${prefix}${key}`);
@@ -407,7 +339,97 @@ function createHub(opts) {
     redisPub = void 0;
     redisSub = null;
   }
-  return { join: join3, leave, broadcast, close };
+  return { join: join2, leave, broadcast, close };
+}
+
+// src/core/ws.ts
+function nodeReqHeadersToRecord(headers) {
+  const result = {};
+  for (const [k, v] of Object.entries(headers)) {
+    if (v !== void 0) result[k] = Array.isArray(v) ? v.join(", ") : v;
+  }
+  return result;
+}
+function sendHttpResponseOnSocket(socket, response) {
+  const statusLine = `HTTP/1.1 ${response.status} ${response.statusText}`;
+  const lines = [statusLine];
+  response.headers.forEach((v, k) => lines.push(`${k}: ${v}`));
+  lines.push("Connection: close", "");
+  const headerStr = lines.join("\r\n");
+  response.arrayBuffer().then((buf) => {
+    socket.write(headerStr + "\r\n");
+    if (buf.byteLength > 0) socket.write(Buffer.from(buf));
+    socket.end();
+  }).catch(() => {
+    socket.write(headerStr + "\r\n");
+    socket.end();
+  });
+}
+function upgradeSocket(wss, req, socket, head, handler, ctx, hub) {
+  wss.handleUpgrade(req, socket, head, (ws) => {
+    const connCtx = { ...ctx, params: { ...ctx.params }, query: { ...ctx.query } };
+    const wsState = {};
+    connCtx.ws = {
+      get state() {
+        return wsState;
+      },
+      json(data) {
+        ws.send(JSON.stringify(data));
+      },
+      join(room) {
+        hub.join(room, ws);
+      },
+      leave() {
+        hub.leave(ws);
+      },
+      sendRoom(room, data) {
+        hub.broadcast(room, data);
+      }
+    };
+    handler.open?.(ws, connCtx);
+    ws.on("message", (data) => handler.message?.(ws, connCtx, data));
+    ws.on("close", () => {
+      hub.leave(ws);
+      handler.close?.(ws, connCtx);
+    });
+    ws.on("error", (err) => handler.error?.(ws, connCtx, err));
+  });
+}
+function createWsUpgradeHandler(wss, hub, matchWsFn, globalMws, runChainFn) {
+  return (req, socket, head) => {
+    const url = new URL(req.url ?? "/", "http://localhost");
+    const segments = url.pathname.split("/").filter(Boolean);
+    const match = matchWsFn(segments);
+    if (!match) {
+      socket.destroy();
+      return;
+    }
+    const query = Object.fromEntries(url.searchParams);
+    const ctx = { params: match.params, query };
+    const mws = globalMws.length === 0 && match.middlewares.length === 0 ? [] : [...globalMws, ...match.middlewares];
+    if (mws.length === 0) {
+      upgradeSocket(wss, req, socket, head, match.handler, ctx, hub);
+      return;
+    }
+    const finalHandler = () => {
+      try {
+        upgradeSocket(wss, req, socket, head, match.handler, ctx, hub);
+      } catch {
+        socket.destroy();
+        return new Response("WebSocket upgrade failed", { status: 500 });
+      }
+      return new Response(null, { status: 200 });
+    };
+    const webReq = new Request(url.href, {
+      method: req.method ?? "GET",
+      headers: nodeReqHeadersToRecord(req.headers)
+    });
+    void runChainFn(mws, finalHandler, webReq, ctx).then((result) => {
+      if (result.status >= 400) sendHttpResponseOnSocket(socket, result);
+    }).catch(() => {
+      socket.destroy();
+    });
+  };
 }
 
 // src/core/router.ts
@@ -462,7 +484,6 @@ var Router = class _Router {
   _hasWildcard = false;
   _hub;
   _wss;
-  /** Track which ctx fields have been injected so far (for dependency checking). */
   _ctxFields = /* @__PURE__ */ new Set();
   get wss() {
     if (!this._wss) this._wss = new WebSocketServer({ noServer: true });
@@ -472,90 +493,88 @@ var Router = class _Router {
     if (!this._hub) this._hub = createHub();
     return this._hub;
   }
-  /** Inject a custom hub (e.g. with Redis for cross-process broadcast). */
   wsHub(hub) {
     this._hub = hub;
     return this;
   }
-  use(arg1) {
-    this.globalMws.push(arg1);
-    this._checkMiddlewareMeta(arg1, "global");
+  // ── Middleware & mounting ─────────────────────────────────
+  use(mw) {
+    this.globalMws.push(mw);
+    this._checkMiddlewareMeta(mw, "global");
     return this;
   }
-  /**
-   * Mount a sub-router at the given path prefix.
-   * All routes from the sub-router are registered with the prefix.
-   *
-   * ```ts
-   * const admin = new Router()
-   * admin.get('/dashboard', handler)
-   * app.mount('/admin', admin)  // → GET /admin/dashboard
-   * ```
-   */
   mount(path, router) {
     this._mountRouter(path, router);
     return this;
   }
-  /**
-   * Check a middleware's dependency metadata and emit warnings if
-   * required fields haven't been injected yet.
-   * Attach __meta to a middleware function:
-   *
-   * ```ts
-   * mw.__meta = { injects: ['sql'], depends: ['session'] }
-   * ```
-   */
-  _checkMiddlewareMeta(mw, location) {
-    const meta = mw.__meta ?? (typeof mw === "object" && mw && "middleware" in mw ? mw.middleware().__meta : void 0);
-    if (!meta) return;
-    for (const dep of meta.depends) {
-      if (!this._ctxFields.has(dep)) {
-        console.warn(
-          `[weifuwu] Middleware at "${location}" depends on ctx.${dep} but it hasn't been registered yet.
-  Register the provider before this middleware:
-    app.use(${dep}())  // add before this middleware
-  Current ctx fields: [${[...this._ctxFields].join(", ")}]`
-        );
-      }
-    }
-    for (const field of meta.injects) {
-      this._ctxFields.add(field);
-    }
+  onError(handler) {
+    this.errorHandler = handler;
+    return this;
   }
-  // Route registration — returns Router<T> unchanged.
-  // Route-level middleware and handlers get Context<T>.
-  get(path, ...args) {
-    return this._route("GET", path, ...args);
+  // ── Route registration ────────────────────────────────────
+  get(path, ...rest) {
+    return this._route("GET", path, ...rest);
   }
-  post(path, ...args) {
-    return this._route("POST", path, ...args);
+  post(path, ...rest) {
+    return this._route("POST", path, ...rest);
   }
-  put(path, ...args) {
-    return this._route("PUT", path, ...args);
+  put(path, ...rest) {
+    return this._route("PUT", path, ...rest);
   }
-  delete(path, ...args) {
-    return this._route("DELETE", path, ...args);
+  delete(path, ...rest) {
+    return this._route("DELETE", path, ...rest);
   }
-  patch(path, ...args) {
-    return this._route("PATCH", path, ...args);
+  patch(path, ...rest) {
+    return this._route("PATCH", path, ...rest);
   }
-  head(path, ...args) {
-    return this._route("HEAD", path, ...args);
+  head(path, ...rest) {
+    return this._route("HEAD", path, ...rest);
   }
-  options(path, ...args) {
-    return this._route("OPTIONS", path, ...args);
+  options(path, ...rest) {
+    return this._route("OPTIONS", path, ...rest);
   }
-  all(path, ...args) {
-    return this._route("*", path, ...args);
+  all(path, ...rest) {
+    return this._route("*", path, ...rest);
   }
-  onError(handler) {
-    this.errorHandler = handler;
+  ws(path, ...args) {
+    const handler = args.pop();
+    const mws = args;
+    let node = this.wsRoot;
+    for (const segment of this.splitPath(path)) {
+      node = getOrCreateChild(node, segment, createWsNode, true);
+    }
+    node.handler = handler;
+    node.middlewares = mws;
     return this;
   }
+  // ── Handler compilation ────────────────────────────────────
+  handler() {
+    return (req, ctx) => {
+      const url = new URL(req.url);
+      return this.handle(req, ctx, this.splitPath(url.pathname));
+    };
+  }
+  websocketHandler() {
+    return createWsUpgradeHandler(
+      this.wss,
+      this.hub,
+      (segments) => this.matchWsTrie(this.wsRoot, segments),
+      this.globalMws,
+      (mws, h, req, ctx) => this.runChain(mws, h, req, ctx)
+    );
+  }
+  // ── Debug ──────────────────────────────────────────────────
+  routes() {
+    const result = [];
+    if (this.globalMws.length > 0) result.push(`MIDDLEWARE  [${this.globalMws.length} global]`);
+    this._collectRoutes(this.root, "", result);
+    this._collectWsRoutes(this.wsRoot, "", result);
+    return result;
+  }
+  // ── Private: Route impl ────────────────────────────────────
   _route(method, path, ...args) {
     return this._routeImpl(method, path, args);
   }
-  /** Internal route registration — no type constraints (used by _mountRouter). */
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   _routeImpl(method, path, args) {
     const last = args[args.length - 1];
@@ -564,123 +583,26 @@ var Router = class _Router {
       return this;
     }
     const handler = args.pop();
-    const middlewares = args;
-    const segments = this.splitPath(path);
+    const mws = args;
     let node = this.root;
-    for (const segment of segments) {
+    for (const segment of this.splitPath(path)) {
       if (segment === "*") {
         this._hasWildcard = true;
-        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);
+        if (mws.length > 0) node.middlewares.set(method, mws);
         return this;
       }
       node = getOrCreateChild(node, segment, createTrieNode, false);
     }
-    if (!isProd() && node.handlers.has(method)) {
-      console.warn(`[router] route conflict: ${method} ${path} overwrites existing handler`);
+    if (node.handlers.has(method)) {
+      throw new Error(`[router] route conflict: ${method} ${path} already registered`);
     }
     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 = getOrCreateChild(node, segment, createWsNode, true);
-    }
-    node.handler = handler;
-    node.middlewares = middlewares;
+    if (mws.length > 0) node.middlewares.set(method, mws);
     return this;
   }
-  handler() {
-    return (req, ctx) => {
-      const url = new URL(req.url);
-      return this.handle(req, ctx, this.splitPath(url.pathname));
-    };
-  }
-  /** Returns a human-readable list of all registered routes. Useful for debugging. */
-  routes() {
-    const result = [];
-    if (this.globalMws.length > 0) {
-      result.push(`MIDDLEWARE  [${this.globalMws.length} global]`);
-    }
-    this._collectRoutes(this.root, "", result);
-    this._collectWsRoutes(this.wsRoot, "", result);
-    return result;
-  }
-  _collectRoutes(node, prefix, result) {
-    for (const [method] of node.handlers) {
-      const m = method === "*" ? "ANY" : method;
-      const path = (prefix || "/") + (node.wildcard ? "/*" : "");
-      const middlewares = node.middlewares.get(method);
-      const mwCount = middlewares ? ` (+${middlewares.length} mw)` : "";
-      result.push(`${m.padEnd(7)} ${path}${mwCount}`);
-    }
-    for (const [seg, child] of node.children) {
-      const segment = seg === ":" ? `:${child.param}` : seg;
-      this._collectRoutes(child, prefix + "/" + segment, result);
-    }
-  }
-  _collectWsRoutes(node, prefix, result) {
-    if (node.handler) {
-      const path = prefix || "/";
-      const mwCount = node.middlewares.length ? ` (+${node.middlewares.length} mw)` : "";
-      result.push(`WS       ${path}${mwCount}`);
-    }
-    for (const [seg, child] of node.children) {
-      const segment = seg === ":" ? `:${child.param}` : seg;
-      this._collectWsRoutes(child, prefix + "/" + segment, result);
-    }
-  }
-  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) {
-        socket.destroy();
-        return;
-      }
-      const query = Object.fromEntries(url.searchParams);
-      const ctx = { params: match.params, query };
-      const allMws = router.globalMws.length === 0 && match.middlewares.length === 0 ? [] : [...router.globalMws, ...match.middlewares];
-      if (allMws.length === 0) {
-        upgradeSocket(router.wss, req, socket, head, match.handler, ctx, router.hub);
-        return;
-      }
-      const finalHandler = () => {
-        try {
-          upgradeSocket(router.wss, req, socket, head, match.handler, ctx, router.hub);
-        } catch {
-          socket.destroy();
-          return new Response("WebSocket upgrade failed", { status: 500 });
-        }
-        return new Response(null, { status: 200 });
-      };
-      const webReq = new Request(url.href, {
-        method: req.method ?? "GET",
-        headers: nodeReqHeadersToRecord(req.headers)
-      });
-      void router.runChain(allMws, finalHandler, webReq, ctx).then((result) => {
-        if (result.status >= 400) {
-          sendHttpResponseOnSocket(socket, result);
-        }
-      }).catch((err) => {
-        console.error("[router] WS middleware chain error:", err);
-        socket.destroy();
-      });
-    };
-  }
+  // ── Private: Mount ─────────────────────────────────────────
   _mountRouter(prefix, sub, extraMws = []) {
     const base = prefix === "/" ? "" : prefix.replace(/\/$/, "");
     const mountMw = (req, ctx, next) => {
@@ -696,92 +618,96 @@ var Router = class _Router {
     const wsRoutes = [];
     this._collectWs(sub.wsRoot, "", wsRoutes);
     for (const { path, handler, middlewares } of wsRoutes) {
-      this.ws(
-        base + path,
-        ...allExtra,
-        ...middlewares,
-        handler
-      );
+      this.ws(base + path, ...allExtra, ...middlewares, handler);
     }
   }
   _collect(node, prefix, result) {
     for (const [method, handler] of node.handlers) {
       const rmws = node.middlewares.get(method) || [];
       const suffix = node.wildcard ? "/*" : "";
-      result.push({
-        method,
-        path: (prefix || "/") + suffix,
-        handler,
-        middlewares: [...rmws]
-      });
+      result.push({ method, path: (prefix || "/") + suffix, handler, middlewares: [...rmws] });
     }
     for (const [seg, child] of node.children) {
-      const next = seg === ":" ? `/:${child.param}` : `/${seg}`;
-      this._collect(child, prefix + next, result);
+      this._collect(child, prefix + "/" + (seg === ":" ? `:${child.param}` : seg), result);
     }
   }
   _collectWs(node, prefix, result, mwsAcc = []) {
     const mws = [...mwsAcc, ...node.middlewares];
     if (node.handler) result.push({ path: prefix || "/", handler: node.handler, middlewares: mws });
     for (const [seg, child] of node.children) {
-      const next = seg === ":" ? `/:${child.param}` : `/${seg}`;
-      this._collectWs(child, prefix + next, result, mws);
+      this._collectWs(child, prefix + "/" + (seg === ":" ? `:${child.param}` : seg), result, mws);
     }
   }
+  // ── Private: Matching ──────────────────────────────────────
   splitPath(path) {
     return path.split("/").filter(Boolean);
   }
+  _collectRoutes(node, prefix, result) {
+    for (const [method] of node.handlers) {
+      const m = method === "*" ? "ANY" : method;
+      const path = (prefix || "/") + (node.wildcard ? "/*" : "");
+      const middlewares = node.middlewares.get(method);
+      const mwCount = middlewares ? ` (+${middlewares.length} mw)` : "";
+      result.push(`${m.padEnd(7)} ${path}${mwCount}`);
+    }
+    for (const [seg, child] of node.children) {
+      const segment = seg === ":" ? `:${child.param}` : seg;
+      this._collectRoutes(child, prefix + "/" + segment, result);
+    }
+  }
+  _collectWsRoutes(node, prefix, result) {
+    if (node.handler) {
+      const path = prefix || "/";
+      const mwCount = node.middlewares.length ? ` (+${node.middlewares.length} mw)` : "";
+      result.push(`WS       ${path}${mwCount}`);
+    }
+    for (const [seg, child] of node.children) {
+      const segment = seg === ":" ? `:${child.param}` : seg;
+      this._collectWsRoutes(child, prefix + "/" + segment, result);
+    }
+  }
   matchTrie(method, segments) {
     let node = this.root;
     const params = {};
-    let wildcardHandler = null;
-    let wildcardMws = [];
-    let wildcardIdx = -1;
+    for (const seg of segments) {
+      const next = matchChild(node, seg, params, false);
+      if (!next) return this._wildcardMatch(method, segments);
+      node = next;
+    }
+    return this._resolveMatch(node, method, params, segments.length);
+  }
+  _wildcardMatch(method, segments) {
+    if (!this._hasWildcard) return null;
+    let node = this.root;
+    const params = {};
     for (let i = 0; i < segments.length; i++) {
-      if (this._hasWildcard && node.wildcard) {
-        let h = node.handlers.get("*") || node.handlers.get(method);
-        if (!h && method === "HEAD") {
-          h = node.handlers.get("GET");
-        }
+      if (node.wildcard) {
+        const h = node.handlers.get("*") || node.handlers.get(method) || (method === "HEAD" ? node.handlers.get("GET") : void 0);
         if (h) {
-          wildcardHandler = h;
-          wildcardMws = node.middlewares.get(method) || node.middlewares.get("*") || [];
-          wildcardIdx = i;
+          params["*"] = segments.slice(i).join("/");
+          return { kind: "route", handler: h, mws: node.middlewares.get(method) || node.middlewares.get("*") || [], params };
         }
       }
-      const segment = segments[i];
-      const next = matchChild(node, segment, params, false);
-      if (!next) {
-        if (wildcardHandler) {
-          params["*"] = segments.slice(wildcardIdx).join("/");
-          return { kind: "route", handler: wildcardHandler, mws: wildcardMws, params };
-        }
-        return null;
-      }
+      const next = matchChild(node, segments[i], params, false);
+      if (!next) return null;
       node = next;
     }
+    return null;
+  }
+  _resolveMatch(node, method, params, _segLen) {
     let handler = node.handlers.get(method) || node.handlers.get("*");
-    if (!handler && method === "HEAD") {
-      handler = node.handlers.get("GET");
-    }
+    if (!handler && method === "HEAD") handler = node.handlers.get("GET");
+    if (node.wildcard) params["*"] = "";
     if (handler) {
-      if (node.wildcard) params["*"] = segments.slice(segments.length).join("/");
-      return {
-        kind: "route",
-        handler,
-        mws: node.middlewares.get(method) || node.middlewares.get("*") || [],
-        params
-      };
-    }
-    if (wildcardHandler) {
-      params["*"] = segments.slice(wildcardIdx).join("/");
-      return { kind: "route", handler: wildcardHandler, mws: wildcardMws, params };
+      return { kind: "route", handler, mws: node.middlewares.get(method) || node.middlewares.get("*") || [], params };
     }
     if (node.handlers.size > 0) {
       return {
         kind: "not-allowed",
-        methods: [...node.handlers.keys()].filter((k) => k !== "*"),
-        params
+        handler: () => new Response("", { status: 405 }),
+        mws: [],
+        params,
+        methods: [...node.handlers.keys()].filter((k) => k !== "*")
       };
     }
     return null;
@@ -789,167 +715,89 @@ var Router = class _Router {
   matchWsTrie(root, segments) {
     let node = root;
     const params = {};
-    for (const segment of segments) {
-      const next = matchChild(node, segment, params, true);
+    for (const seg of segments) {
+      const next = matchChild(node, seg, params, true);
       if (!next) return null;
       node = next;
     }
     return node.handler ? { handler: node.handler, middlewares: node.middlewares, params } : null;
   }
-  async handleError(e, req, ctx) {
-    const err = e instanceof Error ? e : new Error(String(e));
-    console.error(err);
-    return this.errorHandler ? await this.errorHandler(err, req, ctx) : new Response("Internal Server Error", { status: 500 });
-  }
-  _notFoundResponse(method, segments) {
-    if (!isProd()) {
-      return Response.json(
-        { error: "Not Found", path: "/" + segments.join("/"), method },
-        { status: 404 }
-      );
-    }
-    return new Response("Not Found", { status: 404 });
-  }
+  // ── Private: Request handling ──────────────────────────────
   async handle(req, ctx, segments) {
     const match = this.matchTrie(req.method, segments);
     if (match) {
       Object.assign(ctx.params, match.params);
-      switch (match.kind) {
-        case "route": {
-          const mws = [...this.globalMws, ...match.mws];
-          try {
-            return await this.runChain(mws, match.handler, req, ctx);
-          } catch (e) {
-            return this.handleError(e, req, ctx);
-          }
+      if (match.kind === "route") {
+        try {
+          return await this.runChain([...this.globalMws, ...match.mws], match.handler, req, ctx);
+        } catch (e) {
+          return this.handleError(e, req, ctx);
         }
-        case "not-allowed": {
-          if (this.globalMws.length > 0) {
-            try {
-              return await this.runChain(
-                this.globalMws,
-                () => new Response("Method Not Allowed", {
-                  status: 405,
-                  headers: { Allow: match.methods.join(", ") }
-                }),
-                req,
-                ctx
-              );
-            } catch (e) {
-              return this.handleError(e, req, ctx);
-            }
-          }
-          return new Response("Method Not Allowed", {
+      }
+      if (this.globalMws.length > 0) {
+        try {
+          return await this.runChain(this.globalMws, () => new Response("Method Not Allowed", {
             status: 405,
-            headers: { Allow: match.methods.join(", ") }
-          });
+            headers: { Allow: (match.methods || []).join(", ") }
+          }), req, ctx);
+        } catch (e) {
+          return this.handleError(e, req, ctx);
         }
       }
+      return new Response("Method Not Allowed", { status: 405, headers: { Allow: (match.methods || []).join(", ") } });
     }
+    const nf = () => Response.json({ error: "Not Found", path: "/" + segments.join("/"), method: req.method }, { status: 404 });
     if (this.globalMws.length > 0) {
       try {
-        return await this.runChain(
-          this.globalMws,
-          () => this._notFoundResponse(req.method, segments),
-          req,
-          ctx
-        );
+        return await this.runChain(this.globalMws, nf, req, ctx);
       } catch (e) {
         return this.handleError(e, req, ctx);
       }
     }
-    return this._notFoundResponse(req.method, segments);
+    return nf();
   }
-  async runChain(middlewares, finalHandler, req, ctx) {
-    if (middlewares.length === 0) return await finalHandler(req, ctx);
-    return await runChainLoop(middlewares, 0, finalHandler, req, ctx);
+  async handleError(e, req, ctx) {
+    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 });
   }
-};
-function runChainLoop(middlewares, index, finalHandler, req, ctx) {
-  if (index < middlewares.length) {
-    const mw = middlewares[index];
-    let called = false;
+  // ── Private: Middleware chain ───────────────────────────────
+  async runChain(mws, finalHandler, req, ctx) {
+    if (mws.length === 0) return finalHandler(req, ctx);
+    let i = 0;
     const dispatch = (r, c) => {
-      if (called) {
-        console.warn(
-          "[router] next() called more than once in middleware \u2014 ignoring duplicate call"
+      if (i >= mws.length) return Promise.resolve(finalHandler(r, c));
+      const mw = mws[i++];
+      let called = false;
+      const next = (r2, c2) => {
+        if (called) throw new Error("[router] next() called more than once in middleware");
+        called = true;
+        return dispatch(r2, c2);
+      };
+      return Promise.resolve(mw(r, c, next));
+    };
+    return dispatch(req, ctx);
+  }
+  // ── Private: Meta checking ──────────────────────────────────
+  _checkMiddlewareMeta(mw, location) {
+    const meta = mw.__meta ?? (typeof mw === "object" && mw && "middleware" in mw ? mw.middleware().__meta : void 0);
+    if (!meta) return;
+    for (const dep of meta.depends) {
+      if (!this._ctxFields.has(dep)) {
+        throw new Error(
+          `[weifuwu] Middleware at "${location}" depends on ctx.${dep} but it hasn't been registered.
+  Register the provider before this middleware: app.use(${dep}())`
         );
-        return Promise.resolve(new Response("", { status: 499 }));
       }
-      called = true;
-      return runChainLoop(middlewares, index + 1, finalHandler, r, c);
-    };
-    return Promise.resolve(mw(req, ctx, dispatch));
+    }
+    for (const field of meta.injects) this._ctxFields.add(field);
   }
-  return Promise.resolve(finalHandler(req, ctx));
-}
-function upgradeSocket(wss, req, socket, head, handler, ctx, hub) {
-  wss.handleUpgrade(req, socket, head, (ws) => {
-    const connCtx = { ...ctx, params: { ...ctx.params }, query: { ...ctx.query } };
-    const wsState = {};
-    connCtx.ws = {
-      get state() {
-        return wsState;
-      },
-      json(data) {
-        ws.send(JSON.stringify(data));
-      },
-      join(room) {
-        hub.join(room, ws);
-      },
-      leave(_room) {
-        hub.leave(ws);
-      },
-      sendRoom(room, data) {
-        hub.broadcast(room, data);
-      }
-    };
-    if (handler.open) {
-      handler.open(ws, connCtx);
-    }
-    ws.on("message", (data) => {
-      handler.message?.(ws, connCtx, data);
-    });
-    ws.on("close", () => {
-      hub.leave(ws);
-      handler.close?.(ws, connCtx);
-    });
-    ws.on("error", (err) => {
-      handler.error?.(ws, connCtx, err);
-    });
-  });
-}
-function nodeReqHeadersToRecord(headers) {
-  const result = {};
-  for (const [k, v] of Object.entries(headers)) {
-    if (v !== void 0) result[k] = Array.isArray(v) ? v.join(", ") : v;
-  }
-  return result;
-}
-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) => {
-    socket.write(headerStr + "\r\n");
-    if (buf.byteLength > 0) socket.write(Buffer.from(buf));
-    socket.end();
-  }).catch(() => {
-    socket.write(headerStr + "\r\n");
-    socket.end();
-  });
-}
-
-// src/core/logger.ts
-function emit(event) {
-  event.traceId = event.traceId ?? currentTraceId();
-  event.timestamp = (/* @__PURE__ */ new Date()).toISOString();
-  process.stderr.write(JSON.stringify(event) + "\n");
+};
+
+// src/core/logger.ts
+function emit(event) {
+  event.traceId = event.traceId ?? currentTraceId();
+  event.timestamp = (/* @__PURE__ */ new Date()).toISOString();
+  process.stderr.write(JSON.stringify(event) + "\n");
 }
 function logger(options) {
   const format = options?.format ?? "short";
@@ -1046,10 +894,10 @@ function cors(options) {
 
 // src/middleware/static.ts
 import { open, realpath } from "node:fs/promises";
-import { extname, resolve as resolve2, normalize, sep } from "node:path";
+import { extname, resolve, normalize, sep } from "node:path";
 import { Readable } from "node:stream";
 function serveStatic(root, options) {
-  const rootDir = resolve2(root);
+  const rootDir = resolve(root);
   const opts = options ?? {};
   return async (req, ctx) => {
     const relativePath = ctx.params["*"] ?? new URL(req.url).pathname.slice(1);
@@ -1057,50 +905,50 @@ function serveStatic(root, options) {
     if (decoded.includes("..") || decoded.includes("\0")) {
       return new Response("Forbidden", { status: 403 });
     }
-    let filePath = normalize(resolve2(rootDir, decoded));
+    let filePath = normalize(resolve(rootDir, decoded));
     if (!filePath.startsWith(rootDir + sep) && filePath !== rootDir) {
       return new Response("Forbidden", { status: 403 });
     }
     let fileHandle;
     try {
       fileHandle = await open(filePath, "r");
-      let stat2 = await fileHandle.stat();
+      let stat = 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 (stat2.isDirectory()) {
+      if (stat.isDirectory()) {
         await fileHandle.close();
         const indexFile = opts.index ?? "index.html";
-        filePath = resolve2(filePath, indexFile);
+        filePath = resolve(filePath, indexFile);
         if (!filePath.startsWith(rootDir + sep)) {
           return new Response("Forbidden", { status: 403 });
         }
         fileHandle = await open(filePath, "r");
-        stat2 = await fileHandle.stat();
-        if (!stat2.isFile()) {
+        stat = await fileHandle.stat();
+        if (!stat.isFile()) {
           await fileHandle.close();
           return new Response("Not Found", { status: 404 });
         }
       }
       const mimeType = MIME_TYPES[extname(filePath).toLowerCase()] ?? "application/octet-stream";
-      const etag = `"${stat2.ino}-${stat2.size}-${stat2.mtimeMs}"`;
+      const etag = `"${stat.ino}-${stat.size}-${stat.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 && stat2.mtimeMs <= new Date(ifModifiedSince).getTime()) {
+      if (ifModifiedSince && stat.mtimeMs <= new Date(ifModifiedSince).getTime()) {
         await fileHandle.close();
         return new Response(null, { status: 304 });
       }
       const headers = {
         "Content-Type": mimeType,
-        "Content-Length": String(stat2.size),
+        "Content-Length": String(stat.size),
         ETag: etag,
-        "Last-Modified": stat2.mtime.toUTCString(),
+        "Last-Modified": stat.mtime.toUTCString(),
         "Cache-Control": opts.immutable ? `public, max-age=${opts.maxAge ?? 31536e3}, immutable` : `public, max-age=${opts.maxAge ?? 0}`
       };
       const readStream = fileHandle.createReadStream();
@@ -1157,187 +1005,6 @@ var MIME_TYPES = {
   ".wav": "audio/wav"
 };
 
-// src/middleware/validate.ts
-function parseFormBody(text) {
-  const params = new URLSearchParams(text);
-  const result = {};
-  for (const [key, value] of params) {
-    result[key] = value;
-  }
-  return result;
-}
-function parseBody(text, ct) {
-  if (ct.includes("application/x-www-form-urlencoded")) {
-    return parseFormBody(text);
-  }
-  const isExplicitJson = ct.includes("application/json") || ct.includes("+json") || ct.includes("text/") || ct.includes("*/json");
-  const isNotSpecialMultipart = !ct.includes("multipart/form-data") && !ct.includes("application/x-www-form-urlencoded");
-  if (isExplicitJson || isNotSpecialMultipart) {
-    try {
-      return JSON.parse(text);
-    } catch {
-    }
-  }
-  return text;
-}
-function validate(schemas) {
-  const mw = async (req, ctx, next) => {
-    const parsed = {};
-    const issues = [];
-    if (schemas?.params) {
-      const result = schemas.params.safeParse(ctx.params);
-      if (result.success) {
-        parsed.params = result.data;
-      } else {
-        issues.push(
-          ...result.error.issues.map((i) => ({
-            path: ["params", ...i.path.map(String)],
-            message: i.message
-          }))
-        );
-      }
-    }
-    if (schemas?.query) {
-      const result = schemas.query.safeParse(ctx.query);
-      if (result.success) {
-        parsed.query = result.data;
-      } else {
-        issues.push(
-          ...result.error.issues.map((i) => ({
-            path: ["query", ...i.path.map(String)],
-            message: i.message
-          }))
-        );
-      }
-    }
-    if (schemas?.headers) {
-      const rawHeaders = {};
-      req.headers.forEach((v, k) => {
-        rawHeaders[k] = v;
-      });
-      const result = schemas.headers.safeParse(rawHeaders);
-      if (result.success) {
-        parsed.headers = result.data;
-      } else {
-        issues.push(
-          ...result.error.issues.map((i) => ({
-            path: ["headers", ...i.path.map(String)],
-            message: i.message
-          }))
-        );
-      }
-    }
-    if (req.method !== "GET" && req.method !== "HEAD") {
-      const ct = req.headers.get("content-type") ?? "";
-      const isForm = ct.includes("application/x-www-form-urlencoded");
-      if (schemas?.body || isForm) {
-        if (req.body === null) {
-          if (schemas?.body) {
-            issues.push({ path: ["body"], message: "Request body is required" });
-          }
-        } else {
-          const bodyText = await req.text();
-          if (!bodyText) {
-            if (schemas?.body) {
-              issues.push({ path: ["body"], message: "Request body is required" });
-            }
-          } else {
-            const bodyValue = parseBody(bodyText, ct);
-            if (schemas?.body) {
-              const result = schemas.body.safeParse(bodyValue);
-              if (result.success) {
-                parsed.body = result.data;
-              } else {
-                issues.push(
-                  ...result.error.issues.map((i) => ({
-                    path: ["body", ...i.path.map(String)],
-                    message: i.message
-                  }))
-                );
-              }
-            } else {
-              parsed.body = bodyValue;
-            }
-          }
-        }
-      }
-    }
-    if (issues.length > 0) {
-      return Response.json({ error: "Validation failed", issues }, { status: 400 });
-    }
-    ctx.parsed = { ...ctx.parsed, ...parsed };
-    return next(req, ctx);
-  };
-  mw.__meta = { injects: ["parsed"], depends: [] };
-  return mw;
-}
-
-// src/core/cookie.ts
-function getCookies(req) {
-  const header = req.headers.get("cookie");
-  if (!header) return {};
-  const cookies = {};
-  for (const pair of header.split(";")) {
-    const idx = pair.indexOf("=");
-    if (idx === -1) continue;
-    let name = pair.slice(0, idx).trim();
-    let value = pair.slice(idx + 1).trim();
-    if (!name) continue;
-    try {
-      name = decodeURIComponent(name);
-    } catch {
-    }
-    if (value.length >= 2 && value.startsWith('"') && value.endsWith('"')) {
-      value = value.slice(1, -1);
-    }
-    try {
-      cookies[name] = decodeURIComponent(value);
-    } catch {
-      cookies[name] = value;
-    }
-  }
-  return cookies;
-}
-function serializeCookie(name, value, options) {
-  if (/[\x00-\x1F\x7F-\x9F;,]/.test(name) || /[\x00-\x1F\x7F-\x9F;,]/.test(value)) {
-    throw new Error(`Invalid cookie name or value: contains control characters or special chars`);
-  }
-  const parts = [`${encodeURIComponent(name)}=${encodeURIComponent(value)}`];
-  if (options?.maxAge != null) parts.push(`Max-Age=${options.maxAge}`);
-  if (options?.expires) parts.push(`Expires=${options.expires.toUTCString()}`);
-  if (options?.domain) parts.push(`Domain=${options.domain}`);
-  if (options?.path) parts.push(`Path=${options.path}`);
-  if (options?.httpOnly) parts.push("HttpOnly");
-  if (options?.secure) parts.push("Secure");
-  if (options?.sameSite) parts.push(`SameSite=${options.sameSite}`);
-  return parts.join("; ");
-}
-function setCookie(res, name, value, options) {
-  const headers = new Headers(res.headers);
-  headers.append("Set-Cookie", serializeCookie(name, value, options));
-  return new Response(res.body, {
-    status: res.status,
-    statusText: res.statusText,
-    headers
-  });
-}
-function deleteCookie(res, name, options) {
-  const headers = new Headers(res.headers);
-  headers.append(
-    "Set-Cookie",
-    serializeCookie(name, "", {
-      ...options,
-      maxAge: 0,
-      expires: /* @__PURE__ */ new Date(0)
-    })
-  );
-  return new Response(res.body, {
-    status: res.status,
-    statusText: res.statusText,
-    headers
-  });
-}
-
 // src/middleware/upload.ts
 import { writeFile, mkdir } from "node:fs/promises";
 import { randomUUID } from "node:crypto";
@@ -1378,8 +1045,7 @@ function upload(options) {
     if (!ct.includes("multipart/form-data")) return next(req, ctx);
     try {
       if (saveDir) await mkdir(saveDir, { recursive: true });
-    } catch (e) {
-      console.error("upload: failed to create directory", saveDir, e);
+    } catch {
       return Response.json({ error: "Server configuration error" }, { status: 500 });
     }
     let formData;
@@ -1637,482 +1303,6 @@ var DEFAULTS = {
   permissionsPolicy: "camera=(),display-capture=(),fullscreen=(),geolocation=(),microphone=()"
 };
 
-// src/middleware/request-id.ts
-import crypto3 from "node:crypto";
-function requestId(options) {
-  const header = options?.header ?? "X-Request-ID";
-  const gen = options?.generator ?? (() => crypto3.randomUUID());
-  const mw = async (req, ctx, next) => {
-    const existing = req.headers.get(header);
-    const id = existing ?? gen();
-    ctx.requestId = id;
-    const res = await next(req, ctx);
-    if (res.headers.has(header)) return res;
-    const h = new Headers(res.headers);
-    h.set(header, id);
-    return new Response(res.body, { status: res.status, statusText: res.statusText, headers: h });
-  };
-  mw.__meta = { injects: ["requestId"], depends: [] };
-  return mw;
-}
-
-// src/core/sse.ts
-var encoder = new TextEncoder();
-function formatSSE(event, data) {
-  return `event: ${event}
-data: ${JSON.stringify(data)}
-
-`;
-}
-function formatSSEData(data) {
-  return `data: ${JSON.stringify(data)}
-
-`;
-}
-function createSSEStream(iterable, opts) {
-  return new Response(
-    new ReadableStream({
-      async start(controller) {
-        try {
-          for await (const event of iterable) {
-            const text = event.type ? formatSSE(event.type, event) : formatSSEData(event);
-            controller.enqueue(encoder.encode(text));
-          }
-        } catch (e) {
-          if (e instanceof Error && e.name !== "AbortError") {
-            controller.enqueue(encoder.encode(formatSSE("error", { error: e.message })));
-          }
-        } finally {
-          controller.close();
-        }
-      }
-    }),
-    {
-      status: opts?.status ?? 200,
-      headers: {
-        "Content-Type": "text/event-stream",
-        "Cache-Control": "no-cache",
-        Connection: "keep-alive",
-        ...opts?.headers
-      }
-    }
-  );
-}
-
-// src/test/test-utils.ts
-import { WebSocket as WSWebSocket } from "ws";
-var TestResponseImpl = class {
-  response;
-  constructor(response) {
-    this.response = response;
-  }
-  get status() {
-    return this.response.status;
-  }
-  get headers() {
-    return this.response.headers;
-  }
-  async json() {
-    return this.response.json();
-  }
-  async text() {
-    return this.response.text();
-  }
-  async bytes() {
-    return this.response.bytes();
-  }
-  async arrayBuffer() {
-    return this.response.arrayBuffer();
-  }
-};
-var TestRequest = class {
-  headers = {};
-  ctxMixin = {};
-  bodyData = null;
-  app;
-  method;
-  path;
-  constructor(app, method, path) {
-    this.app = app;
-    this.method = method;
-    this.path = path;
-  }
-  /** Set a request header */
-  header(name, value) {
-    this.headers[name.toLowerCase()] = value;
-    return this;
-  }
-  /** Mix properties into ctx (simulating middleware injection) */
-  with(mixin) {
-    Object.assign(this.ctxMixin, mixin);
-    return this;
-  }
-  /** Shortcut: set ctx.user */
-  withUser(user) {
-    ;
-    this.ctxMixin.user = user;
-    return this;
-  }
-  /** Shortcut: set ctx.tenant */
-  withTenant(tenant) {
-    this.ctxMixin.tenant = tenant;
-    return this;
-  }
-  /** Set JSON request body */
-  body(data) {
-    this.bodyData = JSON.stringify(data);
-    this.headers["content-type"] = "application/json";
-    return this;
-  }
-  /** Set raw text body */
-  rawBody(data) {
-    this.bodyData = data;
-    return this;
-  }
-  /** Send the request and return the response */
-  async send() {
-    const url = `http://localhost${this.path}`;
-    const query = {};
-    const qIdx = this.path.indexOf("?");
-    if (qIdx !== -1) {
-      const searchParams = new URLSearchParams(this.path.slice(qIdx));
-      for (const [k, v] of searchParams) {
-        query[k] = v;
-      }
-    }
-    const request = new Request(url, {
-      method: this.method,
-      headers: this.headers,
-      body: this.bodyData
-    });
-    const ctx = {
-      params: {},
-      query,
-      ...this.ctxMixin
-    };
-    const handler = this.app.handler();
-    const response = await handler(request, ctx);
-    return new TestResponseImpl(response);
-  }
-};
-var TestApp = class {
-  router;
-  wsServer = null;
-  wsConnections = [];
-  constructor() {
-    this.router = new Router();
-  }
-  /**
-   * Register a WebSocket handler.
-   */
-  ws(path, handler) {
-    this.router.ws(path, handler);
-    return this;
-  }
-  /** Get the raw Router (for advanced use). */
-  get _router() {
-    return this.router;
-  }
-  /** Add global middleware */
-  use(mw) {
-    this.router.use(mw);
-    return this;
-  }
-  /** Register a GET route — supports route-level middleware via spread args. */
-  get(path, ...args) {
-    ;
-    this.router.get(path, ...args);
-    return this;
-  }
-  /** Register a POST route. */
-  post(path, ...args) {
-    ;
-    this.router.post(path, ...args);
-    return this;
-  }
-  /** Register a PUT route. */
-  put(path, ...args) {
-    ;
-    this.router.put(path, ...args);
-    return this;
-  }
-  /** Register a PATCH route. */
-  patch(path, ...args) {
-    ;
-    this.router.patch(path, ...args);
-    return this;
-  }
-  /** Register a DELETE route. */
-  delete(path, ...args) {
-    ;
-    this.router.delete(path, ...args);
-    return this;
-  }
-  /** Start building a GET request */
-  getReq(path) {
-    return new TestRequest(this, "GET", path);
-  }
-  /** Start building a POST request */
-  postReq(path) {
-    return new TestRequest(this, "POST", path);
-  }
-  /** Start building a PUT request */
-  putReq(path) {
-    return new TestRequest(this, "PUT", path);
-  }
-  /** Start building a PATCH request */
-  patchReq(path) {
-    return new TestRequest(this, "PATCH", path);
-  }
-  /** Start building a DELETE request */
-  deleteReq(path) {
-    return new TestRequest(this, "DELETE", path);
-  }
-  /** Get the underlying handler (for advanced usage) */
-  handler() {
-    return this.router.handler();
-  }
-  /** Start building a WebSocket connection to the given path. */
-  wsReq(path) {
-    return new TestWSRequest(this, path);
-  }
-  /**
-   * Internal: ensure HTTP server is running for WebSocket connections.
-   * Starts on a random port.
-   */
-  /* @internal */
-  async _ensureServer() {
-    if (this.wsServer) {
-      return `http://localhost:${this.wsServer.port}`;
-    }
-    const wsHandler = this.router.websocketHandler();
-    if (!wsHandler) {
-      throw new Error(
-        "No WebSocket routes registered. Use app.ws(path, handler) before calling wsReq()."
-      );
-    }
-    this.wsServer = serve(this.router);
-    await this.wsServer.ready;
-    return `http://localhost:${this.wsServer.port}`;
-  }
-  /**
-   * Internal: register a WS connection for cleanup.
-   */
-  /* @internal */
-  _trackConnection(conn) {
-    this.wsConnections.push(conn);
-  }
-  /**
-   * Cleanup all WebSocket connections and stop the server.
-   */
-  async close() {
-    for (const conn of this.wsConnections) {
-      try {
-        conn.close();
-      } catch {
-      }
-    }
-    this.wsConnections = [];
-    if (this.wsServer) {
-      this.wsServer.close();
-      this.wsServer = null;
-    }
-  }
-};
-var TestWSRequest = class {
-  app;
-  path;
-  _timeout = 5e3;
-  constructor(app, path) {
-    this.app = app;
-    this.path = path;
-  }
-  /** Set the timeout for operations (default: 5000ms). */
-  timeout(ms) {
-    this._timeout = ms;
-    return this;
-  }
-  /**
-   * Connect to the WebSocket endpoint.
-   * Starts a real HTTP server (random port) if not already running.
-   */
-  async connect() {
-    const baseUrl = await this.app._ensureServer();
-    const wsUrl = baseUrl.replace(/^http/, "ws") + this.path;
-    const ws = new WSWebSocket(wsUrl, { handshakeTimeout: this._timeout });
-    return new Promise((resolve4, reject) => {
-      const timer = setTimeout(() => {
-        reject(new Error(`WebSocket connection timed out after ${this._timeout}ms`));
-        ws.close();
-      }, this._timeout);
-      ws.on("open", () => {
-        clearTimeout(timer);
-        const conn = new TestWSConnection(ws, this._timeout);
-        this.app._trackConnection(conn);
-        resolve4(conn);
-      });
-      ws.on("error", (err) => {
-        clearTimeout(timer);
-        reject(new Error(`WebSocket connection error: ${err.message}`));
-      });
-      ws.on("unexpected-response", (_req, res) => {
-        clearTimeout(timer);
-        let body = "";
-        res.on("data", (chunk) => {
-          body += chunk.toString();
-        });
-        res.on("end", () => {
-          reject(new Error(`WebSocket upgrade rejected (${res.statusCode}): ${body.slice(0, 200)}`));
-        });
-      });
-    });
-  }
-};
-var TestWSConnection = class {
-  ws;
-  _timeout;
-  messageQueue = [];
-  resolveQueue = [];
-  _closed = false;
-  constructor(ws, timeout = 5e3) {
-    this.ws = ws;
-    this._timeout = timeout;
-    ws.on("message", (data) => {
-      const str = data.toString();
-      if (this.resolveQueue.length > 0) {
-        const resolve4 = this.resolveQueue.shift();
-        resolve4(str);
-      } else {
-        this.messageQueue.push(str);
-      }
-    });
-    ws.on("close", () => {
-      this._closed = true;
-      for (const _r of this.resolveQueue) {
-      }
-    });
-  }
-  /** Send a text message. */
-  send(data) {
-    this.ws.send(data);
-  }
-  /** Send a JSON message. */
-  json(data) {
-    this.ws.send(JSON.stringify(data));
-  }
-  /**
-   * Wait for the next message. Returns the raw text.
-   * Throws on timeout or if the connection is closed.
-   */
-  async receive(timeout) {
-    if (this.messageQueue.length > 0) {
-      return this.messageQueue.shift();
-    }
-    if (this._closed) {
-      throw new Error("WebSocket connection closed");
-    }
-    return new Promise((resolve4, reject) => {
-      const timer = setTimeout(() => {
-        const idx = this.resolveQueue.indexOf(resolve4);
-        if (idx !== -1) this.resolveQueue.splice(idx, 1);
-        reject(new Error(`WebSocket receive timed out after ${timeout ?? this._timeout}ms`));
-      }, timeout ?? this._timeout);
-      this.resolveQueue.push((msg) => {
-        clearTimeout(timer);
-        resolve4(msg);
-      });
-    });
-  }
-  /** Wait for the next message and parse as JSON. */
-  async receiveJson() {
-    const msg = await this.receive();
-    return JSON.parse(msg);
-  }
-  /**
-   * Assert that no message is received within the given silence period.
-   * Useful for verifying that something did NOT happen.
-   */
-  async expectSilent(ms) {
-    return new Promise((resolve4, reject) => {
-      if (this.messageQueue.length > 0) {
-        reject(new Error(`Expected silence but got message: ${this.messageQueue[0].slice(0, 100)}`));
-        return;
-      }
-      const timer = setTimeout(() => resolve4(), ms);
-      const origPush = this.resolveQueue.push.bind(this.resolveQueue);
-      this.resolveQueue.push = (_fn) => {
-        clearTimeout(timer);
-        reject(new Error("Expected silence but received a message"));
-        return 0;
-      };
-      setTimeout(() => {
-        this.resolveQueue.push = origPush;
-      }, ms + 10).unref();
-    });
-  }
-  /** Close the connection. */
-  close() {
-    this._closed = true;
-    this.ws.close();
-  }
-  /** Whether the connection is closed. */
-  get closed() {
-    return this._closed;
-  }
-};
-function testApp() {
-  return new TestApp();
-}
-async function createTestDb(options) {
-  const dbUrl = options?.url || process.env.TEST_DATABASE_URL || process.env.DATABASE_URL;
-  if (!dbUrl) throw new Error("createTestDb: DATABASE_URL or TEST_DATABASE_URL required");
-  const schema = options?.schema || `test_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
-  const { default: postgres2 } = await import("postgres");
-  const adminSql = postgres2(dbUrl);
-  await adminSql.unsafe('CREATE SCHEMA IF NOT EXISTS "' + schema.replace(/"/g, '""') + '"');
-  const schemaUrl = new URL(dbUrl);
-  schemaUrl.searchParams.set("search_path", schema);
-  const sql = postgres2(schemaUrl.toString());
-  await adminSql.end();
-  return {
-    sql,
-    url: schemaUrl.toString(),
-    schema,
-    destroy: async () => {
-      const destroySql = postgres2(dbUrl);
-      await destroySql.unsafe('DROP SCHEMA IF EXISTS "' + schema.replace(/"/g, '""') + '" CASCADE');
-      await destroySql.end();
-      await sql.end();
-    }
-  };
-}
-async function withTestDb(optionsOrFn, fn) {
-  let dbUrl;
-  let callback;
-  if (typeof optionsOrFn === "function") {
-    callback = optionsOrFn;
-  } else if (typeof optionsOrFn === "string") {
-    dbUrl = optionsOrFn;
-    callback = fn;
-  } else {
-    dbUrl = optionsOrFn?.url;
-    callback = fn;
-  }
-  const resolvedUrl = dbUrl || process.env.TEST_DATABASE_URL || process.env.DATABASE_URL;
-  if (!resolvedUrl) throw new Error("withTestDb: DATABASE_URL or TEST_DATABASE_URL required");
-  const { default: postgres2 } = await import("postgres");
-  const sql = postgres2(resolvedUrl);
-  try {
-    await sql.begin(async (txSql) => {
-      await callback(txSql);
-      throw void 0;
-    });
-  } catch {
-  } finally {
-    await sql.end();
-  }
-}
-
 // src/graphql.ts
 import {
   buildSchema,
@@ -2145,16 +1335,10 @@ async function parseParamsFromPost(req) {
   }
 }
 function buildSchemaFromOptions(options) {
-  try {
-    if (typeof options.schema === "string") {
-      return options.resolvers ? makeExecutableSchema({ typeDefs: options.schema, resolvers: options.resolvers }) : buildSchema(options.schema);
-    }
-    return options.schema;
-  } catch (err) {
-    const msg = err instanceof Error ? err.message : String(err);
-    console.error(`[graphql] schema build failed: ${msg}`);
-    throw err;
+  if (typeof options.schema === "string") {
+    return options.resolvers ? makeExecutableSchema({ typeDefs: options.schema, resolvers: options.resolvers }) : buildSchema(options.schema);
   }
+  return options.schema;
 }
 function queryDepth(doc) {
   let max = 0;
@@ -2222,7 +1406,6 @@ async function executeQuery(schema, params, options, req, ctx) {
     return Response.json(result, { status: result.errors ? 400 : 200 });
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
-    console.error(`[${currentTraceId()}] graphql execution failed: ${msg}`);
     return Response.json({ errors: [{ message: msg }] }, { status: 500 });
   }
 }
@@ -2414,7 +1597,8 @@ function redis(opts) {
   const options = typeof opts === "string" ? { url: opts } : opts ?? {};
   const url = options.url ?? process.env.REDIS_URL ?? "redis://localhost:6379";
   const client = new IORedis(url, options);
-  client.on("error", (err) => console.error("[redis]", err.message));
+  client.on("error", () => {
+  });
   const mw = ((req, ctx, next) => {
     ctx.redis = client;
     return next(req, ctx);
@@ -2426,8 +1610,8 @@ function redis(opts) {
 }
 
 // src/queue/index.ts
+import crypto2 from "node:crypto";
 import { Redis as IORedis2 } from "ioredis";
-import crypto4 from "node:crypto";
 
 // src/queue/cron.ts
 function parseField(field, min, max) {
@@ -2495,427 +1679,85 @@ function cronNext(expr, from = /* @__PURE__ */ new Date()) {
 
 // src/queue/index.ts
 function queue(opts) {
-  const store = opts?.store ?? "memory";
-  if (store === "redis") return createRedisQueue(opts);
-  if (store === "pg") return createPgQueue(opts);
-  return createMemoryQueue(opts);
-}
-function escapeIdent(s) {
-  return '"' + s.replace(/"/g, '""') + '"';
-}
-function attachCron(q, handlers) {
-  ;
-  q.cron = function(pattern, handler) {
-    const id = "__cron_" + pattern.replace(/[^a-zA-Z0-9]/g, "_") + "_" + crypto4.randomUUID().slice(0, 8);
-    q.process(id, async () => {
-      await handler();
-    });
-    q.add(id, {}, { schedule: pattern });
-    return { stop: () => handlers.delete(id) };
-  };
-}
-function createMemoryQueue(opts) {
+  const redis2 = opts?.redis ?? new IORedis2(opts?.url ?? process.env.REDIS_URL ?? "redis://localhost:6379");
+  const prefix = opts?.prefix ?? "queue";
+  const jobKey = prefix + ":jobs";
+  const failedKey = prefix + ":failed";
   const pollInterval = opts?.pollInterval ?? 200;
-  const handlers = /* @__PURE__ */ new Map();
-  const pending = [];
-  const failed = [];
-  const MAX_FAILED = 1e3;
-  let running = false;
-  let pollTimer = null;
-  let _processed = 0;
-  let _failed = 0;
-  let inflight = 0;
   const MAX_CONCURRENT = 16;
-  function insertJob(job) {
-    let i = 0;
-    while (i < pending.length && pending[i].runAt <= job.runAt) i++;
-    pending.splice(i, 0, job);
-  }
-  async function execute(job, handler) {
-    inflight++;
-    try {
-      await handler(job);
-      _processed++;
-    } catch (e) {
-      _failed++;
-      failed.unshift({ ...job, error: e.message, failedAt: Date.now() });
-      if (failed.length > MAX_FAILED) failed.length = MAX_FAILED;
-    } finally {
-      inflight--;
-    }
-    if (job.schedule) {
-      try {
-        insertJob({
-          ...job,
-          id: crypto4.randomUUID(),
-          runAt: cronNext(job.schedule),
-          createdAt: Date.now()
-        });
-      } catch (e) {
-        console.error("[queue] cron re-queue failed:", e.message);
-      }
-    }
-  }
-  async function poll() {
-    if (!running) return;
-    const now = Date.now();
-    while (running && inflight < MAX_CONCURRENT && pending.length > 0 && pending[0].runAt <= now) {
-      const job = pending.shift();
-      const handler = handlers.get(job.type);
-      if (handler) execute(job, handler);
-    }
-    if (running) pollTimer = setTimeout(poll, pollInterval);
-  }
-  const mw = ((req, ctx, next) => {
-    ctx.queue = q;
-    return next(req, ctx);
-  });
-  const q = mw;
-  mw.add = function add(type, payload, opts2) {
-    const id = crypto4.randomUUID();
-    let runAt;
-    if (opts2?.schedule) {
-      try {
-        const f = parsePattern(opts2.schedule);
-        runAt = matches(f, /* @__PURE__ */ new Date()) ? Date.now() : cronNext(opts2.schedule);
-      } catch {
-        runAt = cronNext(opts2.schedule);
-      }
-    } else if (opts2?.delay) {
-      runAt = Date.now() + opts2.delay;
-    } else {
-      runAt = Date.now();
-    }
-    const job = { id, type, payload, createdAt: Date.now(), runAt };
-    if (opts2?.schedule) job.schedule = opts2.schedule;
-    insertJob(job);
-    return Promise.resolve(id);
-  };
-  mw.process = function process2(type, handler) {
-    handlers.set(type, handler);
-  };
-  mw.run = async function run() {
-    if (running) return;
-    running = true;
-    poll();
-  };
-  mw.close = async function close() {
-    running = false;
-    if (pollTimer) {
-      clearTimeout(pollTimer);
-      pollTimer = null;
-    }
-    while (inflight > 0) await new Promise((r) => setTimeout(r, 50));
-  };
-  mw.jobs = async function(limit) {
-    return pending.slice(0, limit ?? 50);
-  };
-  mw.failedJobs = async function failedJobs(limit) {
-    return failed.slice(0, limit ?? 50);
-  };
-  mw.retryFailed = async function retry(jobId) {
-    const idx = failed.findIndex((j) => j.id === jobId);
-    if (idx < 0) return false;
-    const [entry] = failed.splice(idx, 1);
-    _failed--;
-    insertJob({ ...entry, runAt: Date.now() });
-    return true;
-  };
-  mw.retryAllFailed = async function retryAll(type) {
-    let count = 0;
-    for (let i = failed.length - 1; i >= 0; i--) {
-      if (type && failed[i].type !== type) continue;
-      const [entry] = failed.splice(i, 1);
-      _failed--;
-      insertJob({ ...entry, runAt: Date.now() });
-      count++;
-    }
-    return count;
-  };
-  mw.dashboard = function dashboard() {
-    return buildDashboard(q);
-  };
-  mw.stats = () => ({
-    running,
-    inflight,
-    processed: _processed,
-    failed: _failed,
-    handlers: handlers.size,
-    maxConcurrent: MAX_CONCURRENT
-  });
-  attachCron(q, handlers);
-  return q;
-}
-function createPgQueue(opts) {
-  const sql = opts.pg.sql;
-  const pollInterval = opts?.pollInterval ?? 200;
-  const table = (opts?.prefix ?? "queue") + "_jobs";
+  const MAX_FAILED = 1e3;
   const handlers = /* @__PURE__ */ new Map();
   let running = false, pollTimer = null;
-  let _processed = 0, _failed = 0, inflight = 0, ready = false;
-  const MAX_CONCURRENT = 16;
-  const MAX_FAILED = 1e3;
-  async function ensureTable() {
-    if (ready) return;
-    await sql.unsafe(
-      `CREATE TABLE IF NOT EXISTS ${escapeIdent(table)} (id UUID PRIMARY KEY, type TEXT NOT NULL, payload JSONB NOT NULL DEFAULT '{}', run_at TIMESTAMPTZ NOT NULL DEFAULT NOW(), schedule TEXT, status TEXT NOT NULL DEFAULT 'pending', error TEXT, failed_at TIMESTAMPTZ, created_at TIMESTAMPTZ NOT NULL DEFAULT NOW())`
-    );
-    await sql.unsafe(
-      `CREATE INDEX IF NOT EXISTS ${escapeIdent(table + "_run_at_idx")} ON ${escapeIdent(table)} (run_at, status)`
-    );
-    ready = true;
-  }
-  async function processJob(job, handler) {
-    inflight++;
-    try {
-      await handler(job);
-      _processed++;
-      await sql.unsafe(`DELETE FROM ${escapeIdent(table)} WHERE id = $1`, [job.id]);
-    } catch (e) {
-      _failed++;
-      const msg = e.message;
-      console.error("[queue] handler error:", msg);
-      await sql.unsafe(
-        `UPDATE ${escapeIdent(table)} SET status = 'failed', error = $2, failed_at = NOW() WHERE id = $1`,
-        [job.id, msg]
-      );
-    } finally {
-      inflight--;
-    }
-    if (job.schedule) {
-      try {
-        const nextRun = cronNext(job.schedule);
-        await sql.unsafe(
-          `INSERT INTO ${escapeIdent(table)} (id, type, payload, run_at, schedule) VALUES ($1, $2, $3::jsonb, $4, $5)`,
-          [
-            crypto4.randomUUID(),
-            job.type,
-            JSON.stringify(job.payload),
-            new Date(nextRun).toISOString(),
-            job.schedule
-          ]
-        );
-      } catch (e) {
-        console.error("[queue] cron re-queue failed:", e.message);
-      }
+  let _processed = 0, _failed = 0, inflight = 0;
+  async function insert(job, error) {
+    if (error) {
+      await redis2.lpush(failedKey, JSON.stringify({ ...job, error, failedAt: Date.now() }));
+      await redis2.ltrim(failedKey, 0, MAX_FAILED - 1);
+    } else {
+      await redis2.zadd(jobKey, job.runAt, JSON.stringify(job));
     }
   }
   async function poll() {
-    if (!running) return;
+    const result = await redis2.zpopmin(jobKey);
+    if (result.length < 2) return null;
+    const score = parseInt(result[1], 10);
+    if (score > Date.now()) {
+      await redis2.zadd(jobKey, score, result[0]);
+      return null;
+    }
     try {
-      while (running && inflight < MAX_CONCURRENT) {
-        const rows = await sql.unsafe(
-          `UPDATE ${escapeIdent(table)} SET status = 'running' WHERE id = (SELECT id FROM ${escapeIdent(table)} WHERE run_at <= NOW() AND status = 'pending' ORDER BY run_at LIMIT 1 FOR UPDATE SKIP LOCKED) RETURNING *`
-          // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        );
-        if (rows.length === 0) break;
-        const row = rows[0];
-        const job = {
-          id: row.id,
-          type: row.type,
-          payload: typeof row.payload === "string" ? JSON.parse(row.payload) : row.payload,
-          createdAt: new Date(row.created_at).getTime(),
-          runAt: new Date(row.run_at).getTime(),
-          schedule: row.schedule || void 0
-        };
-        const handler = handlers.get(job.type);
-        if (handler) processJob(job, handler);
-      }
-    } catch (e) {
-      const msg = e.message;
-      if (msg.includes("CONNECTION_ENDED") || msg.includes("Connection terminated")) {
-        running = false;
-        return;
-      }
-      console.error("[queue] poll error:", msg);
+      return JSON.parse(result[0]);
+    } catch {
+      return null;
     }
-    if (running) pollTimer = setTimeout(poll, pollInterval);
   }
-  const mw = ((req, ctx, next) => {
-    ctx.queue = q;
-    return next(req, ctx);
-  });
-  const q = mw;
-  mw.add = function add(type, payload, opts2) {
-    return (async () => {
-      const id = crypto4.randomUUID();
-      let runAt;
-      if (opts2?.schedule) {
-        try {
-          const f = parsePattern(opts2.schedule);
-          runAt = matches(f, /* @__PURE__ */ new Date()) ? /* @__PURE__ */ new Date() : new Date(cronNext(opts2.schedule));
-        } catch {
-          runAt = new Date(cronNext(opts2.schedule));
-        }
-      } else if (opts2?.delay) {
-        runAt = new Date(Date.now() + opts2.delay);
-      } else {
-        runAt = /* @__PURE__ */ new Date();
-      }
-      await sql.unsafe(
-        `INSERT INTO ${escapeIdent(table)} (id, type, payload, run_at, schedule) VALUES ($1, $2, $3::jsonb, $4, $5)`,
-        [id, type, JSON.stringify(payload), runAt.toISOString(), opts2?.schedule || null]
-      );
-      return id;
-    })();
-  };
-  mw.process = function process2(type, handler) {
-    handlers.set(type, handler);
-  };
-  mw.migrate = ensureTable;
-  mw.run = async function run() {
-    if (running) return;
-    await ensureTable();
-    running = true;
-    poll();
-  };
-  mw.close = async function close() {
-    running = false;
-    if (pollTimer) {
-      clearTimeout(pollTimer);
-      pollTimer = null;
-    }
-    while (inflight > 0) await new Promise((r) => setTimeout(r, 50));
-  };
-  mw.jobs = async function jobs(limit) {
-    const rows = await sql.unsafe(
-      `SELECT * FROM ${escapeIdent(table)} WHERE status = 'pending' ORDER BY run_at LIMIT $1`,
-      [limit ?? 50]
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    );
-    return rows.map((r) => ({
-      id: r.id,
-      type: r.type,
-      payload: typeof r.payload === "string" ? JSON.parse(r.payload) : r.payload,
-      createdAt: new Date(r.created_at).getTime(),
-      runAt: new Date(r.run_at).getTime(),
-      schedule: r.schedule || void 0
-    }));
-  };
-  mw.failedJobs = async function failedJobs(limit) {
-    const rows = await sql.unsafe(
-      `SELECT * FROM ${escapeIdent(table)} WHERE status = 'failed' ORDER BY failed_at DESC LIMIT $1`,
-      [limit ?? 50]
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    );
-    return rows.map((r) => ({
-      id: r.id,
-      type: r.type,
-      payload: typeof r.payload === "string" ? JSON.parse(r.payload) : r.payload,
-      createdAt: new Date(r.created_at).getTime(),
-      runAt: new Date(r.run_at).getTime(),
-      schedule: r.schedule || void 0,
-      error: r.error || "",
-      failedAt: new Date(r.failed_at).getTime()
-    }));
-  };
-  mw.retryFailed = async function retryFailed(jobId) {
-    const result = await sql.unsafe(
-      `UPDATE ${escapeIdent(table)} SET status = 'pending', error = NULL, failed_at = NULL, run_at = NOW() WHERE id = $1 AND status = 'failed' RETURNING id`,
-      [jobId]
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    );
-    return result.length > 0;
-  };
-  mw.retryAllFailed = async function retryAllFailed(type) {
-    const result = await sql.unsafe(
-      type ? `UPDATE ${escapeIdent(table)} SET status = 'pending', error = NULL, failed_at = NULL, run_at = NOW() WHERE status = 'failed' AND type = $1 RETURNING id` : `UPDATE ${escapeIdent(table)} SET status = 'pending', error = NULL, failed_at = NULL, run_at = NOW() WHERE status = 'failed' RETURNING id`,
-      type ? [type] : []
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    );
-    return result.length;
-  };
-  mw.dashboard = function dashboard() {
-    return buildDashboard(q);
-  };
-  mw.stats = () => ({
-    running,
-    inflight,
-    processed: _processed,
-    failed: _failed,
-    handlers: handlers.size,
-    maxConcurrent: MAX_CONCURRENT
-  });
-  attachCron(q, handlers);
-  return q;
-}
-function createRedisQueue(opts) {
-  const redis2 = opts?.redis ?? new IORedis2(opts?.url ?? process.env.REDIS_URL ?? "redis://localhost:6379");
-  const prefix = opts?.prefix ?? "queue";
-  const pollInterval = opts?.pollInterval ?? 200;
-  const handlers = /* @__PURE__ */ new Map();
-  let running = false, pollTimer = null, epoch = 0;
-  let _processed = 0, _failed = 0, inflight = 0;
-  const jobKey = prefix + ":jobs", failedKey = prefix + ":failed", MAX_FAILED = 1e3, MAX_CONCURRENT = 16;
-  async function processJob(job, handler) {
+  async function execute(job, handler) {
     inflight++;
     try {
       await handler(job);
       _processed++;
     } catch (e) {
       _failed++;
-      const msg = e.message;
-      console.error("[queue] handler error:", msg);
-      await redis2.lpush(failedKey, JSON.stringify({ ...job, error: msg, failedAt: Date.now() }));
-      await redis2.ltrim(failedKey, 0, MAX_FAILED - 1);
+      await insert(job, e.message);
     } finally {
       inflight--;
     }
     if (job.schedule) {
       try {
-        const nextRun = cronNext(job.schedule);
-        await redis2.zadd(
-          jobKey,
-          nextRun,
-          JSON.stringify({
-            ...job,
-            id: crypto4.randomUUID(),
-            runAt: nextRun,
-            createdAt: Date.now()
-          })
-        );
-      } catch (e) {
-        console.error("[queue] cron re-queue failed:", e.message);
+        await insert({ ...job, id: crypto2.randomUUID(), runAt: cronNext(job.schedule), createdAt: Date.now() });
+      } catch {
       }
     }
   }
-  async function poll() {
-    const currentEpoch = epoch;
+  async function pollLoop() {
     if (!running) return;
     try {
-      const now = Date.now();
       while (running && inflight < MAX_CONCURRENT) {
-        const result = await redis2.zpopmin(jobKey);
-        if (result.length < 2) break;
-        const raw2 = result[0], score = parseInt(result[1], 10);
-        if (score > now) {
-          await redis2.zadd(jobKey, score, raw2);
-          break;
-        }
-        let job;
-        try {
-          job = JSON.parse(raw2);
-        } catch {
-          continue;
-        }
+        const job = await poll();
+        if (!job) break;
         const handler = handlers.get(job.type);
-        if (handler) processJob(job, handler);
+        if (handler) execute(job, handler);
       }
-    } catch (e) {
-      console.error("[queue] poll error:", e.message);
+    } catch {
     }
-    if (running && currentEpoch === epoch) pollTimer = setTimeout(poll, pollInterval);
+    if (running) pollTimer = setTimeout(pollLoop, pollInterval);
   }
-  const mw = ((req, ctx, next) => {
+  const stats = () => ({ running, inflight, processed: _processed, failed: _failed, handlers: handlers.size, maxConcurrent: MAX_CONCURRENT });
+  const mw = ((_req, ctx, next) => {
+    ;
     ctx.queue = q;
-    return next(req, ctx);
+    return next(_req, ctx);
   });
   const q = mw;
   mw.add = function add(type, payload, opts2) {
-    const id = crypto4.randomUUID();
+    const id = crypto2.randomUUID();
     let runAt;
     if (opts2?.schedule) {
-      runAt = cronNext(opts2.schedule);
+      try {
+        runAt = matches(parsePattern(opts2.schedule), /* @__PURE__ */ new Date()) ? Date.now() : cronNext(opts2.schedule);
+      } catch {
+        runAt = cronNext(opts2.schedule);
+      }
     } else if (opts2?.delay) {
       runAt = Date.now() + opts2.delay;
     } else {
@@ -2931,11 +1773,10 @@ function createRedisQueue(opts) {
   mw.run = async function run() {
     if (running) return;
     running = true;
-    poll();
+    pollLoop();
   };
   mw.close = async function close() {
     running = false;
-    epoch++;
     if (pollTimer) {
       clearTimeout(pollTimer);
       pollTimer = null;
@@ -2943,9 +1784,9 @@ function createRedisQueue(opts) {
     while (inflight > 0) await new Promise((r) => setTimeout(r, 50));
     redis2.disconnect();
   };
-  mw.jobs = async function jobs(limit) {
-    const raw2 = await redis2.zrevrange(jobKey, 0, (limit ?? 50) - 1);
-    return raw2.map((r) => {
+  mw.jobs = async (limit = 50) => {
+    const raw = await redis2.zrevrange(jobKey, 0, limit - 1);
+    return raw.map((r) => {
       try {
         return JSON.parse(r);
       } catch {
@@ -2953,9 +1794,9 @@ function createRedisQueue(opts) {
       }
     }).filter(Boolean);
   };
-  mw.failedJobs = async function failedJobs(limit) {
-    const raw2 = await redis2.lrange(failedKey, 0, (limit ?? 50) - 1);
-    return raw2.map((r) => {
+  mw.failedJobs = async (limit = 50) => {
+    const raw = await redis2.lrange(failedKey, 0, limit - 1);
+    return raw.map((r) => {
       try {
         return JSON.parse(r);
       } catch {
@@ -2963,29 +1804,28 @@ function createRedisQueue(opts) {
       }
     }).filter(Boolean);
   };
-  mw.retryFailed = async function retryFailed(jobId) {
-    const raw2 = await redis2.lrange(failedKey, 0, -1);
-    for (const entry of raw2) {
+  mw.retryFailed = async (jobId) => {
+    const raw = await redis2.lrange(failedKey, 0, -1);
+    for (const entry of raw) {
       try {
         const job = JSON.parse(entry);
-        if (job.id === jobId) {
-          await redis2.lrem(failedKey, 1, entry);
-          const reJob = { ...job, runAt: Date.now() };
-          delete reJob.error;
-          delete reJob.failedAt;
-          await redis2.zadd(jobKey, reJob.runAt, JSON.stringify(reJob));
-          _failed--;
-          return true;
-        }
+        if (job.id !== jobId) continue;
+        await redis2.lrem(failedKey, 1, entry);
+        const reJob = { ...job, runAt: Date.now() };
+        delete reJob.error;
+        delete reJob.failedAt;
+        await redis2.zadd(jobKey, reJob.runAt, JSON.stringify(reJob));
+        _failed--;
+        return true;
       } catch {
       }
     }
     return false;
   };
-  mw.retryAllFailed = async function retryAllFailed(type) {
+  mw.retryAllFailed = async (type) => {
     let count = 0;
-    const raw2 = await redis2.lrange(failedKey, 0, -1);
-    for (const entry of raw2) {
+    const raw = await redis2.lrange(failedKey, 0, -1);
+    for (const entry of raw) {
       try {
         const job = JSON.parse(entry);
         if (type && job.type !== type) continue;
@@ -3001,387 +1841,63 @@ function createRedisQueue(opts) {
     }
     return count;
   };
-  mw.dashboard = function dashboard() {
-    return buildDashboard(q);
-  };
-  mw.stats = () => ({
-    running,
-    inflight,
-    processed: _processed,
-    failed: _failed,
-    handlers: handlers.size,
-    maxConcurrent: MAX_CONCURRENT
-  });
-  attachCron(q, handlers);
-  return q;
-}
-function buildDashboard(q) {
-  const r = new Router();
-  r.get("/", async () => {
-    const s = q.stats();
-    const pending = await q.jobs(100);
-    const byType = {};
-    for (const j of pending) {
-      if (!byType[j.type]) byType[j.type] = { pending: 0, failed: 0 };
-      byType[j.type].pending++;
-    }
-    const failed = await q.failedJobs(1e3);
-    for (const j of failed) {
-      if (!byType[j.type]) byType[j.type] = { pending: 0, failed: 0 };
-      byType[j.type].failed++;
-    }
-    return Response.json({ stats: s, types: byType, failedCount: failed.length });
-  });
-  r.get("/:type/failed", async (req, ctx) => {
-    const failed = await q.failedJobs(100);
-    return Response.json({ jobs: failed.filter((j) => j.type === ctx.params.type) });
-  });
-  r.post("/:type/retry", async (req, ctx) => {
-    return Response.json({ retried: await q.retryAllFailed(ctx.params.type) });
-  });
-  r.post("/retry/:id", async (req, ctx) => {
-    const ok = await q.retryFailed(ctx.params.id);
-    if (!ok) return new Response("Not found", { status: 404 });
-    return Response.json({ ok: true });
-  });
-  return r;
-}
-
-// src/middleware/health.ts
-function health(options) {
-  const path = options?.path ?? "/__health";
-  const r = new Router();
-  const handler = async () => {
-    try {
-      await options?.check?.();
-      return new Response("OK", { status: 200 });
-    } catch {
-      return new Response("Service Unavailable", { status: 503 });
-    }
-  };
-  r.get(path, handler);
-  r.head(path, handler);
-  return r;
-}
-
-// src/core/html.ts
-var ESCAPE = {
-  "&": "&amp;",
-  "<": "&lt;",
-  ">": "&gt;",
-  '"': "&quot;",
-  "'": "&#39;"
-};
-function esc(s) {
-  return s.replace(/[&<>"']/g, (c) => ESCAPE[c] ?? c);
-}
-function html(strings, ...values) {
-  let result = "";
-  for (let i = 0; i < strings.length; i++) {
-    result += strings[i];
-    if (i < values.length) {
-      const v = values[i];
-      if (v == null || v === false) continue;
-      if (Array.isArray(v)) {
-        result += v.join("");
-      } else if (typeof v === "object" && v !== null && "_raw" in v) {
-        result += v._raw;
-      } else {
-        result += esc(String(v));
-      }
-    }
-  }
-  return result;
-}
-function raw(content) {
-  return { _raw: content };
-}
-
-// src/middleware/theme.ts
-function makeSetTheme(cookie, location) {
-  return (value, loc) => {
-    const finalLoc = loc ?? location;
-    const c = `${cookie}=${encodeURIComponent(value)}; Path=/; SameSite=Lax`;
-    return new Response(null, { status: 302, headers: { Location: finalLoc, "Set-Cookie": c } });
-  };
-}
-function theme(options) {
-  const opts = { default: "system", cookie: "theme", ...options };
-  const mw = async (req, ctx, next) => {
-    let themeValue = opts.default;
-    if (opts.cookie) {
-      const fromCookie = getCookies(req)[opts.cookie];
-      if (fromCookie) themeValue = fromCookie;
-    }
-    ;
-    ctx.theme = {
-      value: themeValue,
-      set: makeSetTheme(opts.cookie, req.headers.get("referer") || "/")
-    };
-    return next(req, ctx);
-  };
-  mw.__meta = { injects: ["theme"], depends: [] };
-  class ThemeRouter extends Router {
-    middleware() {
-      return mw;
-    }
-  }
-  const router = new ThemeRouter();
-  router.get("/__theme/:value", (req) => {
-    const url = new URL(req.url);
-    const value = url.pathname.split("/__theme/")[1] ?? "";
-    const cookie = `${opts.cookie}=${encodeURIComponent(value)}; Path=/; SameSite=Lax`;
-    const accept = req.headers.get("accept") ?? "";
-    if (accept.includes("application/json")) {
-      return Response.json({ ok: true, theme: value }, { headers: { "Set-Cookie": cookie } });
-    }
-    const referer = req.headers.get("referer") || "/";
-    return new Response(null, { status: 302, headers: { Location: referer, "Set-Cookie": cookie } });
-  });
-  return router;
-}
-
-// src/middleware/i18n.ts
-import { readFile, stat } from "node:fs/promises";
-import { join as join2, resolve as resolve3 } from "node:path";
-var DEFAULTS2 = {
-  default: "en",
-  cookie: "locale",
-  fromAcceptLanguage: true
-};
-function translate(msgs, key, params, fallback) {
-  const msg = key.split(".").reduce((o, k) => o?.[k], msgs);
-  if (msg === void 0 || msg === null) return fallback ?? key;
-  if (!params) return String(msg);
-  let result = String(msg);
-  for (const [k, v] of Object.entries(params)) {
-    result = result.replace(`{${k}}`, v);
-  }
-  return result;
-}
-function i18n(options) {
-  const opts = { ...DEFAULTS2, ...options };
-  const dir = opts.dir ? resolve3(opts.dir) : void 0;
-  const cache = /* @__PURE__ */ new Map();
-  function validLocale(locale) {
-    return /^[\w-]+$/.test(locale) && !locale.includes("..");
-  }
-  async function loadMessages(locale) {
-    if (opts.messages?.[locale] && Object.keys(opts.messages[locale]).length > 0) {
-      cache.set(locale, opts.messages[locale]);
-      return opts.messages[locale];
-    }
-    if (!dir || !validLocale(locale)) return {};
-    const cached = cache.get(locale);
-    if (cached) return cached;
-    const filePath = join2(dir, `${locale}.json`);
-    try {
-      await stat(filePath);
-      const content = await readFile(filePath, "utf-8");
-      const data = JSON.parse(content);
-      cache.set(locale, data);
-      return data;
-    } catch {
-    }
-    const short = locale.split("-")[0];
-    if (short !== locale) {
-      const fallback = cache.get(short) || await loadMessages(short);
-      if (fallback && Object.keys(fallback).length > 0) {
-        cache.set(locale, fallback);
-        return fallback;
-      }
-    }
-    return {};
-  }
-  function detectLocale(req) {
-    if (opts.cookie) {
-      const fromCookie = getCookies(req)[opts.cookie];
-      if (fromCookie && validLocale(fromCookie)) return fromCookie;
-    }
-    if (opts.fromAcceptLanguage) {
-      const fromHeader = req.headers.get("Accept-Language")?.split(",")[0]?.trim();
-      if (fromHeader && validLocale(fromHeader)) return fromHeader;
-    }
-    return opts.default;
-  }
-  const mw = async (req, ctx, next) => {
-    const locale = detectLocale(req);
-    const msgs = await loadMessages(locale);
-    ctx.i18n = {
-      locale,
-      messages: msgs,
-      t: (key, params, fallback) => translate(msgs, key, params, fallback),
-      set: (value, loc) => {
-        const cookie = `${opts.cookie}=${encodeURIComponent(value)}; Path=/; SameSite=Lax`;
-        const location = loc ?? (req.headers.get("referer") || "/");
-        return new Response(null, {
-          status: 302,
-          headers: { Location: location, "Set-Cookie": cookie }
-        });
-      }
-    };
-    return next(req, ctx);
-  };
-  mw.__meta = { injects: ["i18n"], depends: [] };
-  class I18nRouter extends Router {
-    middleware() {
-      return mw;
-    }
-  }
-  const router = new I18nRouter();
-  router.get("/__lang/:locale", async (req) => {
-    const url = new URL(req.url);
-    const value = url.pathname.split("/__lang/")[1] ?? "";
-    const cookie = `${opts.cookie}=${encodeURIComponent(value)}; Path=/; SameSite=Lax`;
-    const messages = await loadMessages(value);
-    const accept = req.headers.get("accept") ?? "";
-    if (accept.includes("application/json")) {
-      return Response.json(
-        {
-          ok: true,
-          locale: value,
-          messages: Object.keys(messages).length > 0 ? messages : void 0
-        },
-        { headers: { "Set-Cookie": cookie } }
-      );
-    }
-    const referer = req.headers.get("referer") || "/";
-    return new Response(null, { status: 302, headers: { Location: referer, "Set-Cookie": cookie } });
-  });
-  return router;
-}
-
-// src/middleware/flash.ts
-function makeSetFlash(name, location) {
-  return (data, loc) => {
-    const finalLoc = loc ?? location;
-    const value = encodeURIComponent(JSON.stringify(data));
-    return new Response(null, {
-      status: 302,
-      headers: {
-        Location: finalLoc,
-        "Set-Cookie": `${name}=${value}; Path=/; SameSite=Lax`
-      }
+  mw.stats = stats;
+  mw.dashboard = () => {
+    const r = new Router();
+    r.get("/", async () => {
+      const s = stats();
+      const pending = await mw.jobs(100);
+      const byType = {};
+      for (const j of pending) {
+        byType[j.type] = byType[j.type] || { pending: 0, failed: 0 };
+        byType[j.type].pending++;
+      }
+      const failed = await mw.failedJobs(1e3);
+      for (const j of failed) {
+        byType[j.type] = byType[j.type] || { pending: 0, failed: 0 };
+        byType[j.type].failed++;
+      }
+      return Response.json({ stats: s, types: byType, failedCount: failed.length });
     });
+    r.get("/:type/failed", async (req, ctx) => Response.json({ jobs: (await mw.failedJobs(100)).filter((j) => j.type === ctx.params.type) }));
+    r.post("/:type/retry", async (req, ctx) => Response.json({ retried: await mw.retryAllFailed(ctx.params.type) }));
+    r.post("/retry/:id", async (req, ctx) => {
+      const ok = await mw.retryFailed(ctx.params.id);
+      return ok ? Response.json({ ok: true }) : new Response("Not found", { status: 404 });
+    });
+    return r;
   };
-}
-function flash(options) {
-  const name = options?.name ?? "flash";
-  const mw = async (req, ctx, next) => {
-    const raw2 = getCookies(req)[name] ?? null;
-    const referer = req.headers.get("referer") || "/";
-    let value = void 0;
-    if (raw2) {
-      try {
-        value = JSON.parse(decodeURIComponent(raw2));
-      } catch {
-        value = raw2;
-      }
-    }
-    ctx.flash = {
-      value,
-      set: makeSetFlash(name, referer)
-    };
-    const res = await next(req, ctx);
-    if (raw2) {
-      const headers = new Headers(res.headers);
-      headers.append("Set-Cookie", `${name}=; Path=/; Max-Age=0`);
-      return new Response(res.body, { status: res.status, statusText: res.statusText, headers });
-    }
-    return res;
-  };
-  mw.__meta = { injects: ["flash"], depends: [] };
-  return mw;
-}
-
-// src/middleware/csrf.ts
-function csrf(options) {
-  const cookieName = options?.cookie ?? "_csrf";
-  const headerName = options?.header ?? "x-csrf-token";
-  const bodyKey = options?.key ?? "_csrf";
-  const excluded = new Set(options?.excludeMethods ?? ["GET", "HEAD", "OPTIONS"]);
-  const mw = async (req, ctx, next) => {
-    const method = req.method.toUpperCase();
-    if (excluded.has(method)) {
-      const token = getCookies(req)[cookieName] || crypto.randomUUID();
-      ctx.csrf = { token };
-      const res = await next(req, ctx);
-      const tokenToSet = ctx.csrf?.token;
-      if (tokenToSet && !getCookies(req)[cookieName]) {
-        return setCookie(res, cookieName, tokenToSet, {
-          httpOnly: true,
-          sameSite: "strict",
-          path: "/"
-        });
-      }
-      return res;
-    }
-    const cookieToken = getCookies(req)[cookieName];
-    let headerToken = req.headers.get(headerName) ?? "";
-    if (!headerToken && (req.method === "POST" || req.method === "PUT" || req.method === "PATCH" || req.method === "DELETE")) {
-      try {
-        const body = await req.clone().json();
-        headerToken = body[bodyKey] ?? "";
-      } catch {
-        return new Response("Invalid request body", { status: 400 });
-      }
-    }
-    if (!cookieToken || !headerToken || cookieToken !== headerToken) {
-      return new Response("CSRF token mismatch", { status: 403 });
-    }
-    return next(req, ctx);
+  q.cron = function(pattern, handler) {
+    const id = "__cron_" + pattern.replace(/[^a-zA-Z0-9]/g, "_") + "_" + crypto2.randomUUID().slice(0, 8);
+    q.process(id, async () => {
+      await handler();
+    });
+    q.add(id, {}, { schedule: pattern });
+    return { stop: () => handlers.delete(id) };
   };
-  mw.__meta = { injects: ["csrf"], depends: [] };
-  return mw;
+  return q;
 }
 export {
   DEFAULT_MAX_BODY,
   HttpError,
   MIGRATIONS_TABLE,
   Router,
-  TestApp,
-  TestRequest,
   compress,
   cors,
   createHub,
-  createSSEStream,
-  createTestDb,
-  createTestServer,
-  csrf,
   currentTrace,
   currentTraceId,
-  deleteCookie,
-  env,
-  flash,
-  formatSSE,
-  formatSSEData,
-  getCookies,
-  getPublicEnv,
   graphql,
-  health,
   helmet,
-  html,
-  i18n,
-  isBundled,
-  isDev,
-  isProd,
-  loadEnv,
   logger,
   postgres,
   queue,
   rateLimit,
-  raw,
   redis,
-  requestId,
   runWithTrace,
   serve,
   serveStatic,
-  setCookie,
-  testApp,
-  theme,
   trace,
   traceElapsed,
-  upload,
-  validate,
-  withTestDb
+  upload
 };