weifuwu 0.4.0 → 0.5.1

package/dist/index.js

@@ -107,1896 +107,2122 @@ function serve(handler, options) {
 
 // router.ts
 import { WebSocketServer } from "ws";
-import { buildSchema, graphql } from "graphql";
-import { makeExecutableSchema } from "@graphql-tools/schema";
-import { streamText } from "ai";
-
-// workflow/tool.ts
-function tool(def) {
-  return {
-    name: def.name ?? "",
-    description: def.description,
-    inputSchema: def.inputSchema,
-    execute: def.execute
-  };
-}
-
-// workflow/reference.ts
-function getByPath(obj, path) {
-  let current = obj;
-  for (const key of path) {
-    if (current === null || current === void 0) return void 0;
-    if (typeof current === "object" && key in current) {
-      current = current[key];
-    } else {
-      return void 0;
+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);
     }
-  }
-  return current;
-}
-function resolveRef(path, ctx) {
-  if (path.startsWith("$nodes.")) {
-    const afterNodes = path.slice(7);
-    const dotIdx = afterNodes.indexOf(".");
-    if (dotIdx === -1) {
-      return ctx.nodeOutputs.get(afterNodes);
+    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)}"`
+      );
     }
-    const id2 = afterNodes.slice(0, dotIdx);
-    const propPath = afterNodes.slice(dotIdx + 1);
-    const output = ctx.nodeOutputs.get(id2);
-    if (output === void 0) {
-      throw new Error(`Node "${id2}" has no output yet`);
+    return child;
+  }
+  if (!node.children.has(segment)) {
+    node.children.set(segment, createTrieNode());
+  }
+  return node.children.get(segment);
+};
+var matchTrieNode = (node, segment, params) => {
+  if (node.children.has(segment)) return node.children.get(segment);
+  if (node.children.has(":")) {
+    const child = node.children.get(":");
+    if (child.param) params[child.param] = segment;
+    return child;
+  }
+  return null;
+};
+var getWsNode = (node, segment) => {
+  if (segment.startsWith(":")) {
+    if (!node.children.has(":")) {
+      const child2 = createWsNode();
+      child2.param = segment.slice(1);
+      node.children.set(":", child2);
     }
-    if (propPath.startsWith("output")) {
-      return getByPath(output, propPath.slice(7).split(".").filter(Boolean));
+    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 getByPath(output, propPath.split("."));
+    return child;
   }
-  if (path.startsWith("$var.")) {
-    const name = path.slice(5);
-    if (!ctx.variables.has(name)) {
-      throw new Error(`Variable "${name}" is not defined`);
+  if (!node.children.has(segment)) {
+    node.children.set(segment, createWsNode());
+  }
+  return node.children.get(segment);
+};
+var matchWsNode = (node, segment, params) => {
+  if (node.children.has(segment)) return node.children.get(segment);
+  if (node.children.has(":")) {
+    const child = node.children.get(":");
+    if (child.param) params[child.param] = segment;
+    return child;
+  }
+  return null;
+};
+var Router = class _Router {
+  root = createTrieNode();
+  wsRoot = createWsNode();
+  globalMws = [];
+  errorHandler;
+  use(arg1, arg2) {
+    if (typeof arg1 === "string") {
+      if (arg2 instanceof _Router) {
+        let node = this.root;
+        for (const segment of this.splitPath(arg1)) {
+          node = getTrieNode(node, segment);
+        }
+        node.subRouter = arg2;
+      } else if (typeof arg2 === "function") {
+        let node = this.root;
+        for (const segment of this.splitPath(arg1)) {
+          node = getTrieNode(node, segment);
+        }
+        node.pathMws.push(arg2);
+      }
+    } else if (typeof arg1 === "function") {
+      this.globalMws.push(arg1);
     }
-    return ctx.variables.get(name);
+    return this;
   }
-  if (path.startsWith("$input.")) {
-    const key = path.slice(7);
-    return ctx.input[key];
+  get(path, ...args) {
+    return this.route("GET", path, ...args);
   }
-  if (path === "true") return true;
-  if (path === "false") return false;
-  if (path === "null") return null;
-  const num = Number(path);
-  if (!isNaN(num) && path.trim() !== "") return num;
-  return path;
-}
-function resolveValue(v, ctx) {
-  if (typeof v === "string" && v.startsWith("$")) {
-    return resolveRef(v, ctx);
+  post(path, ...args) {
+    return this.route("POST", path, ...args);
   }
-  if (Array.isArray(v)) {
-    return v.map((item) => resolveValue(item, ctx));
+  put(path, ...args) {
+    return this.route("PUT", path, ...args);
   }
-  if (typeof v === "object" && v !== null) {
-    const result = {};
-    for (const [k, val] of Object.entries(v)) {
-      result[k] = resolveValue(val, ctx);
-    }
-    return result;
+  delete(path, ...args) {
+    return this.route("DELETE", path, ...args);
   }
-  return v;
-}
-
-// workflow/nodes.ts
-function evaluateExpression(expr, ctx) {
-  const operators = [
-    { op: "===", fn: (a, b) => a === b },
-    { op: "!==", fn: (a, b) => a !== b },
-    { op: ">=", fn: (a, b) => Number(a) >= Number(b) },
-    { op: "<=", fn: (a, b) => Number(a) <= Number(b) },
-    { op: ">", fn: (a, b) => Number(a) > Number(b) },
-    { op: "<", fn: (a, b) => Number(a) < Number(b) },
-    { op: "==", fn: (a, b) => a == b },
-    { op: "!=", fn: (a, b) => a != b },
-    { op: "+", fn: (a, b) => Number(a) + Number(b) },
-    { op: "-", fn: (a, b) => Number(a) - Number(b) },
-    { op: "*", fn: (a, b) => Number(a) * Number(b) },
-    { op: "/", fn: (a, b) => Number(a) / Number(b) },
-    { op: "%", fn: (a, b) => Number(a) % Number(b) },
-    { op: "&&", fn: (a, b) => Boolean(a) && Boolean(b) },
-    { op: "||", fn: (a, b) => Boolean(a) || Boolean(b) }
-  ];
-  for (const { op, fn } of operators) {
-    const idx = expr.indexOf(op);
-    if (idx > 0) {
-      const leftRaw = expr.slice(0, idx).trim();
-      const rightRaw = expr.slice(idx + op.length).trim();
-      const left = resolveValue(leftRaw, ctx);
-      const right = resolveValue(rightRaw, ctx);
-      return fn(left, right);
-    }
+  patch(path, ...args) {
+    return this.route("PATCH", path, ...args);
   }
-  const trimmed = expr.trim();
-  if (trimmed === "true") return true;
-  if (trimmed === "false") return false;
-  if (trimmed === "null") return null;
-  const num = Number(trimmed);
-  if (!isNaN(num) && trimmed !== "") return num;
-  return resolveValue(expr, ctx);
-}
-async function executeEval(node, ctx) {
-  const expression = node.input.expression;
-  if (!expression) throw new Error('eval node requires "expression" field');
-  const result = evaluateExpression(expression, ctx);
-  return { result };
-}
-async function executeSet(node, ctx) {
-  const name = node.input.name;
-  const value = node.input.value;
-  if (!name) throw new Error('set node requires "name" field');
-  let resolved;
-  if (typeof value === "string") {
-    resolved = evaluateExpression(value, ctx);
-  } else {
-    resolved = resolveValue(value ?? null, ctx);
+  head(path, ...args) {
+    return this.route("HEAD", path, ...args);
   }
-  ctx.variables.set(name, resolved);
-  return resolved;
-}
-async function executeGet(node, ctx) {
-  const name = node.input.name;
-  if (!name) throw new Error('get node requires "name" field');
-  if (!ctx.variables.has(name)) {
-    throw new Error(`Variable "${name}" is not defined`);
+  options(path, ...args) {
+    return this.route("OPTIONS", path, ...args);
   }
-  return ctx.variables.get(name);
-}
-async function executeIf(node, ctx) {
-  const conditions = node.conditions ?? [];
-  for (const condition of conditions) {
-    const test = typeof condition.test === "string" ? Boolean(resolveValue(condition.test, ctx)) : condition.test;
-    if (test && condition.body) {
-      let lastOutput = void 0;
-      for (const bodyNode of condition.body) {
-        lastOutput = await executeNode(bodyNode, ctx);
-      }
-      return lastOutput;
-    }
+  all(path, ...args) {
+    return this.route("*", path, ...args);
   }
-  return void 0;
-}
-async function executeWhile(node, ctx) {
-  const conditionExpr = node.input.condition;
-  if (!conditionExpr) throw new Error('while node requires "condition" field');
-  let lastOutput = void 0;
-  let iterations = 0;
-  const maxIterations = 1e3;
-  while (iterations < maxIterations) {
-    iterations++;
-    ctx.stepCount++;
-    if (ctx.stepCount > ctx.maxSteps) {
-      throw new Error(`Step limit exceeded (${ctx.maxSteps})`);
-    }
-    const condition = Boolean(evaluateExpression(conditionExpr, ctx));
-    if (!condition) break;
-    for (const bodyNode of node.body ?? []) {
-      lastOutput = await executeNode(bodyNode, ctx);
+  onError(handler) {
+    this.errorHandler = handler;
+    return this;
+  }
+  route(method, path, ...args) {
+    const handler = args.pop();
+    const middlewares = args;
+    const segments = this.splitPath(path);
+    let node = this.root;
+    for (const segment of segments) {
+      if (segment === "*") {
+        node.wildcard = true;
+        node.handlers.set(method, handler);
+        if (middlewares.length > 0) node.middlewares.set(method, middlewares);
+        return this;
+      }
+      node = getTrieNode(node, segment);
     }
+    node.handlers.set(method, handler);
+    if (middlewares.length > 0) node.middlewares.set(method, middlewares);
+    return this;
   }
-  return lastOutput;
-}
-async function executeCall(node, ctx) {
-  const toolName = node.input.tool;
-  const args = node.input.args ?? {};
-  if (toolName && ctx.toolRegistry.has(toolName)) {
-    const tool3 = ctx.toolRegistry.get(toolName);
-    const resolvedInput = resolveValue(args, ctx);
-    const parsed = tool3.inputSchema.parse(resolvedInput);
-    return tool3.execute(parsed, {
-      nodeId: node.id,
-      workflowId: ctx.workflowId,
-      onStream: async (event) => {
-        if (ctx.sseManager && ctx.workflowId) {
-          ctx.sseManager.send(ctx.workflowId, { event: "llm-stream", data: { nodeId: node.id, ...event } });
+  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 wss = new WebSocketServer({ noServer: true });
+    const wsRoot = this.wsRoot;
+    const router = this;
+    return (req, socket, head) => {
+      const url = new URL(req.url ?? "/", "http://localhost");
+      const segments = url.pathname.split("/").filter(Boolean);
+      const query = Object.fromEntries(url.searchParams);
+      const match = router.matchWsTrie(wsRoot, segments);
+      if (!match) {
+        socket.destroy();
+        return;
+      }
+      const webReq = new Request(url.href, {
+        method: req.method ?? "GET",
+        headers: Object.fromEntries(
+          Object.entries(req.headers).map(([k, v]) => [k, Array.isArray(v) ? v.join(", ") : v ?? ""])
+        )
+      });
+      const ctx = { params: match.params, query };
+      if (match.middlewares.length === 0) {
+        upgradeSocket(wss, req, socket, head, match.handler, ctx);
+        return;
+      }
+      let index = 0;
+      const dispatch = async (innerReq, ctx2) => {
+        if (index < match.middlewares.length) {
+          const mw = match.middlewares[index++];
+          return mw(innerReq, ctx2, dispatch);
+        }
+        return await new Promise((resolve3) => {
+          upgradeSocket(wss, req, socket, head, match.handler, ctx2);
+          resolve3(new Response(null, { status: 101 }));
+        });
+      };
+      Promise.resolve(dispatch(webReq, ctx)).then((result) => {
+        if (result.status !== 101) {
+          sendHttpResponseOnSocket(socket, result);
+        }
+      }).catch(() => {
+        socket.destroy();
+      });
+    };
+  }
+  splitPath(path) {
+    return path.split("/").filter(Boolean);
+  }
+  matchTrie(method, segments) {
+    let node = this.root;
+    const params = {};
+    const pathMws = [...this.root.pathMws];
+    let wildcardHandler = null;
+    let wildcardMws = [];
+    let wildcardIdx = -1;
+    for (let i = 0; i < segments.length; i++) {
+      pathMws.push(...node.pathMws);
+      if (node.wildcard) {
+        const h = node.handlers.get("*") || 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 (node.subRouter) {
+          return {
+            pathMws,
+            params,
+            middlewares: [],
+            subRouter: { router: node.subRouter, remainingIdx: i }
+          };
+        }
+        if (wildcardHandler) {
+          params["*"] = segments.slice(wildcardIdx).join("/");
+          return { handler: wildcardHandler, middlewares: wildcardMws, pathMws, params };
+        }
+        return null;
+      }
+      node = next;
+    }
+    if (node.subRouter) {
+      return {
+        pathMws,
+        params,
+        middlewares: [],
+        subRouter: { router: node.subRouter, remainingIdx: segments.length }
+      };
+    }
+    pathMws.push(...node.pathMws);
+    const handler = node.handlers.get(method) || node.handlers.get("*");
+    if (handler) {
+      if (node.wildcard) params["*"] = segments.slice(segments.length).join("/");
+      return {
+        handler,
+        middlewares: node.middlewares.get(method) || node.middlewares.get("*") || [],
+        pathMws,
+        params
+      };
+    }
+    if (wildcardHandler) {
+      params["*"] = segments.slice(wildcardIdx).join("/");
+      return { handler: wildcardHandler, middlewares: wildcardMws, pathMws, params };
+    }
+    return null;
   }
-  const functionName = node.input.function;
-  if (functionName && ctx.functions[functionName]) {
-    const fn = ctx.functions[functionName];
-    const prevFunctions = ctx.functions;
-    const prevInput = ctx.input;
-    ctx.input = resolveValue(args, ctx);
-    let lastOutput = void 0;
-    for (const bodyNode of fn.workflow.nodes) {
-      lastOutput = await executeNode(bodyNode, ctx);
+  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;
     }
-    ctx.input = prevInput;
-    return lastOutput;
+    return node.handler ? { handler: node.handler, middlewares: node.middlewares, params } : null;
   }
-  throw new Error(`call node: tool "${toolName ?? functionName}" not found`);
-}
-async function executeHttp(node, ctx) {
-  const input = resolveValue(node.input, ctx);
-  const url = input.url;
-  if (!url) throw new Error('http node requires "url" field');
-  const controller = new AbortController();
-  const timeout = input.timeout ?? 3e4;
-  const timer = setTimeout(() => controller.abort(), timeout);
-  try {
-    const fetchInit = {
-      method: input.method ?? "GET",
-      headers: input.headers ?? {},
-      signal: controller.signal
-    };
-    if (input.body && fetchInit.method !== "GET") {
-      fetchInit.body = JSON.stringify(input.body);
+  async handle(req, ctx, segments, query) {
+    const match = this.matchTrie(req.method, segments);
+    if (match?.subRouter) {
+      const { router: sub, remainingIdx } = match.subRouter;
+      const remainingSegments = segments.slice(remainingIdx);
+      const delegate = (req2, ctx2) => sub.handle(req2, ctx2, remainingSegments, query);
+      const allMws = this.globalMws.length + match.pathMws.length === 0 ? [] : [...this.globalMws, ...match.pathMws];
+      try {
+        return await this.runChain(allMws, delegate, req, { ...ctx, params: { ...ctx.params, ...match.params } });
+      } catch (e) {
+        return this.errorHandler ? this.errorHandler(e, req, ctx) : new Response("Internal Server Error", { status: 500 });
+      }
     }
-    const response = await fetch(url, fetchInit);
-    const contentType = response.headers.get("content-type") ?? "";
-    const body = contentType.includes("application/json") ? await response.json() : await response.text();
-    return {
-      status: response.status,
-      statusText: response.statusText,
-      headers: Object.fromEntries(response.headers.entries()),
-      body
+    if (match?.handler) {
+      const { handler, middlewares: routeMws, pathMws, params } = match;
+      const allMws = this.globalMws.length + pathMws.length + routeMws.length === 0 ? [] : [...this.globalMws, ...pathMws, ...routeMws];
+      const ctxWithMatch = { ...ctx, params: { ...ctx.params, ...params } };
+      try {
+        return await this.runChain(allMws, handler, req, ctxWithMatch);
+      } catch (e) {
+        return this.errorHandler ? this.errorHandler(e, req, ctxWithMatch) : new Response("Internal Server Error", { status: 500 });
+      }
+    }
+    if (this.globalMws.length > 0) {
+      try {
+        const delegate = () => new Response("Not Found", { status: 404 });
+        return await this.runChain(this.globalMws, delegate, req, ctx);
+      } catch (e) {
+        return this.errorHandler ? this.errorHandler(e, req, ctx) : new Response("Internal Server Error", { status: 500 });
+      }
+    }
+    return new Response("Not Found", { status: 404 });
+  }
+  async runChain(middlewares, finalHandler, req, ctx) {
+    let index = 0;
+    const dispatch = async (req2, ctx2) => {
+      if (index < middlewares.length) {
+        const mw = middlewares[index++];
+        return mw ? await mw(req2, ctx2, dispatch) : new Response("Middleware error", { status: 500 });
+      }
+      return await finalHandler(req2, ctx2);
     };
-  } finally {
-    clearTimeout(timer);
+    return dispatch(req, ctx);
   }
-}
-var executors = {
-  eval: executeEval,
-  set: executeSet,
-  get: executeGet,
-  if: executeIf,
-  while: executeWhile,
-  call: executeCall,
-  http: executeHttp
 };
-async function executeNode(node, ctx) {
-  const executor = executors[node.tool];
-  if (!executor) {
-    throw new Error(`Unknown node type: "${node.tool}"`);
-  }
-  return executor(node, 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);
+    });
+  });
 }
-
-// workflow/llm.ts
-function buildToolsDescription(tools) {
-  return Object.entries(tools).map(([key, t]) => {
-    const name = t.name || key;
-    const schema = t.inputSchema;
-    return `- ${name}: ${t.description}
-  Input schema: describe as JSON object fields`;
-  }).join("\n");
+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();
+  });
 }
-var SYSTEM_PROMPT_TEMPLATE = `You are a workflow generator. Given a user goal and available tools, output a workflow JSON.
-
-Available tools:
-{{TOOLS}}
 
-Workflow format:
-{
-  "name": "workflow name",
-  "nodes": [
-    {
-      "id": "step1",
-      "tool": "set",
-      "input": { "name": "varName", "value": "initialValue" }
-    },
-    {
-      "id": "step2",
-      "tool": "call",
-      "input": { "tool": "toolName", "args": { "param1": "$var.varName" } }
-    },
-    {
-      "id": "step3",
-      "tool": "if",
-      "input": {},
-      "conditions": [
-        { "test": "$nodes.step2.output.someField", "body": [
-          { "id": "step4", "tool": "call", "input": { "tool": "toolName", "args": {} } }
-        ]}
-      ]
-    }
-  ]
+// tsx.ts
+import { createElement, createContext, useContext } from "react";
+import { renderToReadableStream } from "react-dom/server";
+import * as esbuild from "esbuild";
+import { readdirSync, statSync, existsSync, mkdirSync } from "node:fs";
+import { join, relative, resolve, sep, dirname } from "node:path";
+import { pathToFileURL } from "node:url";
+import { createHash } from "node:crypto";
+var TsxContext = createContext({ params: {}, query: {} });
+function useTsx() {
+  return useContext(TsxContext);
 }
-
-Node types:
-- eval: evaluate an expression. input: { expression: "..." }
-- set: assign a variable. input: { name, value }
-- get: read a variable. input: { name }
-- if: conditional branch. input: {}, conditions: [{ test, body }]
-- while: loop. input: { condition }, body: [nodes]
-- call: call a registered tool. input: { tool, args }
-- http: HTTP request. input: { url, method?, headers?, body? }
-
-Reference syntax:
-- $var.name - read a variable
-- $nodes.id.output - output of a previous node
-- $nodes.id.output.field - specific field of a node's output
-- $input.field - workflow input parameter
-
-Output ONLY valid JSON. No explanation, no markdown.`;
-async function generateWorkflow(goal, tools, generateFn) {
-  const toolsDesc = buildToolsDescription(tools);
-  const system = SYSTEM_PROMPT_TEMPLATE.replace("{{TOOLS}}", toolsDesc);
-  const result = await generateFn({
-    system,
-    messages: [{ role: "user", content: goal }]
-  });
-  const text = result.text.trim();
-  const jsonStart = text.indexOf("{");
-  const jsonEnd = text.lastIndexOf("}");
-  if (jsonStart === -1 || jsonEnd === -1) {
-    throw new Error(`LLM output is not valid JSON: ${text.slice(0, 200)}`);
+function id(s) {
+  return createHash("md5").update(s).digest("hex").slice(0, 8);
+}
+function concatUint8(chunks) {
+  const len = chunks.reduce((a, c) => a + c.length, 0);
+  const out = new Uint8Array(len);
+  let off = 0;
+  for (const c of chunks) {
+    out.set(c, off);
+    off += c.length;
   }
-  const jsonStr = text.slice(jsonStart, jsonEnd + 1);
-  try {
-    const workflow = JSON.parse(jsonStr);
-    if (!workflow.nodes || !Array.isArray(workflow.nodes)) {
-      throw new Error("Generated workflow has no nodes array");
+  return out;
+}
+async function readStream(stream) {
+  const chunks = [];
+  const reader = stream.getReader();
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    chunks.push(value);
+  }
+  return new TextDecoder().decode(concatUint8(chunks));
+}
+function scanPages(dir) {
+  const pages = [];
+  function walk(current) {
+    let entries;
+    try {
+      entries = readdirSync(current);
+    } catch {
+      return;
     }
-    return workflow;
-  } catch (err) {
-    if (err instanceof SyntaxError) {
-      throw new Error(`Failed to parse LLM output as JSON: ${err.message}`);
+    const dirs = [];
+    for (const name of entries) {
+      const full = join(current, name);
+      const st = statSync(full);
+      if (st.isDirectory()) {
+        if (!name.startsWith(".")) dirs.push(full);
+      }
     }
-    throw err;
+    const pagePath = join(current, "page.tsx");
+    const tsPagePath = join(current, "page.ts");
+    let entryPath = "";
+    if (existsSync(pagePath)) {
+      entryPath = pagePath;
+    } else if (existsSync(tsPagePath)) {
+      entryPath = tsPagePath;
+    }
+    if (entryPath) {
+      let relPath = relative(dir, entryPath).replace(sep, "/");
+      relPath = relPath.replace(/\/page\.tsx?$/, "");
+      relPath = relPath.replace(/^page\.tsx?$/, "");
+      const route = filePathToRoute(relPath);
+      const layouts = resolveLayouts(current, dir);
+      const loadPath = existsSync(join(current, "load.ts")) ? join(current, "load.ts") : void 0;
+      const rPath = existsSync(join(current, "route.ts")) ? join(current, "route.ts") : void 0;
+      pages.push({
+        route,
+        entryPath,
+        loadPath,
+        layouts,
+        routePath: rPath
+      });
+    } else {
+      const rPath = join(current, "route.ts");
+      if (existsSync(rPath)) {
+        let relPath = relative(dir, rPath).replace(sep, "/");
+        relPath = relPath.replace(/\/route\.tsx?$/, "");
+        const route = filePathToRoute(relPath);
+        pages.push({
+          route,
+          entryPath: "",
+          layouts: [],
+          routePath: rPath,
+          routeOnly: true
+        });
+      }
+    }
+    for (const d of dirs) walk(d);
   }
+  walk(dir);
+  return pages;
+}
+function filePathToRoute(relPath) {
+  let route = relPath.replace(/\\/g, "/");
+  route = route.replace(/\[\.\.\.(\w+)\]/g, "*");
+  route = route.replace(/\[(\w+)\]/g, ":$1");
+  return route.startsWith("/") ? route : "/" + route;
+}
+function resolveLayouts(dir, pagesDir) {
+  const layouts = [];
+  let current = dir;
+  while (current.startsWith(pagesDir)) {
+    const p = join(current, "layout.tsx");
+    if (existsSync(p)) {
+      layouts.push(p);
+    }
+    const parent = dirname(current);
+    if (parent === current) break;
+    current = parent;
+  }
+  return layouts.reverse();
+}
+async function compileAll(files, outDir, platform) {
+  const entryPoints = {};
+  for (const f of files) {
+    entryPoints[id(f)] = f;
+  }
+  const isBrowser = platform === "browser";
+  await esbuild.build({
+    entryPoints,
+    outdir: outDir,
+    format: "esm",
+    platform: "node",
+    jsx: "automatic",
+    jsxImportSource: "react",
+    bundle: true,
+    external: isBrowser ? void 0 : [
+      "react",
+      "react-dom",
+      "esbuild",
+      "graphql",
+      "ws",
+      "zod",
+      "@graphql-tools/schema",
+      "ai"
+    ],
+    write: true,
+    allowOverwrite: true
+  });
 }
-
-// workflow/engine.ts
-import { generateText } from "ai";
-function createWorkflowEngine(options) {
-  const toolRegistry = /* @__PURE__ */ new Map();
-  for (const [key, t] of Object.entries(options.tools)) {
-    t.name = t.name || key;
-    toolRegistry.set(t.name, t);
-  }
-  const states = /* @__PURE__ */ new Map();
-  async function execute(workflow, opts) {
-    const ctx = {
-      variables: /* @__PURE__ */ new Map(),
-      nodeOutputs: /* @__PURE__ */ new Map(),
-      functions: workflow.functions ?? {},
-      stepCount: 0,
-      maxSteps: opts?.maxSteps ?? 1e3,
-      input: opts?.initialInput ?? {},
-      toolRegistry,
-      sseManager: options.sseManager,
-      workflowId: opts?.workflowId
-    };
-    let lastOutput = void 0;
-    for (const node of workflow.nodes) {
-      ctx.stepCount++;
-      if (ctx.stepCount > ctx.maxSteps) {
-        throw new Error(`Step limit exceeded (${ctx.maxSteps})`);
+function compiledUrl(filePath, outDir) {
+  const hash = id(join(outDir, id(filePath)));
+  const p = join(outDir, id(filePath) + ".js");
+  return pathToFileURL(p).href;
+}
+var clientBundleCache = /* @__PURE__ */ new Map();
+var clientRouteLog = /* @__PURE__ */ new WeakMap();
+async function getOrBuildClientBundle(entryPath, layoutPaths, pagesDir, router) {
+  const key = id(entryPath);
+  const url = `/__wfw/client/${key}.js`;
+  if (!clientRouteLog.get(router)?.has(url)) {
+    let buf = clientBundleCache.get(key);
+    if (!buf) {
+      try {
+        const nested = layoutPaths.slice(1);
+        const layoutsImport = nested.map(
+          (p, i) => `import L${i} from${JSON.stringify(p)};`
+        ).join("");
+        const layoutsWrap = nested.map((_, i) => {
+          const idx = nested.length - 1 - i;
+          return `el=createElement(L${idx},null,el);`;
+        }).join("");
+        const code = [
+          `import{hydrateRoot}from'react-dom/client';`,
+          `import{createElement}from'react';`,
+          `import P from${JSON.stringify(entryPath)};`,
+          layoutsImport,
+          `const p=window.__WEIFUWU_PROPS;`,
+          `let el=createElement(P,p);`,
+          layoutsWrap,
+          `hydrateRoot(document.getElementById('__weifuwu_root'),el);`
+        ].join("");
+        const result = await esbuild.build({
+          stdin: { contents: code, loader: "tsx", resolveDir: pagesDir },
+          bundle: true,
+          format: "esm",
+          jsx: "automatic",
+          jsxImportSource: "react",
+          write: false,
+          minify: true
+        });
+        buf = result.outputFiles[0].contents;
+        clientBundleCache.set(key, buf);
+      } catch (err) {
+        console.error("hydration bundle failed:", err);
+        return null;
       }
-      options.sseManager?.send(ctx.workflowId ?? "", { event: "node-start", data: { nodeId: node.id, tool: node.tool, input: node.input } });
-      const output = await executeNode(node, ctx);
-      ctx.nodeOutputs.set(node.id, output);
-      lastOutput = output;
-      options.sseManager?.send(ctx.workflowId ?? "", { event: "node-end", data: { nodeId: node.id, output } });
     }
-    return lastOutput;
+    router.get(url, () => new Response(buf, {
+      headers: { "content-type": "application/javascript; charset=utf-8" }
+    }));
+    const set = clientRouteLog.get(router) ?? /* @__PURE__ */ new Set();
+    set.add(url);
+    clientRouteLog.set(router, set);
   }
-  async function runAsync(workflowId, workflow, opts) {
-    const state = {
-      workflowId,
-      status: "running",
-      goal: workflow.name ?? "",
-      startTime: Date.now()
-    };
-    states.set(workflowId, state);
-    const sse = options.sseManager;
-    sse?.send(workflowId, { event: "workflow-start", data: { workflowId, goal: state.goal } });
-    try {
-      const result = await execute(workflow, { ...opts, workflowId });
-      state.status = "completed";
-      state.result = result;
-      state.endTime = Date.now();
-      sse?.send(workflowId, { event: "complete", data: { result, duration: state.endTime - state.startTime } });
-    } catch (err) {
-      state.status = "error";
-      state.error = err instanceof Error ? err.message : String(err);
-      state.endTime = Date.now();
-      sse?.send(workflowId, { event: "error", data: { error: state.error } });
-    } finally {
-      sse?.close(workflowId);
+  return { url };
+}
+function makeSsrHandler(Component, loadFn, layouts, entryPath, layoutPaths, pagesDir, router) {
+  return async (req, ctx) => {
+    const loadProps = loadFn ? await loadFn({ params: ctx.params, query: ctx.query }) : {};
+    const allProps = { ...loadProps, params: ctx.params, query: ctx.query };
+    let element = createElement(Component, allProps);
+    for (let i = layouts.length - 1; i >= 0; i--) {
+      const isRoot = i === 0;
+      element = createElement(
+        layouts[i],
+        isRoot ? { children: element, req, ctx } : { children: element }
+      );
     }
-  }
-  async function generateWorkflow2(goal) {
-    if (!options.model) {
-      throw new Error('LLM model is required for generateWorkflow. Pass "model" to createWorkflowEngine.');
+    element = createElement(TsxContext.Provider, {
+      value: { params: ctx.params, query: ctx.query, user: ctx.user, parsed: ctx.parsed }
+    }, element);
+    const stream = await renderToReadableStream(element);
+    const body = await readStream(stream);
+    const scripts = [];
+    scripts.push(`<script>window.__WEIFUWU_PROPS=${JSON.stringify(allProps)}</script>`);
+    const bundle = await getOrBuildClientBundle(entryPath, layoutPaths, pagesDir, router);
+    if (bundle) {
+      scripts.push(`<script type="module" src="${bundle.url}"></script>`);
     }
-    return generateWorkflow(goal, options.tools, async (prompt) => {
-      const result = await generateText({
-        model: options.model,
-        system: prompt.system,
-        messages: prompt.messages
-      });
-      return { text: result.text };
+    const html = `<!DOCTYPE html>
+${body}
+${scripts.join("\n")}`;
+    return new Response(html, {
+      headers: { "content-type": "text/html; charset=utf-8" }
     });
-  }
-  return {
-    execute,
-    runAsync,
-    generateWorkflow: generateWorkflow2,
-    getState(workflowId) {
-      return states.get(workflowId);
-    }
   };
 }
-
-// workflow/sse.ts
-function createSSEManager() {
-  const streams = /* @__PURE__ */ new Map();
-  const encoder = new TextEncoder();
-  function createStream(workflowId) {
-    const state = {
-      controller: null,
-      encoder,
-      closed: false,
-      buffer: []
-    };
-    const stream = new ReadableStream({
-      start(controller) {
-        state.controller = controller;
-        streams.set(workflowId, state);
-        for (const event of state.buffer) {
-          try {
-            controller.enqueue(encoder.encode(event));
-          } catch {
-            break;
-          }
+async function tsx(options) {
+  const pagesDir = resolve(options.dir);
+  const outDir = join(pagesDir, "..", ".weifuwu", "ssr");
+  const pages = scanPages(pagesDir);
+  if (pages.length === 0) return new Router();
+  const allFiles = /* @__PURE__ */ new Set();
+  for (const p of pages) {
+    if (p.entryPath) allFiles.add(p.entryPath);
+    if (p.loadPath) allFiles.add(p.loadPath);
+    for (const lp of p.layouts) allFiles.add(lp);
+    if (p.routePath) allFiles.add(p.routePath);
+  }
+  const nfPath = join(pagesDir, "not-found.tsx");
+  const hasNotFound = existsSync(nfPath);
+  if (hasNotFound) {
+    allFiles.add(nfPath);
+    const rootLayouts = resolveLayouts(pagesDir, pagesDir);
+    for (const lp of rootLayouts) allFiles.add(lp);
+  }
+  mkdirSync(outDir, { recursive: true });
+  await compileAll([...allFiles], outDir, "node");
+  const router = new Router();
+  for (const p of pages) {
+    if (p.routeOnly && p.routePath) {
+      const rUrl = compiledUrl(p.routePath, outDir);
+      const modR = await import(rUrl);
+      const methods = ["GET", "POST", "PUT", "DELETE", "PATCH", "HEAD", "OPTIONS"];
+      for (const method of methods) {
+        if (modR[method]) {
+          router.route(method, p.route, modR[method]);
         }
-        state.buffer = [];
-      },
-      cancel() {
-        state.closed = true;
-        streams.delete(workflowId);
       }
-    });
-    return stream;
-  }
-  function send(workflowId, event) {
-    const state = streams.get(workflowId);
-    if (!state || state.closed) return;
-    const data = `event: ${event.event}
-data: ${JSON.stringify(event.data)}
-
-`;
-    if (state.controller) {
-      try {
-        state.controller.enqueue(encoder.encode(data));
-      } catch {
-        state.closed = true;
-        streams.delete(workflowId);
+      continue;
+    }
+    const url = compiledUrl(p.entryPath, outDir);
+    const mod = await import(url);
+    const Component = mod.default;
+    let loadFn;
+    if (p.loadPath) {
+      const loadUrl = compiledUrl(p.loadPath, outDir);
+      const modLoad = await import(loadUrl);
+      loadFn = modLoad.default;
+    }
+    const layoutComponents = [];
+    for (const lp of p.layouts) {
+      const lUrl = compiledUrl(lp, outDir);
+      const modL = await import(lUrl);
+      layoutComponents.push(modL.default);
+    }
+    const handler = makeSsrHandler(
+      Component,
+      loadFn,
+      layoutComponents,
+      p.entryPath,
+      p.layouts,
+      pagesDir,
+      router
+    );
+    router.get(p.route, handler);
+    if (p.routePath) {
+      const rUrl = compiledUrl(p.routePath, outDir);
+      const modR = await import(rUrl);
+      const methods = ["POST", "PUT", "DELETE", "PATCH", "HEAD", "OPTIONS"];
+      for (const method of methods) {
+        if (modR[method]) {
+          router.route(method, p.route, modR[method]);
+        }
       }
-    } else {
-      state.buffer.push(data);
     }
   }
-  function close(workflowId) {
-    const state = streams.get(workflowId);
-    if (!state) return;
-    state.closed = true;
-    streams.delete(workflowId);
-    try {
-      state.controller?.close();
-    } catch {
+  if (hasNotFound) {
+    const nfUrl = compiledUrl(nfPath, outDir);
+    const modNf = await import(nfUrl);
+    const NfComponent = modNf.default;
+    const nfLayouts = [];
+    const rootLayouts = resolveLayouts(pagesDir, pagesDir);
+    for (const lp of rootLayouts) {
+      const lUrl = compiledUrl(lp, outDir);
+      const modL = await import(lUrl);
+      nfLayouts.push(modL.default);
     }
+    const handler = async (req, ctx) => {
+      let element = createElement(NfComponent, { params: ctx.params, query: ctx.query });
+      for (let i = nfLayouts.length - 1; i >= 0; i--) {
+        element = createElement(nfLayouts[i], { children: element });
+      }
+      element = createElement(TsxContext.Provider, {
+        value: { params: ctx.params, query: ctx.query, user: ctx.user, parsed: ctx.parsed }
+      }, element);
+      const stream = await renderToReadableStream(element);
+      const body = await readStream(stream);
+      const html = `<!DOCTYPE html>
+${body}`;
+      return new Response(html, {
+        status: 404,
+        headers: { "content-type": "text/html; charset=utf-8" }
+      });
+    };
+    router.all("/*", handler);
   }
-  return { createStream, send, close };
+  return router;
 }
 
-// router.ts
-var createTrieNode = () => ({
-  children: /* @__PURE__ */ new Map(),
-  handlers: /* @__PURE__ */ new Map(),
-  middlewares: /* @__PURE__ */ new Map(),
-  pathMws: []
-});
-var createWsNode = () => ({
-  children: /* @__PURE__ */ new Map(),
-  middlewares: []
-});
-var getTrieNode = (node, segment) => {
-  if (segment.startsWith(":")) {
-    if (!node.children.has(":")) {
-      const child2 = createTrieNode();
-      child2.param = segment.slice(1);
-      node.children.set(":", child2);
-    }
-    const child = node.children.get(":");
-    if (child.param !== segment.slice(1)) {
-      throw new Error(
-        `Param name conflict: ":${child.param}" already registered at this path position, cannot register ":"${segment.slice(1)}"`
-      );
-    }
-    return child;
-  }
-  if (!node.children.has(segment)) {
-    node.children.set(segment, createTrieNode());
-  }
-  return node.children.get(segment);
-};
-var matchTrieNode = (node, segment, params) => {
-  if (node.children.has(segment)) return node.children.get(segment);
-  if (node.children.has(":")) {
-    const child = node.children.get(":");
-    if (child.param) params[child.param] = segment;
-    return child;
-  }
-  return null;
-};
-var getWsNode = (node, segment) => {
-  if (segment.startsWith(":")) {
-    if (!node.children.has(":")) {
-      const child2 = createWsNode();
-      child2.param = segment.slice(1);
-      node.children.set(":", child2);
-    }
-    const child = node.children.get(":");
-    if (child.param !== segment.slice(1)) {
-      throw new Error(
-        `Param name conflict: ":${child.param}" already registered at this path position`
-      );
+// middleware.ts
+function logger(options) {
+  return async (req, ctx, next) => {
+    const start = Date.now();
+    const url = new URL(req.url);
+    const res = await next(req, ctx);
+    const ms = Date.now() - start;
+    if (options?.format === "combined") {
+      console.log(`${req.method} ${url.pathname}${url.search} ${res.status} ${ms}ms`);
+    } else {
+      console.log(`${req.method} ${url.pathname} ${res.status} ${ms}ms`);
     }
-    return child;
-  }
-  if (!node.children.has(segment)) {
-    node.children.set(segment, createWsNode());
-  }
-  return node.children.get(segment);
-};
-var matchWsNode = (node, segment, params) => {
-  if (node.children.has(segment)) return node.children.get(segment);
-  if (node.children.has(":")) {
-    const child = node.children.get(":");
-    if (child.param) params[child.param] = segment;
-    return child;
-  }
-  return null;
-};
-var Router = class _Router {
-  root = createTrieNode();
-  wsRoot = createWsNode();
-  globalMws = [];
-  errorHandler;
-  use(arg1, arg2) {
-    if (typeof arg1 === "string") {
-      if (arg2 instanceof _Router) {
-        let node = this.root;
-        for (const segment of this.splitPath(arg1)) {
-          node = getTrieNode(node, segment);
-        }
-        node.subRouter = arg2;
-      } else if (typeof arg2 === "function") {
-        let node = this.root;
-        for (const segment of this.splitPath(arg1)) {
-          node = getTrieNode(node, segment);
-        }
-        node.pathMws.push(arg2);
-      }
-    } else if (typeof arg1 === "function") {
-      this.globalMws.push(arg1);
+    return res;
+  };
+}
+function cors(options) {
+  const opts = {
+    origin: "*",
+    methods: ["GET", "HEAD", "PUT", "PATCH", "POST", "DELETE"],
+    allowedHeaders: ["Content-Type", "Authorization"],
+    ...options
+  };
+  function resolveOrigin(requestOrigin) {
+    if (typeof opts.origin === "string") return opts.origin === "*" ? "*" : opts.origin;
+    if (Array.isArray(opts.origin)) {
+      return opts.origin.includes(requestOrigin) ? requestOrigin : "";
     }
-    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;
+    const result = opts.origin(requestOrigin);
+    if (typeof result === "boolean") return result ? requestOrigin : "";
+    if (typeof result === "string") return result;
+    return "";
   }
-  route(method, path, ...args) {
-    const handler = args.pop();
-    const middlewares = args;
-    const segments = this.splitPath(path);
-    let node = this.root;
-    for (const segment of segments) {
-      if (segment === "*") {
-        node.wildcard = true;
-        node.handlers.set(method, handler);
-        if (middlewares.length > 0) node.middlewares.set(method, middlewares);
-        return this;
-      }
-      node = getTrieNode(node, segment);
-    }
-    node.handlers.set(method, handler);
-    if (middlewares.length > 0) node.middlewares.set(method, middlewares);
-    return this;
+  function setCORSHeaders(res, acao) {
+    if (!acao) return res;
+    const headers = new Headers(res.headers);
+    headers.set("Access-Control-Allow-Origin", acao);
+    if (opts.credentials) headers.set("Access-Control-Allow-Credentials", "true");
+    if (opts.exposedHeaders?.length) headers.set("Access-Control-Expose-Headers", opts.exposedHeaders.join(", "));
+    headers.set("Vary", "Origin");
+    return new Response(res.body, { status: res.status, statusText: res.statusText, headers });
   }
-  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);
+  return (req, ctx, next) => {
+    const requestOrigin = req.headers.get("origin") ?? "";
+    const acao = resolveOrigin(requestOrigin);
+    if (req.method === "OPTIONS" && acao) {
+      const headers = new Headers();
+      headers.set("Access-Control-Allow-Origin", acao);
+      headers.set("Access-Control-Allow-Methods", opts.methods.join(", "));
+      headers.set("Access-Control-Allow-Headers", opts.allowedHeaders.join(", "));
+      if (opts.credentials) headers.set("Access-Control-Allow-Credentials", "true");
+      if (opts.maxAge != null) headers.set("Access-Control-Max-Age", String(opts.maxAge));
+      headers.set("Vary", "Origin");
+      return new Response(null, { status: 204, headers });
     }
-    node.handler = handler;
-    if (middlewares.length > 0) node.middlewares = middlewares;
-    return this;
-  }
-  graphql(path, ...args) {
-    const options = args.pop();
-    const middlewares = args;
-    const schema = typeof options.schema === "string" ? options.resolvers ? makeExecutableSchema({
-      typeDefs: options.schema,
-      resolvers: options.resolvers
-    }) : buildSchema(options.schema) : options.schema;
-    const handler = (req, ctx) => {
-      const url = new URL(req.url);
-      if (options.graphiql && req.method === "GET" && !url.searchParams.has("query")) {
-        return new Response(getGraphiQLHtml(url.pathname), {
-          status: 200,
-          headers: { "Content-Type": "text/html" }
-        });
+    if (!acao) return next(req, ctx);
+    return Promise.resolve(next(req, ctx)).then((res) => setCORSHeaders(res, acao));
+  };
+}
+function auth(options) {
+  return async (req, ctx, next) => {
+    const headerName = options.header ?? "Authorization";
+    let from = "header";
+    let header = req.headers.get(headerName);
+    let token = "";
+    if (header) {
+      token = header;
+      if (headerName.toLowerCase() === "authorization") {
+        const parts = header.split(" ");
+        if (parts[0]?.toLowerCase() === "bearer") {
+          token = parts.slice(1).join(" ");
+        }
       }
-      if (req.method !== "GET" && req.method !== "POST") {
-        return new Response("Not Found", { status: 404 });
+    } else {
+      const url = new URL(req.url);
+      const qsToken = url.searchParams.get("access_token");
+      if (qsToken) {
+        token = qsToken;
+        from = "query";
       }
-      const paramsPromise = req.method === "GET" ? Promise.resolve(parseGraphQLParamsFromGet(url)) : parseGraphQLParamsFromPost(req);
-      return paramsPromise.then((params) => {
-        if (!params) {
-          return Response.json(
-            { errors: [{ message: "Missing query" }] },
-            { status: 400 }
-          );
-        }
-        return executeGraphQLQuery(schema, params, options, req, ctx);
-      });
-    };
-    return this.all(path, ...middlewares, handler);
-  }
-  ai(path, ...args) {
-    const handler = args.pop();
-    const middlewares = args;
-    const routeHandler = async (req, ctx) => {
-      const options = await handler(req, ctx);
-      const result = streamText(options);
-      return result.toTextStreamResponse();
-    };
-    return this.post(path, ...middlewares, routeHandler);
-  }
-  workflow(path, options) {
-    const sseManager = options.stream ? createSSEManager() : void 0;
-    if (options.stream && sseManager) {
-      this.get(`${path}/:workflowId/events`, async (req, ctx) => {
-        const stream = sseManager.createStream(ctx.params.workflowId);
-        return new Response(stream, {
-          headers: {
-            "Content-Type": "text/event-stream",
-            "Cache-Control": "no-cache",
-            "Connection": "keep-alive"
-          }
-        });
-      });
     }
-    this.post(path, async (req) => {
-      const body = await req.json();
-      const engine = createWorkflowEngine({
-        tools: options.tools,
-        model: options.model,
-        sseManager
+    if (!token) {
+      return new Response("Unauthorized", {
+        status: 401,
+        headers: headerName.toLowerCase() === "authorization" ? { "WWW-Authenticate": "Bearer" } : void 0
       });
-      let wf;
-      if (body.goal && options.model) {
-        wf = await engine.generateWorkflow(body.goal);
-      } else if (body.workflow) {
-        wf = body.workflow;
-      } else if (body.nodes) {
-        wf = { nodes: body.nodes };
+    }
+    if (options.proxy) {
+      const proxyUrl = typeof options.proxy === "string" ? new URL(options.proxy) : options.proxy;
+      const proxyHeaders = {};
+      if (from === "header" && header) {
+        proxyHeaders[headerName] = header;
       } else {
-        return Response.json(
-          { error: 'Provide "goal" (with model) or "workflow"/"nodes"' },
-          { status: 400 }
-        );
+        proxyUrl.searchParams.set("access_token", token);
       }
-      if (options.stream && sseManager) {
-        const workflowId = crypto.randomUUID();
-        engine.runAsync(workflowId, wf);
-        return Response.json({ workflowId, eventsUrl: `${path}/${workflowId}/events` });
+      for (const name of ["x-forwarded-for", "x-real-ip", "user-agent", "content-type"]) {
+        const v = req.headers.get(name);
+        if (v) proxyHeaders[name] = v;
       }
-      const result = await engine.execute(wf);
-      return Response.json({ workflow: wf, result });
-    });
-    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 wss = new WebSocketServer({ noServer: true });
-    const wsRoot = this.wsRoot;
-    const router = this;
-    return (req, socket, head) => {
-      const url = new URL(req.url ?? "/", "http://localhost");
-      const segments = url.pathname.split("/").filter(Boolean);
-      const query = Object.fromEntries(url.searchParams);
-      const match = router.matchWsTrie(wsRoot, segments);
-      if (!match) {
-        socket.destroy();
-        return;
+      const proxyRes = await fetch(proxyUrl.href, { headers: proxyHeaders });
+      if (proxyRes.status >= 400) {
+        return new Response(await proxyRes.text() || "Forbidden", { status: proxyRes.status });
       }
-      const webReq = new Request(url.href, {
-        method: req.method ?? "GET",
-        headers: Object.fromEntries(
-          Object.entries(req.headers).map(([k, v]) => [k, Array.isArray(v) ? v.join(", ") : v ?? ""])
-        )
-      });
-      const ctx = { params: match.params, query };
-      if (match.middlewares.length === 0) {
-        upgradeSocket(wss, req, socket, head, match.handler, ctx);
-        return;
+      let userData = void 0;
+      if (proxyRes.status === 200) {
+        const ct = proxyRes.headers.get("content-type");
+        if (ct?.includes("application/json")) {
+          try {
+            userData = await proxyRes.json();
+          } catch {
+          }
+        }
       }
-      let index = 0;
-      const dispatch = async (innerReq, ctx2) => {
-        if (index < match.middlewares.length) {
-          const mw = match.middlewares[index++];
-          return mw(innerReq, ctx2, dispatch);
+      ctx.user = userData;
+      return next(req, ctx);
+    }
+    if (options.token) {
+      if (token !== options.token) {
+        return new Response("Forbidden", { status: 403 });
+      }
+      return next(req, ctx);
+    }
+    if (options.verify) {
+      const result = await options.verify(token, req);
+      if (!result) {
+        return new Response("Forbidden", { status: 403 });
+      }
+      if (typeof result === "object" && result !== null) {
+        ctx.user = result;
+      }
+      return next(req, ctx);
+    }
+    return next(req, ctx);
+  };
+}
+
+// static.ts
+import { createHash as createHash2 } from "node:crypto";
+import { open } from "node:fs/promises";
+import { extname, resolve as resolve2, normalize, sep as sep2 } from "node:path";
+function serveStatic(root, options) {
+  const rootDir = resolve2(root);
+  const opts = options ?? {};
+  return async (req, ctx) => {
+    const relativePath = ctx.params["*"] ?? new URL(req.url).pathname.slice(1);
+    const decoded = decodeURIComponent(relativePath);
+    if (decoded.includes("..") || decoded.includes("\0")) {
+      return new Response("Forbidden", { status: 403 });
+    }
+    let filePath = normalize(resolve2(rootDir, decoded));
+    if (!filePath.startsWith(rootDir + sep2) && filePath !== rootDir) {
+      return new Response("Forbidden", { status: 403 });
+    }
+    let fileHandle;
+    try {
+      fileHandle = await open(filePath, "r");
+      const stat = await fileHandle.stat();
+      if (stat.isDirectory()) {
+        await fileHandle.close();
+        const indexFile = opts.index ?? "index.html";
+        filePath = resolve2(filePath, indexFile);
+        if (!filePath.startsWith(rootDir + sep2)) {
+          return new Response("Forbidden", { status: 403 });
         }
-        return await new Promise((resolve3) => {
-          upgradeSocket(wss, req, socket, head, match.handler, ctx2);
-          resolve3(new Response(null, { status: 101 }));
-        });
-      };
-      Promise.resolve(dispatch(webReq, ctx)).then((result) => {
-        if (result.status !== 101) {
-          sendHttpResponseOnSocket(socket, result);
+        fileHandle = await open(filePath, "r");
+        const dirStat = await fileHandle.stat();
+        if (!dirStat.isFile()) {
+          await fileHandle.close();
+          return new Response("Not Found", { status: 404 });
         }
-      }).catch(() => {
-        socket.destroy();
+      }
+      const mimeType = MIME_TYPES[extname(filePath).toLowerCase()] ?? "application/octet-stream";
+      const etag = `"${createHash2("md5").update(`${stat.size}-${stat.mtimeMs}`).digest("hex")}"`;
+      const ifNoneMatch = req.headers.get("if-none-match");
+      if (ifNoneMatch === etag) {
+        await fileHandle.close();
+        return new Response(null, { status: 304 });
+      }
+      const ifModifiedSince = req.headers.get("if-modified-since");
+      if (ifModifiedSince && stat.mtimeMs <= new Date(ifModifiedSince).getTime()) {
+        await fileHandle.close();
+        return new Response(null, { status: 304 });
+      }
+      const headers = {
+        "Content-Type": mimeType,
+        "Content-Length": String(stat.size),
+        "ETag": etag,
+        "Last-Modified": stat.mtime.toUTCString(),
+        "Cache-Control": opts.immutable ? `public, max-age=${opts.maxAge ?? 31536e3}, immutable` : `public, max-age=${opts.maxAge ?? 0}`
+      };
+      const stream = fileHandle.readableWebStream();
+      return new Response(stream, { headers });
+    } catch (err) {
+      if (fileHandle) await fileHandle.close().catch(() => {
       });
-    };
-  }
-  splitPath(path) {
-    return path.split("/").filter(Boolean);
-  }
-  matchTrie(method, segments) {
-    let node = this.root;
-    const params = {};
-    const pathMws = [...this.root.pathMws];
-    let wildcardHandler = null;
-    let wildcardMws = [];
-    let wildcardIdx = -1;
-    for (let i = 0; i < segments.length; i++) {
-      pathMws.push(...node.pathMws);
-      if (node.wildcard) {
-        const h = node.handlers.get("*") || node.handlers.get(method);
-        if (h) {
-          wildcardHandler = h;
-          wildcardMws = node.middlewares.get(method) || node.middlewares.get("*") || [];
-          wildcardIdx = i;
-        }
+      if (err?.code === "ENOENT") {
+        return new Response("Not Found", { status: 404 });
       }
-      const segment = segments[i];
-      if (!segment) break;
-      const next = matchTrieNode(node, segment, params);
-      if (!next) {
-        if (node.subRouter) {
-          return {
-            pathMws,
-            params,
-            middlewares: [],
-            subRouter: { router: node.subRouter, remainingIdx: i }
-          };
-        }
-        if (wildcardHandler) {
-          params["*"] = segments.slice(wildcardIdx).join("/");
-          return { handler: wildcardHandler, middlewares: wildcardMws, pathMws, params };
-        }
-        return null;
+      return new Response("Internal Server Error", { status: 500 });
+    }
+  };
+}
+var MIME_TYPES = {
+  ".html": "text/html; charset=utf-8",
+  ".htm": "text/html; charset=utf-8",
+  ".css": "text/css; charset=utf-8",
+  ".js": "application/javascript; charset=utf-8",
+  ".mjs": "application/javascript; charset=utf-8",
+  ".json": "application/json",
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".gif": "image/gif",
+  ".svg": "image/svg+xml",
+  ".ico": "image/x-icon",
+  ".webp": "image/webp",
+  ".avif": "image/avif",
+  ".woff": "font/woff",
+  ".woff2": "font/woff2",
+  ".ttf": "font/ttf",
+  ".otf": "font/otf",
+  ".eot": "application/vnd.ms-fontobject",
+  ".txt": "text/plain; charset=utf-8",
+  ".xml": "application/xml",
+  ".pdf": "application/pdf",
+  ".zip": "application/zip",
+  ".wasm": "application/wasm",
+  ".map": "application/json"
+};
+
+// validate.ts
+function validate(schemas) {
+  return async (req, ctx, next) => {
+    const parsed = {};
+    const issues = [];
+    if (schemas.params) {
+      const result = schemas.params.safeParse(ctx.params);
+      if (result.success) {
+        parsed.params = result.data;
+      } else {
+        issues.push(...result.error.issues.map((i) => ({
+          path: ["params", ...i.path.map(String)],
+          message: i.message
+        })));
       }
-      node = next;
-    }
-    if (node.subRouter) {
-      return {
-        pathMws,
-        params,
-        middlewares: [],
-        subRouter: { router: node.subRouter, remainingIdx: segments.length }
-      };
-    }
-    pathMws.push(...node.pathMws);
-    const handler = node.handlers.get(method) || node.handlers.get("*");
-    if (handler) {
-      if (node.wildcard) params["*"] = segments.slice(segments.length).join("/");
-      return {
-        handler,
-        middlewares: node.middlewares.get(method) || node.middlewares.get("*") || [],
-        pathMws,
-        params
-      };
-    }
-    if (wildcardHandler) {
-      params["*"] = segments.slice(wildcardIdx).join("/");
-      return { handler: wildcardHandler, middlewares: wildcardMws, pathMws, params };
-    }
-    return null;
-  }
-  matchWsTrie(root, segments) {
-    let node = root;
-    const params = {};
-    for (const segment of segments) {
-      const next = matchWsNode(node, segment, params);
-      if (!next) return null;
-      node = next;
     }
-    return node.handler ? { handler: node.handler, middlewares: node.middlewares, params } : null;
-  }
-  async handle(req, ctx, segments, query) {
-    const match = this.matchTrie(req.method, segments);
-    if (match?.subRouter) {
-      const { router: sub, remainingIdx } = match.subRouter;
-      const remainingSegments = segments.slice(remainingIdx);
-      const delegate = (req2, ctx2) => sub.handle(req2, ctx2, remainingSegments, query);
-      const allMws = this.globalMws.length + match.pathMws.length === 0 ? [] : [...this.globalMws, ...match.pathMws];
-      try {
-        return await this.runChain(allMws, delegate, req, { ...ctx, params: { ...ctx.params, ...match.params } });
-      } catch (e) {
-        return this.errorHandler ? this.errorHandler(e, req, ctx) : new Response("Internal Server Error", { status: 500 });
+    if (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 (match?.handler) {
-      const { handler, middlewares: routeMws, pathMws, params } = match;
-      const allMws = this.globalMws.length + pathMws.length + routeMws.length === 0 ? [] : [...this.globalMws, ...pathMws, ...routeMws];
-      const ctxWithMatch = { ...ctx, params: { ...ctx.params, ...params } };
-      try {
-        return await this.runChain(allMws, handler, req, ctxWithMatch);
-      } catch (e) {
-        return this.errorHandler ? this.errorHandler(e, req, ctxWithMatch) : new Response("Internal Server Error", { status: 500 });
+    if (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 (this.globalMws.length > 0) {
-      try {
-        const delegate = () => new Response("Not Found", { status: 404 });
-        return await this.runChain(this.globalMws, delegate, req, ctx);
-      } catch (e) {
-        return this.errorHandler ? this.errorHandler(e, req, ctx) : new Response("Internal Server Error", { status: 500 });
+    if (schemas.body) {
+      if (req.body === null) {
+        issues.push({ path: ["body"], message: "Request body is required" });
+      } else {
+        const bodyText = await req.text();
+        if (!bodyText && req.method !== "GET" && req.method !== "HEAD") {
+          issues.push({ path: ["body"], message: "Request body is required" });
+        } else {
+          let bodyValue;
+          try {
+            bodyValue = JSON.parse(bodyText);
+          } catch {
+            bodyValue = bodyText;
+          }
+          const result = schemas.body.safeParse(bodyValue);
+          if (result.success) {
+            parsed.body = result.data;
+          } else {
+            issues.push(...result.error.issues.map((i) => ({
+              path: ["body", ...i.path.map(String)],
+              message: i.message
+            })));
+          }
+        }
       }
     }
-    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);
+    if (issues.length > 0) {
+      return Response.json({ error: "Validation failed", issues }, { status: 400 });
     }
-    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);
-    });
-  });
+    ctx.parsed = parsed;
+    return next(req, ctx);
+  };
 }
-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}`);
+
+// cookie.ts
+function getCookies(req) {
+  const header = req.headers.get("cookie");
+  if (!header) return {};
+  const cookies = {};
+  for (const pair of header.split(";")) {
+    const idx = pair.indexOf("=");
+    if (idx === -1) continue;
+    const name = pair.slice(0, idx).trim();
+    const value = pair.slice(idx + 1).trim();
+    if (name) {
+      cookies[name] = decodeURIComponent(value);
+    }
+  }
+  return cookies;
+}
+function serializeCookie(name, value, options) {
+  const parts = [`${encodeURIComponent(name)}=${encodeURIComponent(value)}`];
+  if (options?.maxAge != null) parts.push(`Max-Age=${options.maxAge}`);
+  if (options?.expires) parts.push(`Expires=${options.expires.toUTCString()}`);
+  if (options?.domain) parts.push(`Domain=${options.domain}`);
+  if (options?.path) parts.push(`Path=${options.path}`);
+  if (options?.httpOnly) parts.push("HttpOnly");
+  if (options?.secure) parts.push("Secure");
+  if (options?.sameSite) parts.push(`SameSite=${options.sameSite}`);
+  return parts.join("; ");
+}
+function setCookie(res, name, value, options) {
+  const headers = new Headers(res.headers);
+  headers.append("Set-Cookie", serializeCookie(name, value, options));
+  return new Response(res.body, {
+    status: res.status,
+    statusText: res.statusText,
+    headers
   });
-  headerLines.push("Connection: close");
-  headerLines.push("");
-  const headerStr = headerLines.join("\r\n");
-  response.arrayBuffer().then((buf) => {
-    const body = Buffer.from(buf);
-    socket.write(headerStr + "\r\n" + body.toString());
-    socket.end();
-  }).catch(() => {
-    socket.write(headerStr + "\r\n");
-    socket.end();
+}
+function deleteCookie(res, name, options) {
+  const headers = new Headers(res.headers);
+  headers.append("Set-Cookie", serializeCookie(name, "", { ...options, maxAge: 0 }));
+  return new Response(res.body, {
+    status: res.status,
+    statusText: res.statusText,
+    headers
   });
 }
-function parseGraphQLParamsFromGet(url) {
-  const query = url.searchParams.get("query");
-  if (!query) return null;
-  const variablesStr = url.searchParams.get("variables");
-  let variables = {};
-  if (variablesStr) {
-    try {
-      variables = JSON.parse(variablesStr);
-    } catch {
-      return null;
+
+// upload.ts
+import { writeFile, mkdir } from "node:fs/promises";
+import { randomUUID } from "node:crypto";
+import { join as join2 } from "node:path";
+function upload(options) {
+  const saveDir = options?.dir;
+  return async (req, ctx, next) => {
+    const ct = req.headers.get("content-type") ?? "";
+    if (!ct.includes("multipart/form-data")) {
+      return next(req, ctx);
+    }
+    const match = ct.match(/boundary=(?:"([^"]+)"|([^;]+))/i);
+    if (!match) {
+      return Response.json({ error: "Missing boundary" }, { status: 400 });
+    }
+    const boundary = match[1] ?? match[2];
+    const body = await req.text();
+    const rawParts = body.split(`--${boundary}`).filter((p) => p && !p.startsWith("--") && !p.startsWith("\r\n--"));
+    const files = {};
+    const fields = {};
+    for (const raw of rawParts) {
+      const trimmed = raw.replace(/^\r?\n/, "");
+      const lines = trimmed.split(/\r?\n/);
+      let i = 0;
+      const headers = {};
+      while (i < lines.length && lines[i].length > 0) {
+        const sep3 = lines[i].indexOf(": ");
+        if (sep3 !== -1) headers[lines[i].slice(0, sep3).toLowerCase()] = lines[i].slice(sep3 + 2);
+        i++;
+      }
+      i++;
+      const bodyValue = lines.slice(i).join("\r\n");
+      const disposition = headers["content-disposition"] ?? "";
+      const nameMatch = disposition.match(/name="([^"]*)"/);
+      if (!nameMatch) continue;
+      const name = nameMatch[1];
+      const filenameMatch = disposition.match(/filename="([^"]*)"/);
+      const filename = filenameMatch?.[1];
+      if (filename) {
+        const buf = Buffer.from(bodyValue.replace(/\r?\n$/, ""), "binary");
+        if (options?.allowedTypes) {
+          const mime = headers["content-type"] ?? "application/octet-stream";
+          if (!options.allowedTypes.includes(mime)) {
+            return Response.json({ error: `File type not allowed: ${mime}` }, { status: 415 });
+          }
+        }
+        if (options?.maxFileSize && buf.byteLength > options.maxFileSize) {
+          return Response.json({ error: `File too large: ${filename}` }, { status: 413 });
+        }
+        const uf = {
+          name: filename,
+          type: headers["content-type"] ?? "application/octet-stream",
+          size: buf.byteLength,
+          buffer: saveDir ? void 0 : buf
+        };
+        if (saveDir) {
+          const filePath = join2(saveDir, `${randomUUID()}-${filename}`);
+          await mkdir(saveDir, { recursive: true });
+          await writeFile(filePath, buf);
+          uf.path = filePath;
+        }
+        if (files[name]) {
+          const existing = files[name];
+          files[name] = Array.isArray(existing) ? [...existing, uf] : [existing, uf];
+        } else {
+          files[name] = uf;
+        }
+      } else {
+        fields[name] = bodyValue.replace(/\r?\n$/, "");
+      }
     }
-  }
-  return {
-    query,
-    variables,
-    operationName: url.searchParams.get("operationName") || void 0
+    ctx.parsed = { ...ctx.parsed, files, fields };
+    return next(req, ctx);
   };
 }
-async function parseGraphQLParamsFromPost(req) {
-  try {
-    const body = await req.json();
-    if (!body.query) return null;
-    return {
-      query: body.query,
-      variables: body.variables || {},
-      operationName: body.operationName
-    };
-  } catch {
-    return null;
-  }
-}
-async function executeGraphQLQuery(schema, params, options, req, ctx) {
-  const contextValue = options.context ? await options.context(req, ctx) : ctx;
-  const result = await graphql({
-    schema,
-    source: params.query,
-    rootValue: options.rootValue,
-    contextValue,
-    variableValues: params.variables,
-    operationName: params.operationName
+
+// rate-limit.ts
+function rateLimit(options) {
+  const max = options?.max ?? 100;
+  const window = options?.window ?? 6e4;
+  const getKey = options?.key ?? ((req) => {
+    const forwarded = req.headers.get("x-forwarded-for");
+    if (forwarded) return forwarded.split(",")[0].trim();
+    return new URL(req.url).hostname;
   });
-  return Response.json(result, { status: result.errors ? 400 : 200 });
-}
-function getGraphiQLHtml(endpoint) {
-  return `<!doctype html>
-<html lang="en">
-  <head>
-    <meta charset="UTF-8" />
-    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-    <title>GraphiQL</title>
-    <style>
-      body { margin: 0; }
-      #graphiql { height: 100dvh; }
-    </style>
-    <link rel="stylesheet" href="https://esm.sh/graphiql@5.2.2/dist/style.css" />
-    <script type="importmap">
-      {
-        "imports": {
-          "react": "https://esm.sh/react@19.2.5",
-          "react/": "https://esm.sh/react@19.2.5/",
-          "react-dom": "https://esm.sh/react-dom@19.2.5",
-          "react-dom/": "https://esm.sh/react-dom@19.2.5/",
-          "graphiql": "https://esm.sh/graphiql@5.2.2?standalone&external=react,react-dom,@graphiql/react,graphql",
-          "graphiql/": "https://esm.sh/graphiql@5.2.2/",
-          "@graphiql/react": "https://esm.sh/@graphiql/react@0.37.3?standalone&external=react,react-dom,graphql,@graphiql/toolkit,@emotion/is-prop-valid",
-          "@graphiql/toolkit": "https://esm.sh/@graphiql/toolkit@0.11.3?standalone&external=graphql",
-          "graphql": "https://esm.sh/graphql@16.13.2",
-          "@emotion/is-prop-valid": "data:text/javascript,"
+  const message = options?.message ?? "Too Many Requests";
+  const hits = /* @__PURE__ */ new Map();
+  const interval = setInterval(() => {
+    const now = Date.now();
+    for (const [key, entry] of hits) {
+      if (entry.reset < now) hits.delete(key);
+    }
+  }, window);
+  if (interval.unref) interval.unref();
+  return async (req, ctx, next) => {
+    const key = getKey(req);
+    const now = Date.now();
+    const entry = hits.get(key);
+    if (!entry || entry.reset < now) {
+      hits.set(key, { count: 1, reset: now + window });
+      const res2 = await next(req, ctx);
+      const headers2 = new Headers(res2.headers);
+      headers2.set("X-RateLimit-Limit", String(max));
+      headers2.set("X-RateLimit-Remaining", String(max - 1));
+      headers2.set("X-RateLimit-Reset", String(Math.ceil((now + window) / 1e3)));
+      return new Response(res2.body, { status: res2.status, statusText: res2.statusText, headers: headers2 });
+    }
+    entry.count++;
+    const remaining = Math.max(0, max - entry.count);
+    if (entry.count > max) {
+      return new Response(message, {
+        status: 429,
+        headers: {
+          "Retry-After": String(Math.ceil((entry.reset - now) / 1e3)),
+          "X-RateLimit-Limit": String(max),
+          "X-RateLimit-Remaining": "0",
+          "X-RateLimit-Reset": String(Math.ceil(entry.reset / 1e3))
         }
-      }
-    </script>
-    <script type="module">
-      import React from 'react';
-      import ReactDOM from 'react-dom/client';
-      import { GraphiQL } from 'graphiql';
-      import { createGraphiQLFetcher } from '@graphiql/toolkit';
-      import 'graphiql/setup-workers/esm.sh';
-
-      const fetcher = createGraphiQLFetcher({ url: "${endpoint}" });
-
-      function App() {
-        return React.createElement(GraphiQL, { fetcher });
-      }
-
-      const container = document.getElementById('graphiql');
-      const root = ReactDOM.createRoot(container);
-      root.render(React.createElement(App));
-    </script>
-  </head>
-  <body>
-    <div id="graphiql">Loading\u2026</div>
-  </body>
-</html>`;
+      });
+    }
+    const res = await next(req, ctx);
+    const headers = new Headers(res.headers);
+    headers.set("X-RateLimit-Limit", String(max));
+    headers.set("X-RateLimit-Remaining", String(remaining));
+    headers.set("X-RateLimit-Reset", String(Math.ceil(entry.reset / 1e3)));
+    return new Response(res.body, { status: res.status, statusText: res.statusText, headers });
+  };
 }
 
-// tsx.ts
-import { createElement, createContext, useContext } from "react";
-import { renderToReadableStream } from "react-dom/server";
-import * as esbuild from "esbuild";
-import { readdirSync, statSync, existsSync, mkdirSync } from "node:fs";
-import { join, relative, resolve, sep, dirname } from "node:path";
-import { pathToFileURL } from "node:url";
-import { createHash } from "node:crypto";
-var TsxContext = createContext({ params: {}, query: {} });
-function useTsx() {
-  return useContext(TsxContext);
-}
-function id(s) {
-  return createHash("md5").update(s).digest("hex").slice(0, 8);
-}
-function concatUint8(chunks) {
-  const len = chunks.reduce((a, c) => a + c.length, 0);
-  const out = new Uint8Array(len);
-  let off = 0;
-  for (const c of chunks) {
-    out.set(c, off);
-    off += c.length;
-  }
-  return out;
-}
-async function readStream(stream) {
-  const chunks = [];
-  const reader = stream.getReader();
-  while (true) {
-    const { done, value } = await reader.read();
-    if (done) break;
-    chunks.push(value);
-  }
-  return new TextDecoder().decode(concatUint8(chunks));
-}
-function scanPages(dir) {
-  const pages = [];
-  function walk(current) {
-    let entries;
-    try {
-      entries = readdirSync(current);
-    } catch {
-      return;
+// compress.ts
+import { gzipSync, brotliCompressSync, constants } from "node:zlib";
+function compress(options) {
+  const level = options?.level ?? 6;
+  const threshold = options?.threshold ?? 1024;
+  return async (req, ctx, next) => {
+    const accept = req.headers.get("accept-encoding") ?? "";
+    const useBrotli = accept.includes("br");
+    const useGzip = !useBrotli && accept.includes("gzip");
+    const useDeflate = !useBrotli && !useGzip && accept.includes("deflate");
+    if (!useBrotli && !useGzip && !useDeflate) {
+      return next(req, ctx);
     }
-    const dirs = [];
-    for (const name of entries) {
-      const full = join(current, name);
-      const st = statSync(full);
-      if (st.isDirectory()) {
-        if (!name.startsWith(".")) dirs.push(full);
-      }
+    const res = await next(req, ctx);
+    if (res.status === 304 || res.status === 204 || res.status < 200 || res.status >= 300) {
+      return res;
     }
-    const pagePath = join(current, "page.tsx");
-    const tsPagePath = join(current, "page.ts");
-    let entryPath = "";
-    if (existsSync(pagePath)) {
-      entryPath = pagePath;
-    } else if (existsSync(tsPagePath)) {
-      entryPath = tsPagePath;
+    const ce = res.headers.get("content-encoding");
+    if (ce) return res;
+    const ct = res.headers.get("content-type") ?? "";
+    if (!ct || ct.startsWith("audio/") || ct.startsWith("video/") || ct.startsWith("image/") || ct === "application/zip") {
+      return res;
     }
-    if (entryPath) {
-      let relPath = relative(dir, entryPath).replace(sep, "/");
-      relPath = relPath.replace(/\/page\.tsx?$/, "");
-      relPath = relPath.replace(/^page\.tsx?$/, "");
-      const route = filePathToRoute(relPath);
-      const layouts = resolveLayouts(current, dir);
-      const loadPath = existsSync(join(current, "load.ts")) ? join(current, "load.ts") : void 0;
-      const rPath = existsSync(join(current, "route.ts")) ? join(current, "route.ts") : void 0;
-      pages.push({
-        route,
-        entryPath,
-        loadPath,
-        layouts,
-        routePath: rPath
+    const body = await res.bytes();
+    if (body.byteLength < threshold) return res;
+    let compressed;
+    let encoding;
+    if (useBrotli) {
+      compressed = brotliCompressSync(body, {
+        params: { [constants.BROTLI_PARAM_QUALITY]: Math.min(level, 11) }
       });
-    } else {
-      const rPath = join(current, "route.ts");
-      if (existsSync(rPath)) {
-        let relPath = relative(dir, rPath).replace(sep, "/");
-        relPath = relPath.replace(/\/route\.tsx?$/, "");
-        const route = filePathToRoute(relPath);
-        pages.push({
-          route,
-          entryPath: "",
-          layouts: [],
-          routePath: rPath,
-          routeOnly: true
-        });
-      }
+      encoding = "br";
+    } else if (useGzip) {
+      compressed = gzipSync(body, { level: Math.min(level, 9) });
+      encoding = "gzip";
+    } else {
+      compressed = gzipSync(body, { level: Math.min(level, 9) });
+      encoding = "deflate";
     }
-    for (const d of dirs) walk(d);
-  }
-  walk(dir);
-  return pages;
-}
-function filePathToRoute(relPath) {
-  let route = relPath.replace(/\\/g, "/");
-  route = route.replace(/\[\.\.\.(\w+)\]/g, "*");
-  route = route.replace(/\[(\w+)\]/g, ":$1");
-  return route.startsWith("/") ? route : "/" + route;
+    const headers = new Headers(res.headers);
+    headers.set("Content-Encoding", encoding);
+    headers.set("Content-Length", String(compressed.byteLength));
+    headers.delete("Content-Range");
+    headers.set("Vary", "Accept-Encoding");
+    return new Response(compressed, {
+      status: res.status,
+      statusText: res.statusText,
+      headers
+    });
+  };
 }
-function resolveLayouts(dir, pagesDir) {
-  const layouts = [];
-  let current = dir;
-  while (current.startsWith(pagesDir)) {
-    const p = join(current, "layout.tsx");
-    if (existsSync(p)) {
-      layouts.push(p);
+
+// graphql.ts
+import { buildSchema, graphql as executeGraphQL } from "graphql";
+import { makeExecutableSchema } from "@graphql-tools/schema";
+function parseParamsFromGet(url) {
+  const query = url.searchParams.get("query");
+  if (!query) return null;
+  let variables = {};
+  const variablesStr = url.searchParams.get("variables");
+  if (variablesStr) {
+    try {
+      variables = JSON.parse(variablesStr);
+    } catch {
+      return null;
     }
-    const parent = dirname(current);
-    if (parent === current) break;
-    current = parent;
   }
-  return layouts.reverse();
+  return { query, variables, operationName: url.searchParams.get("operationName") || void 0 };
 }
-async function compileAll(files, outDir, platform) {
-  const entryPoints = {};
-  for (const f of files) {
-    entryPoints[id(f)] = f;
+async function parseParamsFromPost(req) {
+  try {
+    const body = await req.json();
+    if (!body.query) return null;
+    return { query: body.query, variables: body.variables || {}, operationName: body.operationName };
+  } catch {
+    return null;
   }
-  const isBrowser = platform === "browser";
-  await esbuild.build({
-    entryPoints,
-    outdir: outDir,
-    format: "esm",
-    platform: "node",
-    jsx: "automatic",
-    jsxImportSource: "react",
-    bundle: true,
-    external: isBrowser ? void 0 : [
-      "react",
-      "react-dom",
-      "esbuild",
-      "graphql",
-      "ws",
-      "zod",
-      "@graphql-tools/schema",
-      "ai"
-    ],
-    write: true,
-    allowOverwrite: true
-  });
 }
-function compiledUrl(filePath, outDir) {
-  const hash = id(join(outDir, id(filePath)));
-  const p = join(outDir, id(filePath) + ".js");
-  return pathToFileURL(p).href;
+function buildSchemaFromOptions(options) {
+  if (typeof options.schema === "string") {
+    return options.resolvers ? makeExecutableSchema({ typeDefs: options.schema, resolvers: options.resolvers }) : buildSchema(options.schema);
+  }
+  return options.schema;
 }
-var clientBundleCache = /* @__PURE__ */ new Map();
-var clientRouteLog = /* @__PURE__ */ new WeakMap();
-async function getOrBuildClientBundle(entryPath, layoutPaths, pagesDir, router) {
-  const key = id(entryPath);
-  const url = `/__wfw/client/${key}.js`;
-  if (!clientRouteLog.get(router)?.has(url)) {
-    let buf = clientBundleCache.get(key);
-    if (!buf) {
-      try {
-        const nested = layoutPaths.slice(1);
-        const layoutsImport = nested.map(
-          (p, i) => `import L${i} from${JSON.stringify(p)};`
-        ).join("");
-        const layoutsWrap = nested.map((_, i) => {
-          const idx = nested.length - 1 - i;
-          return `el=createElement(L${idx},null,el);`;
-        }).join("");
-        const code = [
-          `import{hydrateRoot}from'react-dom/client';`,
-          `import{createElement}from'react';`,
-          `import P from${JSON.stringify(entryPath)};`,
-          layoutsImport,
-          `const p=window.__WEIFUWU_PROPS;`,
-          `let el=createElement(P,p);`,
-          layoutsWrap,
-          `hydrateRoot(document.getElementById('__weifuwu_root'),el);`
-        ].join("");
-        const result = await esbuild.build({
-          stdin: { contents: code, loader: "tsx", resolveDir: pagesDir },
-          bundle: true,
-          format: "esm",
-          jsx: "automatic",
-          jsxImportSource: "react",
-          write: false,
-          minify: true
-        });
-        buf = result.outputFiles[0].contents;
-        clientBundleCache.set(key, buf);
-      } catch (err) {
-        console.error("hydration bundle failed:", err);
-        return null;
+async function executeQuery(schema, params, options, req, ctx) {
+  const contextValue = options.context ? await options.context(req, ctx) : ctx;
+  const result = await executeGraphQL({
+    schema,
+    source: params.query,
+    rootValue: options.rootValue,
+    contextValue,
+    variableValues: params.variables,
+    operationName: params.operationName
+  });
+  return Response.json(result, { status: result.errors ? 400 : 200 });
+}
+function graphiqlHTML(endpoint) {
+  return `<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>GraphiQL</title>
+    <style>body { margin: 0; } #graphiql { height: 100dvh; }</style>
+    <link rel="stylesheet" href="https://esm.sh/graphiql@5.2.2/dist/style.css" />
+    <script type="importmap">
+      {
+        "imports": {
+          "react": "https://esm.sh/react@19.2.5",
+          "react/": "https://esm.sh/react@19.2.5/",
+          "react-dom": "https://esm.sh/react-dom@19.2.5",
+          "react-dom/": "https://esm.sh/react-dom@19.2.5/",
+          "graphiql": "https://esm.sh/graphiql@5.2.2?standalone&external=react,react-dom,@graphiql/react,graphql",
+          "graphiql/": "https://esm.sh/graphiql@5.2.2/",
+          "@graphiql/react": "https://esm.sh/@graphiql/react@0.37.3?standalone&external=react,react-dom,graphql,@graphiql/toolkit,@emotion/is-prop-valid",
+          "@graphiql/toolkit": "https://esm.sh/@graphiql/toolkit@0.11.3?standalone&external=graphql",
+          "graphql": "https://esm.sh/graphql@16.13.2",
+          "@emotion/is-prop-valid": "data:text/javascript,"
+        }
       }
-    }
-    router.get(url, () => new Response(buf, {
-      headers: { "content-type": "application/javascript; charset=utf-8" }
-    }));
-    const set = clientRouteLog.get(router) ?? /* @__PURE__ */ new Set();
-    set.add(url);
-    clientRouteLog.set(router, set);
-  }
-  return { url };
+    </script>
+    <script type="module">
+      import React from 'react';
+      import ReactDOM from 'react-dom/client';
+      import { GraphiQL } from 'graphiql';
+      import { createGraphiQLFetcher } from '@graphiql/toolkit';
+      import 'graphiql/setup-workers/esm.sh';
+
+      const fetcher = createGraphiQLFetcher({ url: "${endpoint}" });
+
+      function App() {
+        return React.createElement(GraphiQL, { fetcher });
+      }
+
+      const container = document.getElementById('graphiql');
+      const root = ReactDOM.createRoot(container);
+      root.render(React.createElement(App));
+    </script>
+  </head>
+  <body>
+    <div id="graphiql">Loading\u2026</div>
+  </body>
+</html>`;
 }
-function makeSsrHandler(Component, loadFn, layouts, entryPath, layoutPaths, pagesDir, router) {
-  return async (req, ctx) => {
-    const loadProps = loadFn ? await loadFn({ params: ctx.params, query: ctx.query }) : {};
-    const allProps = { ...loadProps, params: ctx.params, query: ctx.query };
-    let element = createElement(Component, allProps);
-    for (let i = layouts.length - 1; i >= 0; i--) {
-      const isRoot = i === 0;
-      element = createElement(
-        layouts[i],
-        isRoot ? { children: element, req, ctx } : { children: element }
-      );
+function graphql(handler) {
+  const r = new Router();
+  r.get("/", async (req, ctx) => {
+    const options = await handler(req, ctx);
+    const schema = buildSchemaFromOptions(options);
+    const url = new URL(req.url);
+    if (options.graphiql && !url.searchParams.has("query")) {
+      return new Response(graphiqlHTML(url.pathname), {
+        status: 200,
+        headers: { "Content-Type": "text/html" }
+      });
     }
-    element = createElement(TsxContext.Provider, {
-      value: { params: ctx.params, query: ctx.query, user: ctx.user, parsed: ctx.parsed }
-    }, element);
-    const stream = await renderToReadableStream(element);
-    const body = await readStream(stream);
-    const scripts = [];
-    scripts.push(`<script>window.__WEIFUWU_PROPS=${JSON.stringify(allProps)}</script>`);
-    const bundle = await getOrBuildClientBundle(entryPath, layoutPaths, pagesDir, router);
-    if (bundle) {
-      scripts.push(`<script type="module" src="${bundle.url}"></script>`);
+    const params = parseParamsFromGet(url);
+    if (!params) {
+      return Response.json({ errors: [{ message: "Missing query" }] }, { status: 400 });
     }
-    const html = `<!DOCTYPE html>
-${body}
-${scripts.join("\n")}`;
-    return new Response(html, {
-      headers: { "content-type": "text/html; charset=utf-8" }
-    });
-  };
+    return executeQuery(schema, params, options, req, ctx);
+  });
+  r.post("/", async (req, ctx) => {
+    const options = await handler(req, ctx);
+    const schema = buildSchemaFromOptions(options);
+    const params = await parseParamsFromPost(req);
+    if (!params) {
+      return Response.json({ errors: [{ message: "Missing query" }] }, { status: 400 });
+    }
+    return executeQuery(schema, params, options, req, ctx);
+  });
+  return r;
 }
-async function tsx(options) {
-  const pagesDir = resolve(options.dir);
-  const outDir = join(pagesDir, "..", ".weifuwu", "ssr");
-  const pages = scanPages(pagesDir);
-  if (pages.length === 0) return new Router();
-  const allFiles = /* @__PURE__ */ new Set();
-  for (const p of pages) {
-    if (p.entryPath) allFiles.add(p.entryPath);
-    if (p.loadPath) allFiles.add(p.loadPath);
-    for (const lp of p.layouts) allFiles.add(lp);
-    if (p.routePath) allFiles.add(p.routePath);
-  }
-  const nfPath = join(pagesDir, "not-found.tsx");
-  const hasNotFound = existsSync(nfPath);
-  if (hasNotFound) {
-    allFiles.add(nfPath);
-    const rootLayouts = resolveLayouts(pagesDir, pagesDir);
-    for (const lp of rootLayouts) allFiles.add(lp);
-  }
-  mkdirSync(outDir, { recursive: true });
-  await compileAll([...allFiles], outDir, "node");
-  const router = new Router();
-  for (const p of pages) {
-    if (p.routeOnly && p.routePath) {
-      const rUrl = compiledUrl(p.routePath, outDir);
-      const modR = await import(rUrl);
-      const methods = ["GET", "POST", "PUT", "DELETE", "PATCH", "HEAD", "OPTIONS"];
-      for (const method of methods) {
-        if (modR[method]) {
-          router.route(method, p.route, modR[method]);
-        }
-      }
-      continue;
+
+// ai.ts
+import { streamText } from "ai";
+function ai(handler) {
+  const r = new Router();
+  r.post("/", async (req, ctx) => {
+    const options = await handler(req, ctx);
+    const result = streamText(options);
+    return result.toTextStreamResponse();
+  });
+  return r;
+}
+
+// workflow/tool.ts
+function tool(def) {
+  return {
+    name: def.name ?? "",
+    description: def.description,
+    inputSchema: def.inputSchema,
+    execute: def.execute
+  };
+}
+
+// workflow/reference.ts
+function getByPath(obj, path) {
+  let current = obj;
+  for (const key of path) {
+    if (current === null || current === void 0) return void 0;
+    if (typeof current === "object" && key in current) {
+      current = current[key];
+    } else {
+      return void 0;
     }
-    const url = compiledUrl(p.entryPath, outDir);
-    const mod = await import(url);
-    const Component = mod.default;
-    let loadFn;
-    if (p.loadPath) {
-      const loadUrl = compiledUrl(p.loadPath, outDir);
-      const modLoad = await import(loadUrl);
-      loadFn = modLoad.default;
+  }
+  return current;
+}
+function resolveRef(path, ctx) {
+  if (path.startsWith("$nodes.")) {
+    const afterNodes = path.slice(7);
+    const dotIdx = afterNodes.indexOf(".");
+    if (dotIdx === -1) {
+      return ctx.nodeOutputs.get(afterNodes);
     }
-    const layoutComponents = [];
-    for (const lp of p.layouts) {
-      const lUrl = compiledUrl(lp, outDir);
-      const modL = await import(lUrl);
-      layoutComponents.push(modL.default);
+    const id2 = afterNodes.slice(0, dotIdx);
+    const propPath = afterNodes.slice(dotIdx + 1);
+    const output = ctx.nodeOutputs.get(id2);
+    if (output === void 0) {
+      throw new Error(`Node "${id2}" has no output yet`);
     }
-    const handler = makeSsrHandler(
-      Component,
-      loadFn,
-      layoutComponents,
-      p.entryPath,
-      p.layouts,
-      pagesDir,
-      router
-    );
-    router.get(p.route, handler);
-    if (p.routePath) {
-      const rUrl = compiledUrl(p.routePath, outDir);
-      const modR = await import(rUrl);
-      const methods = ["POST", "PUT", "DELETE", "PATCH", "HEAD", "OPTIONS"];
-      for (const method of methods) {
-        if (modR[method]) {
-          router.route(method, p.route, modR[method]);
-        }
-      }
+    if (propPath.startsWith("output")) {
+      return getByPath(output, propPath.slice(7).split(".").filter(Boolean));
     }
+    return getByPath(output, propPath.split("."));
   }
-  if (hasNotFound) {
-    const nfUrl = compiledUrl(nfPath, outDir);
-    const modNf = await import(nfUrl);
-    const NfComponent = modNf.default;
-    const nfLayouts = [];
-    const rootLayouts = resolveLayouts(pagesDir, pagesDir);
-    for (const lp of rootLayouts) {
-      const lUrl = compiledUrl(lp, outDir);
-      const modL = await import(lUrl);
-      nfLayouts.push(modL.default);
+  if (path.startsWith("$var.")) {
+    const name = path.slice(5);
+    if (!ctx.variables.has(name)) {
+      throw new Error(`Variable "${name}" is not defined`);
     }
-    const handler = async (req, ctx) => {
-      let element = createElement(NfComponent, { params: ctx.params, query: ctx.query });
-      for (let i = nfLayouts.length - 1; i >= 0; i--) {
-        element = createElement(nfLayouts[i], { children: element });
-      }
-      element = createElement(TsxContext.Provider, {
-        value: { params: ctx.params, query: ctx.query, user: ctx.user, parsed: ctx.parsed }
-      }, element);
-      const stream = await renderToReadableStream(element);
-      const body = await readStream(stream);
-      const html = `<!DOCTYPE html>
-${body}`;
-      return new Response(html, {
-        status: 404,
-        headers: { "content-type": "text/html; charset=utf-8" }
-      });
-    };
-    router.all("/*", handler);
+    return ctx.variables.get(name);
   }
-  return router;
+  if (path.startsWith("$input.")) {
+    const key = path.slice(7);
+    return ctx.input[key];
+  }
+  if (path === "true") return true;
+  if (path === "false") return false;
+  if (path === "null") return null;
+  const num = Number(path);
+  if (!isNaN(num) && path.trim() !== "") return num;
+  return path;
 }
-
-// middleware.ts
-function logger(options) {
-  return async (req, ctx, next) => {
-    const start = Date.now();
-    const url = new URL(req.url);
-    const res = await next(req, ctx);
-    const ms = Date.now() - start;
-    if (options?.format === "combined") {
-      console.log(`${req.method} ${url.pathname}${url.search} ${res.status} ${ms}ms`);
-    } else {
-      console.log(`${req.method} ${url.pathname} ${res.status} ${ms}ms`);
+function resolveValue(v, ctx) {
+  if (typeof v === "string" && v.startsWith("$")) {
+    return resolveRef(v, ctx);
+  }
+  if (Array.isArray(v)) {
+    return v.map((item) => resolveValue(item, ctx));
+  }
+  if (typeof v === "object" && v !== null) {
+    const result = {};
+    for (const [k, val] of Object.entries(v)) {
+      result[k] = resolveValue(val, ctx);
     }
-    return res;
-  };
+    return result;
+  }
+  return v;
 }
-function cors(options) {
-  const opts = {
-    origin: "*",
-    methods: ["GET", "HEAD", "PUT", "PATCH", "POST", "DELETE"],
-    allowedHeaders: ["Content-Type", "Authorization"],
-    ...options
-  };
-  function resolveOrigin(requestOrigin) {
-    if (typeof opts.origin === "string") return opts.origin === "*" ? "*" : opts.origin;
-    if (Array.isArray(opts.origin)) {
-      return opts.origin.includes(requestOrigin) ? requestOrigin : "";
+
+// workflow/nodes.ts
+function evaluateExpression(expr, ctx) {
+  const operators = [
+    { op: "===", fn: (a, b) => a === b },
+    { op: "!==", fn: (a, b) => a !== b },
+    { op: ">=", fn: (a, b) => Number(a) >= Number(b) },
+    { op: "<=", fn: (a, b) => Number(a) <= Number(b) },
+    { op: ">", fn: (a, b) => Number(a) > Number(b) },
+    { op: "<", fn: (a, b) => Number(a) < Number(b) },
+    { op: "==", fn: (a, b) => a == b },
+    { op: "!=", fn: (a, b) => a != b },
+    { op: "+", fn: (a, b) => Number(a) + Number(b) },
+    { op: "-", fn: (a, b) => Number(a) - Number(b) },
+    { op: "*", fn: (a, b) => Number(a) * Number(b) },
+    { op: "/", fn: (a, b) => Number(a) / Number(b) },
+    { op: "%", fn: (a, b) => Number(a) % Number(b) },
+    { op: "&&", fn: (a, b) => Boolean(a) && Boolean(b) },
+    { op: "||", fn: (a, b) => Boolean(a) || Boolean(b) }
+  ];
+  for (const { op, fn } of operators) {
+    const idx = expr.indexOf(op);
+    if (idx > 0) {
+      const leftRaw = expr.slice(0, idx).trim();
+      const rightRaw = expr.slice(idx + op.length).trim();
+      const left = resolveValue(leftRaw, ctx);
+      const right = resolveValue(rightRaw, ctx);
+      return fn(left, right);
     }
-    const result = opts.origin(requestOrigin);
-    if (typeof result === "boolean") return result ? requestOrigin : "";
-    if (typeof result === "string") return result;
-    return "";
   }
-  function setCORSHeaders(res, acao) {
-    if (!acao) return res;
-    const headers = new Headers(res.headers);
-    headers.set("Access-Control-Allow-Origin", acao);
-    if (opts.credentials) headers.set("Access-Control-Allow-Credentials", "true");
-    if (opts.exposedHeaders?.length) headers.set("Access-Control-Expose-Headers", opts.exposedHeaders.join(", "));
-    headers.set("Vary", "Origin");
-    return new Response(res.body, { status: res.status, statusText: res.statusText, headers });
+  const trimmed = expr.trim();
+  if (trimmed === "true") return true;
+  if (trimmed === "false") return false;
+  if (trimmed === "null") return null;
+  const num = Number(trimmed);
+  if (!isNaN(num) && trimmed !== "") return num;
+  return resolveValue(expr, ctx);
+}
+async function executeEval(node, ctx) {
+  const expression = node.input.expression;
+  if (!expression) throw new Error('eval node requires "expression" field');
+  const result = evaluateExpression(expression, ctx);
+  return { result };
+}
+async function executeSet(node, ctx) {
+  const name = node.input.name;
+  const value = node.input.value;
+  if (!name) throw new Error('set node requires "name" field');
+  let resolved;
+  if (typeof value === "string") {
+    resolved = evaluateExpression(value, ctx);
+  } else {
+    resolved = resolveValue(value ?? null, ctx);
   }
-  return (req, ctx, next) => {
-    const requestOrigin = req.headers.get("origin") ?? "";
-    const acao = resolveOrigin(requestOrigin);
-    if (req.method === "OPTIONS" && acao) {
-      const headers = new Headers();
-      headers.set("Access-Control-Allow-Origin", acao);
-      headers.set("Access-Control-Allow-Methods", opts.methods.join(", "));
-      headers.set("Access-Control-Allow-Headers", opts.allowedHeaders.join(", "));
-      if (opts.credentials) headers.set("Access-Control-Allow-Credentials", "true");
-      if (opts.maxAge != null) headers.set("Access-Control-Max-Age", String(opts.maxAge));
-      headers.set("Vary", "Origin");
-      return new Response(null, { status: 204, headers });
-    }
-    if (!acao) return next(req, ctx);
-    return Promise.resolve(next(req, ctx)).then((res) => setCORSHeaders(res, acao));
-  };
+  ctx.variables.set(name, resolved);
+  return resolved;
 }
-function auth(options) {
-  return async (req, ctx, next) => {
-    const headerName = options.header ?? "Authorization";
-    let from = "header";
-    let header = req.headers.get(headerName);
-    let token = "";
-    if (header) {
-      token = header;
-      if (headerName.toLowerCase() === "authorization") {
-        const parts = header.split(" ");
-        if (parts[0]?.toLowerCase() === "bearer") {
-          token = parts.slice(1).join(" ");
-        }
-      }
-    } else {
-      const url = new URL(req.url);
-      const qsToken = url.searchParams.get("access_token");
-      if (qsToken) {
-        token = qsToken;
-        from = "query";
+async function executeGet(node, ctx) {
+  const name = node.input.name;
+  if (!name) throw new Error('get node requires "name" field');
+  if (!ctx.variables.has(name)) {
+    throw new Error(`Variable "${name}" is not defined`);
+  }
+  return ctx.variables.get(name);
+}
+async function executeIf(node, ctx) {
+  const conditions = node.conditions ?? [];
+  for (const condition of conditions) {
+    const test = typeof condition.test === "string" ? Boolean(resolveValue(condition.test, ctx)) : condition.test;
+    if (test && condition.body) {
+      let lastOutput = void 0;
+      for (const bodyNode of condition.body) {
+        lastOutput = await executeNode(bodyNode, ctx);
       }
+      return lastOutput;
     }
-    if (!token) {
-      return new Response("Unauthorized", {
-        status: 401,
-        headers: headerName.toLowerCase() === "authorization" ? { "WWW-Authenticate": "Bearer" } : void 0
-      });
+  }
+  return void 0;
+}
+async function executeWhile(node, ctx) {
+  const conditionExpr = node.input.condition;
+  if (!conditionExpr) throw new Error('while node requires "condition" field');
+  let lastOutput = void 0;
+  let iterations = 0;
+  const maxIterations = 1e3;
+  while (iterations < maxIterations) {
+    iterations++;
+    ctx.stepCount++;
+    if (ctx.stepCount > ctx.maxSteps) {
+      throw new Error(`Step limit exceeded (${ctx.maxSteps})`);
     }
-    if (options.proxy) {
-      const proxyUrl = typeof options.proxy === "string" ? new URL(options.proxy) : options.proxy;
-      const proxyHeaders = {};
-      if (from === "header" && header) {
-        proxyHeaders[headerName] = header;
-      } else {
-        proxyUrl.searchParams.set("access_token", token);
-      }
-      for (const name of ["x-forwarded-for", "x-real-ip", "user-agent", "content-type"]) {
-        const v = req.headers.get(name);
-        if (v) proxyHeaders[name] = v;
-      }
-      const proxyRes = await fetch(proxyUrl.href, { headers: proxyHeaders });
-      if (proxyRes.status >= 400) {
-        return new Response(await proxyRes.text() || "Forbidden", { status: proxyRes.status });
-      }
-      let userData = void 0;
-      if (proxyRes.status === 200) {
-        const ct = proxyRes.headers.get("content-type");
-        if (ct?.includes("application/json")) {
-          try {
-            userData = await proxyRes.json();
-          } catch {
-          }
-        }
-      }
-      ctx.user = userData;
-      return next(req, ctx);
+    const condition = Boolean(evaluateExpression(conditionExpr, ctx));
+    if (!condition) break;
+    for (const bodyNode of node.body ?? []) {
+      lastOutput = await executeNode(bodyNode, ctx);
     }
-    if (options.token) {
-      if (token !== options.token) {
-        return new Response("Forbidden", { status: 403 });
+  }
+  return lastOutput;
+}
+async function executeCall(node, ctx) {
+  const toolName = node.input.tool;
+  const args = node.input.args ?? {};
+  if (toolName && ctx.toolRegistry.has(toolName)) {
+    const tool3 = ctx.toolRegistry.get(toolName);
+    const resolvedInput = resolveValue(args, ctx);
+    const parsed = tool3.inputSchema.parse(resolvedInput);
+    return tool3.execute(parsed, {
+      nodeId: node.id,
+      workflowId: ctx.workflowId,
+      onStream: async (event) => {
+        if (ctx.sseManager && ctx.workflowId) {
+          ctx.sseManager.send(ctx.workflowId, { event: "llm-stream", data: { nodeId: node.id, ...event } });
+        }
       }
-      return next(req, ctx);
+    });
+  }
+  const functionName = node.input.function;
+  if (functionName && ctx.functions[functionName]) {
+    const fn = ctx.functions[functionName];
+    const prevFunctions = ctx.functions;
+    const prevInput = ctx.input;
+    ctx.input = resolveValue(args, ctx);
+    let lastOutput = void 0;
+    for (const bodyNode of fn.workflow.nodes) {
+      lastOutput = await executeNode(bodyNode, ctx);
     }
-    if (options.verify) {
-      const result = await options.verify(token, req);
-      if (!result) {
-        return new Response("Forbidden", { status: 403 });
-      }
-      if (typeof result === "object" && result !== null) {
-        ctx.user = result;
-      }
-      return next(req, ctx);
+    ctx.input = prevInput;
+    return lastOutput;
+  }
+  throw new Error(`call node: tool "${toolName ?? functionName}" not found`);
+}
+async function executeHttp(node, ctx) {
+  const input = resolveValue(node.input, ctx);
+  const url = input.url;
+  if (!url) throw new Error('http node requires "url" field');
+  const controller = new AbortController();
+  const timeout = input.timeout ?? 3e4;
+  const timer = setTimeout(() => controller.abort(), timeout);
+  try {
+    const fetchInit = {
+      method: input.method ?? "GET",
+      headers: input.headers ?? {},
+      signal: controller.signal
+    };
+    if (input.body && fetchInit.method !== "GET") {
+      fetchInit.body = JSON.stringify(input.body);
     }
-    return next(req, ctx);
-  };
+    const response = await fetch(url, fetchInit);
+    const contentType = response.headers.get("content-type") ?? "";
+    const body = contentType.includes("application/json") ? await response.json() : await response.text();
+    return {
+      status: response.status,
+      statusText: response.statusText,
+      headers: Object.fromEntries(response.headers.entries()),
+      body
+    };
+  } finally {
+    clearTimeout(timer);
+  }
+}
+var executors = {
+  eval: executeEval,
+  set: executeSet,
+  get: executeGet,
+  if: executeIf,
+  while: executeWhile,
+  call: executeCall,
+  http: executeHttp
+};
+async function executeNode(node, ctx) {
+  const executor = executors[node.tool];
+  if (!executor) {
+    throw new Error(`Unknown node type: "${node.tool}"`);
+  }
+  return executor(node, ctx);
 }
 
-// static.ts
-import { createHash as createHash2 } from "node:crypto";
-import { open } from "node:fs/promises";
-import { extname, resolve as resolve2, normalize, sep as sep2 } from "node:path";
-function serveStatic(root, options) {
-  const rootDir = resolve2(root);
-  const opts = options ?? {};
-  return async (req, ctx) => {
-    const relativePath = ctx.params["*"] ?? new URL(req.url).pathname.slice(1);
-    const decoded = decodeURIComponent(relativePath);
-    if (decoded.includes("..") || decoded.includes("\0")) {
-      return new Response("Forbidden", { status: 403 });
-    }
-    let filePath = normalize(resolve2(rootDir, decoded));
-    if (!filePath.startsWith(rootDir + sep2) && filePath !== rootDir) {
-      return new Response("Forbidden", { status: 403 });
+// workflow/llm.ts
+function buildToolsDescription(tools) {
+  return Object.entries(tools).map(([key, t]) => {
+    const name = t.name || key;
+    const schema = t.inputSchema;
+    return `- ${name}: ${t.description}
+  Input schema: describe as JSON object fields`;
+  }).join("\n");
+}
+var SYSTEM_PROMPT_TEMPLATE = `You are a workflow generator. Given a user goal and available tools, output a workflow JSON.
+
+Available tools:
+{{TOOLS}}
+
+Workflow format:
+{
+  "name": "workflow name",
+  "nodes": [
+    {
+      "id": "step1",
+      "tool": "set",
+      "input": { "name": "varName", "value": "initialValue" }
+    },
+    {
+      "id": "step2",
+      "tool": "call",
+      "input": { "tool": "toolName", "args": { "param1": "$var.varName" } }
+    },
+    {
+      "id": "step3",
+      "tool": "if",
+      "input": {},
+      "conditions": [
+        { "test": "$nodes.step2.output.someField", "body": [
+          { "id": "step4", "tool": "call", "input": { "tool": "toolName", "args": {} } }
+        ]}
+      ]
     }
-    let fileHandle;
-    try {
-      fileHandle = await open(filePath, "r");
-      const stat = await fileHandle.stat();
-      if (stat.isDirectory()) {
-        await fileHandle.close();
-        const indexFile = opts.index ?? "index.html";
-        filePath = resolve2(filePath, indexFile);
-        if (!filePath.startsWith(rootDir + sep2)) {
-          return new Response("Forbidden", { status: 403 });
-        }
-        fileHandle = await open(filePath, "r");
-        const dirStat = await fileHandle.stat();
-        if (!dirStat.isFile()) {
-          await fileHandle.close();
-          return new Response("Not Found", { status: 404 });
-        }
-      }
-      const mimeType = MIME_TYPES[extname(filePath).toLowerCase()] ?? "application/octet-stream";
-      const etag = `"${createHash2("md5").update(`${stat.size}-${stat.mtimeMs}`).digest("hex")}"`;
-      const ifNoneMatch = req.headers.get("if-none-match");
-      if (ifNoneMatch === etag) {
-        await fileHandle.close();
-        return new Response(null, { status: 304 });
-      }
-      const ifModifiedSince = req.headers.get("if-modified-since");
-      if (ifModifiedSince && stat.mtimeMs <= new Date(ifModifiedSince).getTime()) {
-        await fileHandle.close();
-        return new Response(null, { status: 304 });
-      }
-      const headers = {
-        "Content-Type": mimeType,
-        "Content-Length": String(stat.size),
-        "ETag": etag,
-        "Last-Modified": stat.mtime.toUTCString(),
-        "Cache-Control": opts.immutable ? `public, max-age=${opts.maxAge ?? 31536e3}, immutable` : `public, max-age=${opts.maxAge ?? 0}`
-      };
-      const stream = fileHandle.readableWebStream();
-      return new Response(stream, { headers });
-    } catch (err) {
-      if (fileHandle) await fileHandle.close().catch(() => {
-      });
-      if (err?.code === "ENOENT") {
-        return new Response("Not Found", { status: 404 });
-      }
-      return new Response("Internal Server Error", { status: 500 });
+  ]
+}
+
+Node types:
+- eval: evaluate an expression. input: { expression: "..." }
+- set: assign a variable. input: { name, value }
+- get: read a variable. input: { name }
+- if: conditional branch. input: {}, conditions: [{ test, body }]
+- while: loop. input: { condition }, body: [nodes]
+- call: call a registered tool. input: { tool, args }
+- http: HTTP request. input: { url, method?, headers?, body? }
+
+Reference syntax:
+- $var.name - read a variable
+- $nodes.id.output - output of a previous node
+- $nodes.id.output.field - specific field of a node's output
+- $input.field - workflow input parameter
+
+Output ONLY valid JSON. No explanation, no markdown.`;
+async function generateWorkflow(goal, tools, generateFn) {
+  const toolsDesc = buildToolsDescription(tools);
+  const system = SYSTEM_PROMPT_TEMPLATE.replace("{{TOOLS}}", toolsDesc);
+  const result = await generateFn({
+    system,
+    messages: [{ role: "user", content: goal }]
+  });
+  const text = result.text.trim();
+  const jsonStart = text.indexOf("{");
+  const jsonEnd = text.lastIndexOf("}");
+  if (jsonStart === -1 || jsonEnd === -1) {
+    throw new Error(`LLM output is not valid JSON: ${text.slice(0, 200)}`);
+  }
+  const jsonStr = text.slice(jsonStart, jsonEnd + 1);
+  try {
+    const workflow2 = JSON.parse(jsonStr);
+    if (!workflow2.nodes || !Array.isArray(workflow2.nodes)) {
+      throw new Error("Generated workflow has no nodes array");
     }
-  };
+    return workflow2;
+  } catch (err) {
+    if (err instanceof SyntaxError) {
+      throw new Error(`Failed to parse LLM output as JSON: ${err.message}`);
+    }
+    throw err;
+  }
 }
-var MIME_TYPES = {
-  ".html": "text/html; charset=utf-8",
-  ".htm": "text/html; charset=utf-8",
-  ".css": "text/css; charset=utf-8",
-  ".js": "application/javascript; charset=utf-8",
-  ".mjs": "application/javascript; charset=utf-8",
-  ".json": "application/json",
-  ".png": "image/png",
-  ".jpg": "image/jpeg",
-  ".jpeg": "image/jpeg",
-  ".gif": "image/gif",
-  ".svg": "image/svg+xml",
-  ".ico": "image/x-icon",
-  ".webp": "image/webp",
-  ".avif": "image/avif",
-  ".woff": "font/woff",
-  ".woff2": "font/woff2",
-  ".ttf": "font/ttf",
-  ".otf": "font/otf",
-  ".eot": "application/vnd.ms-fontobject",
-  ".txt": "text/plain; charset=utf-8",
-  ".xml": "application/xml",
-  ".pdf": "application/pdf",
-  ".zip": "application/zip",
-  ".wasm": "application/wasm",
-  ".map": "application/json"
-};
 
-// validate.ts
-function validate(schemas) {
-  return async (req, ctx, next) => {
-    const parsed = {};
-    const issues = [];
-    if (schemas.params) {
-      const result = schemas.params.safeParse(ctx.params);
-      if (result.success) {
-        parsed.params = result.data;
-      } else {
-        issues.push(...result.error.issues.map((i) => ({
-          path: ["params", ...i.path.map(String)],
-          message: i.message
-        })));
+// workflow/engine.ts
+import { generateText } from "ai";
+function createWorkflowEngine(options) {
+  const toolRegistry = /* @__PURE__ */ new Map();
+  for (const [key, t] of Object.entries(options.tools)) {
+    t.name = t.name || key;
+    toolRegistry.set(t.name, t);
+  }
+  const states = /* @__PURE__ */ new Map();
+  async function execute(workflow2, opts) {
+    const ctx = {
+      variables: /* @__PURE__ */ new Map(),
+      nodeOutputs: /* @__PURE__ */ new Map(),
+      functions: workflow2.functions ?? {},
+      stepCount: 0,
+      maxSteps: opts?.maxSteps ?? 1e3,
+      input: opts?.initialInput ?? {},
+      toolRegistry,
+      sseManager: options.sseManager,
+      workflowId: opts?.workflowId
+    };
+    let lastOutput = void 0;
+    for (const node of workflow2.nodes) {
+      ctx.stepCount++;
+      if (ctx.stepCount > ctx.maxSteps) {
+        throw new Error(`Step limit exceeded (${ctx.maxSteps})`);
       }
+      options.sseManager?.send(ctx.workflowId ?? "", { event: "node-start", data: { nodeId: node.id, tool: node.tool, input: node.input } });
+      const output = await executeNode(node, ctx);
+      ctx.nodeOutputs.set(node.id, output);
+      lastOutput = output;
+      options.sseManager?.send(ctx.workflowId ?? "", { event: "node-end", data: { nodeId: node.id, output } });
     }
-    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
-        })));
-      }
+    return lastOutput;
+  }
+  async function runAsync(workflowId, workflow2, opts) {
+    const state = {
+      workflowId,
+      status: "running",
+      goal: workflow2.name ?? "",
+      startTime: Date.now()
+    };
+    states.set(workflowId, state);
+    const sse = options.sseManager;
+    sse?.send(workflowId, { event: "workflow-start", data: { workflowId, goal: state.goal } });
+    try {
+      const result = await execute(workflow2, { ...opts, workflowId });
+      state.status = "completed";
+      state.result = result;
+      state.endTime = Date.now();
+      sse?.send(workflowId, { event: "complete", data: { result, duration: state.endTime - state.startTime } });
+    } catch (err) {
+      state.status = "error";
+      state.error = err instanceof Error ? err.message : String(err);
+      state.endTime = Date.now();
+      sse?.send(workflowId, { event: "error", data: { error: state.error } });
+    } finally {
+      sse?.close(workflowId);
     }
-    if (schemas.headers) {
-      const rawHeaders = {};
-      req.headers.forEach((v, k) => {
-        rawHeaders[k] = v;
+  }
+  async function generateWorkflow2(goal) {
+    if (!options.model) {
+      throw new Error('LLM model is required for generateWorkflow. Pass "model" to createWorkflowEngine.');
+    }
+    return generateWorkflow(goal, options.tools, async (prompt) => {
+      const result = await generateText({
+        model: options.model,
+        system: prompt.system,
+        messages: prompt.messages
       });
-      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
-        })));
-      }
+      return { text: result.text };
+    });
+  }
+  return {
+    execute,
+    runAsync,
+    generateWorkflow: generateWorkflow2,
+    getState(workflowId) {
+      return states.get(workflowId);
     }
-    if (schemas.body) {
-      if (req.body === null) {
-        issues.push({ path: ["body"], message: "Request body is required" });
-      } else {
-        const bodyText = await req.text();
-        if (!bodyText && req.method !== "GET" && req.method !== "HEAD") {
-          issues.push({ path: ["body"], message: "Request body is required" });
-        } else {
-          let bodyValue;
+  };
+}
+
+// workflow/sse.ts
+function createSSEManager() {
+  const streams = /* @__PURE__ */ new Map();
+  const encoder = new TextEncoder();
+  function createStream(workflowId) {
+    const state = {
+      controller: null,
+      encoder,
+      closed: false,
+      buffer: []
+    };
+    const stream = new ReadableStream({
+      start(controller) {
+        state.controller = controller;
+        streams.set(workflowId, state);
+        for (const event of state.buffer) {
           try {
-            bodyValue = JSON.parse(bodyText);
+            controller.enqueue(encoder.encode(event));
           } catch {
-            bodyValue = bodyText;
-          }
-          const result = schemas.body.safeParse(bodyValue);
-          if (result.success) {
-            parsed.body = result.data;
-          } else {
-            issues.push(...result.error.issues.map((i) => ({
-              path: ["body", ...i.path.map(String)],
-              message: i.message
-            })));
+            break;
           }
         }
+        state.buffer = [];
+      },
+      cancel() {
+        state.closed = true;
+        streams.delete(workflowId);
+      }
+    });
+    return stream;
+  }
+  function send(workflowId, event) {
+    const state = streams.get(workflowId);
+    if (!state || state.closed) return;
+    const data = `event: ${event.event}
+data: ${JSON.stringify(event.data)}
+
+`;
+    if (state.controller) {
+      try {
+        state.controller.enqueue(encoder.encode(data));
+      } catch {
+        state.closed = true;
+        streams.delete(workflowId);
+      }
+    } else {
+      state.buffer.push(data);
+    }
+  }
+  function close(workflowId) {
+    const state = streams.get(workflowId);
+    if (!state) return;
+    state.closed = true;
+    streams.delete(workflowId);
+    try {
+      state.controller?.close();
+    } catch {
+    }
+  }
+  return { createStream, send, close };
+}
+
+// workflow/route.ts
+function workflow(handler) {
+  const r = new Router();
+  const sseManager = createSSEManager();
+  r.get("/:workflowId/events", async (req, ctx) => {
+    const stream = sseManager.createStream(ctx.params.workflowId);
+    return new Response(stream, {
+      headers: {
+        "Content-Type": "text/event-stream",
+        "Cache-Control": "no-cache",
+        "Connection": "keep-alive"
       }
+    });
+  });
+  r.post("/", async (req, ctx) => {
+    const options = await handler(req, ctx);
+    const engine = createWorkflowEngine({
+      tools: options.tools,
+      model: options.model,
+      sseManager: options.stream ? sseManager : void 0
+    });
+    const body = await req.json();
+    let wf;
+    if (body.goal && options.model) {
+      wf = await engine.generateWorkflow(body.goal);
+    } else if (body.workflow) {
+      wf = body.workflow;
+    } else if (body.nodes) {
+      wf = { nodes: body.nodes };
+    } else {
+      return Response.json(
+        { error: 'Provide "goal" (with model) or "workflow"/"nodes"' },
+        { status: 400 }
+      );
     }
-    if (issues.length > 0) {
-      return Response.json({ error: "Validation failed", issues }, { status: 400 });
+    if (options.stream && sseManager) {
+      const workflowId = crypto.randomUUID();
+      engine.runAsync(workflowId, wf);
+      return Response.json({ workflowId, eventsUrl: `/${workflowId}/events` });
     }
-    ctx.parsed = parsed;
-    return next(req, ctx);
-  };
+    const result = await engine.execute(wf);
+    return Response.json({ workflow: wf, result });
+  });
+  return r;
 }
 
-// cookie.ts
-function getCookies(req) {
-  const header = req.headers.get("cookie");
-  if (!header) return {};
-  const cookies = {};
-  for (const pair of header.split(";")) {
-    const idx = pair.indexOf("=");
-    if (idx === -1) continue;
-    const name = pair.slice(0, idx).trim();
-    const value = pair.slice(idx + 1).trim();
-    if (name) {
-      cookies[name] = decodeURIComponent(value);
+// postgres/client.ts
+import postgresFactory from "postgres";
+
+// postgres/table.ts
+import { z } from "zod";
+function unwrap(field) {
+  let inner = field;
+  while (inner instanceof z.ZodOptional || inner instanceof z.ZodNullable || inner instanceof z.ZodDefault || (inner.constructor.name === "ZodTransform" || inner._def?.type === "transform")) {
+    if (inner._def?.innerType) {
+      inner = inner._def.innerType;
+    } else {
+      break;
     }
   }
-  return cookies;
+  return inner;
 }
-function serializeCookie(name, value, options) {
-  const parts = [`${encodeURIComponent(name)}=${encodeURIComponent(value)}`];
-  if (options?.maxAge != null) parts.push(`Max-Age=${options.maxAge}`);
-  if (options?.expires) parts.push(`Expires=${options.expires.toUTCString()}`);
-  if (options?.domain) parts.push(`Domain=${options.domain}`);
-  if (options?.path) parts.push(`Path=${options.path}`);
-  if (options?.httpOnly) parts.push("HttpOnly");
-  if (options?.secure) parts.push("Secure");
-  if (options?.sameSite) parts.push(`SameSite=${options.sameSite}`);
-  return parts.join("; ");
+function isOptional(field) {
+  let inner = field;
+  while (true) {
+    if (inner instanceof z.ZodOptional) return true;
+    if (inner instanceof z.ZodNullable) return true;
+    if (inner instanceof z.ZodDefault) {
+      inner = inner._def.innerType;
+      continue;
+    }
+    if (inner._def?.type === "transform") {
+      inner = inner._def.innerType;
+      continue;
+    }
+    break;
+  }
+  return false;
 }
-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 hasUUIDCheck(field) {
+  const checks = field._def?.checks ?? [];
+  return checks.some((c) => c.type === "string" && c.def?.format === "uuid");
 }
-function deleteCookie(res, name, options) {
-  const headers = new Headers(res.headers);
-  headers.append("Set-Cookie", serializeCookie(name, "", { ...options, maxAge: 0 }));
-  return new Response(res.body, {
-    status: res.status,
-    statusText: res.statusText,
-    headers
+function detectSqlType(name, field, isPk) {
+  const inner = unwrap(field);
+  const nullable = isOptional(field);
+  const autoGenerate = isPk && name === "id";
+  if (isPk && name === "id" && inner instanceof z.ZodNumber) {
+    return { sqlType: "SERIAL", nullable: false, defaultExpr: null, autoGenerate: true };
+  }
+  if (isPk && name === "id" && typeof BigInt !== "undefined" && inner instanceof z.ZodBigInt) {
+    return { sqlType: "BIGSERIAL", nullable: false, defaultExpr: null, autoGenerate: true };
+  }
+  if (isPk && name === "id" && inner instanceof z.ZodString) {
+    if (hasUUIDCheck(inner)) {
+      return { sqlType: "UUID", nullable: false, defaultExpr: "gen_random_uuid()", autoGenerate: true };
+    }
+    return { sqlType: "TEXT", nullable: false, defaultExpr: null, autoGenerate: false };
+  }
+  let sqlType;
+  if (inner instanceof z.ZodNumber) {
+    sqlType = "INTEGER";
+  } else if (inner instanceof z.ZodString) {
+    sqlType = "TEXT";
+  } else if (inner instanceof z.ZodBoolean) {
+    sqlType = "BOOLEAN";
+  } else if (inner instanceof z.ZodDate) {
+    sqlType = "TIMESTAMPTZ";
+  } else if (inner instanceof z.ZodEnum) {
+    sqlType = "TEXT";
+  } else if (inner instanceof z.ZodArray) {
+    sqlType = "JSONB";
+  } else if (inner instanceof z.ZodObject) {
+    sqlType = "JSONB";
+  } else {
+    sqlType = "TEXT";
+  }
+  return { sqlType, nullable: nullable || autoGenerate, defaultExpr: null, autoGenerate };
+}
+function parseColumns(schema) {
+  const pkField = Object.keys(schema).find((k) => k === "id");
+  return Object.entries(schema).map(([name, field]) => {
+    const isPk = name === pkField;
+    const { sqlType, nullable, defaultExpr, autoGenerate } = detectSqlType(name, field, isPk);
+    return { name, sqlType, nullable: nullable || autoGenerate, isPrimaryKey: isPk, defaultExpr, autoGenerate };
   });
 }
-
-// upload.ts
-import { writeFile, mkdir } from "node:fs/promises";
-import { randomUUID } from "node:crypto";
-import { join as join2 } from "node:path";
-function upload(options) {
-  const saveDir = options?.dir;
-  return async (req, ctx, next) => {
-    const ct = req.headers.get("content-type") ?? "";
-    if (!ct.includes("multipart/form-data")) {
-      return next(req, ctx);
-    }
-    const match = ct.match(/boundary=(?:"([^"]+)"|([^;]+))/i);
-    if (!match) {
-      return Response.json({ error: "Missing boundary" }, { status: 400 });
-    }
-    const boundary = match[1] ?? match[2];
-    const body = await req.text();
-    const rawParts = body.split(`--${boundary}`).filter((p) => p && !p.startsWith("--") && !p.startsWith("\r\n--"));
-    const files = {};
-    const fields = {};
-    for (const raw of rawParts) {
-      const trimmed = raw.replace(/^\r?\n/, "");
-      const lines = trimmed.split(/\r?\n/);
-      let i = 0;
-      const headers = {};
-      while (i < lines.length && lines[i].length > 0) {
-        const sep3 = lines[i].indexOf(": ");
-        if (sep3 !== -1) headers[lines[i].slice(0, sep3).toLowerCase()] = lines[i].slice(sep3 + 2);
-        i++;
+function buildGet(sql, name, pk) {
+  return async function get(id2) {
+    if (!pk) throw new Error(`Table "${name}" has no primary key`);
+    const [row] = await sql`SELECT * FROM ${sql(name)} WHERE ${sql(pk.name)} = ${id2} LIMIT 1`;
+    return row ?? void 0;
+  };
+}
+function buildList(sql, name, columns) {
+  return async function list(filter = {}, opts = {}) {
+    const colNames = new Set(columns.map((c) => c.name));
+    const whereClauses = [];
+    const whereValues = [];
+    for (const [key, value] of Object.entries(filter)) {
+      if (colNames.has(key)) {
+        whereClauses.push(`"${key}" = $${whereValues.length + 1}`);
+        whereValues.push(value);
       }
-      i++;
-      const bodyValue = lines.slice(i).join("\r\n");
-      const disposition = headers["content-disposition"] ?? "";
-      const nameMatch = disposition.match(/name="([^"]*)"/);
-      if (!nameMatch) continue;
-      const name = nameMatch[1];
-      const filenameMatch = disposition.match(/filename="([^"]*)"/);
-      const filename = filenameMatch?.[1];
-      if (filename) {
-        const buf = Buffer.from(bodyValue.replace(/\r?\n$/, ""), "binary");
-        if (options?.allowedTypes) {
-          const mime = headers["content-type"] ?? "application/octet-stream";
-          if (!options.allowedTypes.includes(mime)) {
-            return Response.json({ error: `File type not allowed: ${mime}` }, { status: 415 });
-          }
-        }
-        if (options?.maxFileSize && buf.byteLength > options.maxFileSize) {
-          return Response.json({ error: `File too large: ${filename}` }, { status: 413 });
-        }
-        const uf = {
-          name: filename,
-          type: headers["content-type"] ?? "application/octet-stream",
-          size: buf.byteLength,
-          buffer: saveDir ? void 0 : buf
-        };
-        if (saveDir) {
-          const filePath = join2(saveDir, `${randomUUID()}-${filename}`);
-          await mkdir(saveDir, { recursive: true });
-          await writeFile(filePath, buf);
-          uf.path = filePath;
-        }
-        if (files[name]) {
-          const existing = files[name];
-          files[name] = Array.isArray(existing) ? [...existing, uf] : [existing, uf];
-        } else {
-          files[name] = uf;
+    }
+    const where = whereClauses.length > 0 ? `WHERE ${whereClauses.join(" AND ")}` : "";
+    const sortClauses = [];
+    if (opts.sort) {
+      for (const [key, dir] of Object.entries(opts.sort)) {
+        if (colNames.has(key)) {
+          sortClauses.push(`"${key}" ${dir.toUpperCase()}`);
         }
-      } else {
-        fields[name] = bodyValue.replace(/\r?\n$/, "");
       }
     }
-    ctx.parsed = { ...ctx.parsed, files, fields };
-    return next(req, ctx);
+    const orderBy = sortClauses.length > 0 ? `ORDER BY ${sortClauses.join(", ")}` : "";
+    const limitClause = opts.limit != null ? `LIMIT ${opts.limit}` : "";
+    const offsetClause = opts.offset != null ? `OFFSET ${opts.offset}` : "";
+    const [rows, countResult] = await Promise.all([
+      sql.unsafe(`SELECT * FROM "${name}" ${where} ${orderBy} ${limitClause} ${offsetClause}`.trim(), whereValues),
+      sql.unsafe(`SELECT count(*) as count FROM "${name}" ${where}`.trim(), whereValues)
+    ]);
+    return { rows, count: Number(countResult[0]?.count ?? 0) };
   };
 }
-
-// rate-limit.ts
-function rateLimit(options) {
-  const max = options?.max ?? 100;
-  const window = options?.window ?? 6e4;
-  const getKey = options?.key ?? ((req) => {
-    const forwarded = req.headers.get("x-forwarded-for");
-    if (forwarded) return forwarded.split(",")[0].trim();
-    return new URL(req.url).hostname;
-  });
-  const message = options?.message ?? "Too Many Requests";
-  const hits = /* @__PURE__ */ new Map();
-  const interval = setInterval(() => {
-    const now = Date.now();
-    for (const [key, entry] of hits) {
-      if (entry.reset < now) hits.delete(key);
-    }
-  }, window);
-  if (interval.unref) interval.unref();
-  return async (req, ctx, next) => {
-    const key = getKey(req);
-    const now = Date.now();
-    const entry = hits.get(key);
-    if (!entry || entry.reset < now) {
-      hits.set(key, { count: 1, reset: now + window });
-      const res2 = await next(req, ctx);
-      const headers2 = new Headers(res2.headers);
-      headers2.set("X-RateLimit-Limit", String(max));
-      headers2.set("X-RateLimit-Remaining", String(max - 1));
-      headers2.set("X-RateLimit-Reset", String(Math.ceil((now + window) / 1e3)));
-      return new Response(res2.body, { status: res2.status, statusText: res2.statusText, headers: headers2 });
-    }
-    entry.count++;
-    const remaining = Math.max(0, max - entry.count);
-    if (entry.count > max) {
-      return new Response(message, {
-        status: 429,
-        headers: {
-          "Retry-After": String(Math.ceil((entry.reset - now) / 1e3)),
-          "X-RateLimit-Limit": String(max),
-          "X-RateLimit-Remaining": "0",
-          "X-RateLimit-Reset": String(Math.ceil(entry.reset / 1e3))
-        }
-      });
-    }
-    const res = await next(req, ctx);
-    const headers = new Headers(res.headers);
-    headers.set("X-RateLimit-Limit", String(max));
-    headers.set("X-RateLimit-Remaining", String(remaining));
-    headers.set("X-RateLimit-Reset", String(Math.ceil(entry.reset / 1e3)));
-    return new Response(res.body, { status: res.status, statusText: res.statusText, headers });
+function buildCreate(sql, name, pk, zodSchema) {
+  return async function create(data) {
+    const validated = zodSchema.parse(data);
+    if (pk?.autoGenerate) {
+      delete validated[pk.name];
+    }
+    const [row] = await sql`INSERT INTO ${sql(name)} ${sql(validated)} RETURNING *`;
+    return row;
+  };
+}
+function buildPatch(sql, name, pk, zodSchema) {
+  return async function patch(id2, data) {
+    if (!pk) throw new Error(`Table "${name}" has no primary key`);
+    const validated = zodSchema.partial().parse(data);
+    delete validated[pk.name];
+    if (Object.keys(validated).length === 0) {
+      const [row2] = await sql`SELECT * FROM ${sql(name)} WHERE ${sql(pk.name)} = ${id2} LIMIT 1`;
+      return row2 ?? void 0;
+    }
+    const [row] = await sql`UPDATE ${sql(name)} SET ${sql(validated)} WHERE ${sql(pk.name)} = ${id2} RETURNING *`;
+    return row ?? void 0;
+  };
+}
+function buildRemove(sql, name, pk) {
+  return async function remove(id2) {
+    if (!pk) throw new Error(`Table "${name}" has no primary key`);
+    const rows = await sql`DELETE FROM ${sql(name)} WHERE ${sql(pk.name)} = ${id2} RETURNING 1`;
+    return rows.length > 0;
+  };
+}
+function buildTable(sql, tables) {
+  return function table(name, schema) {
+    const zodSchema = z.object(schema);
+    const columns = parseColumns(schema);
+    const pk = columns.find((c) => c.isPrimaryKey) ?? void 0;
+    tables.push({ name, columns });
+    return {
+      $type: void 0,
+      $insert: void 0,
+      get: buildGet(sql, name, pk),
+      list: buildList(sql, name, columns),
+      create: buildCreate(sql, name, pk, zodSchema),
+      patch: buildPatch(sql, name, pk, zodSchema),
+      remove: buildRemove(sql, name, pk)
+    };
   };
 }
 
-// compress.ts
-import { gzipSync, brotliCompressSync, constants } from "node:zlib";
-function compress(options) {
-  const level = options?.level ?? 6;
-  const threshold = options?.threshold ?? 1024;
-  return async (req, ctx, next) => {
-    const accept = req.headers.get("accept-encoding") ?? "";
-    const useBrotli = accept.includes("br");
-    const useGzip = !useBrotli && accept.includes("gzip");
-    const useDeflate = !useBrotli && !useGzip && accept.includes("deflate");
-    if (!useBrotli && !useGzip && !useDeflate) {
-      return next(req, ctx);
-    }
-    const res = await next(req, ctx);
-    if (res.status === 304 || res.status === 204 || res.status < 200 || res.status >= 300) {
-      return res;
-    }
-    const ce = res.headers.get("content-encoding");
-    if (ce) return res;
-    const ct = res.headers.get("content-type") ?? "";
-    if (!ct || ct.startsWith("audio/") || ct.startsWith("video/") || ct.startsWith("image/") || ct === "application/zip") {
-      return res;
-    }
-    const body = await res.bytes();
-    if (body.byteLength < threshold) return res;
-    let compressed;
-    let encoding;
-    if (useBrotli) {
-      compressed = brotliCompressSync(body, {
-        params: { [constants.BROTLI_PARAM_QUALITY]: Math.min(level, 11) }
-      });
-      encoding = "br";
-    } else if (useGzip) {
-      compressed = gzipSync(body, { level: Math.min(level, 9) });
-      encoding = "gzip";
+// postgres/migrate.ts
+function toDDL(col) {
+  const parts = [`"${col.name}"`, col.sqlType];
+  if (col.isPrimaryKey) parts.push("PRIMARY KEY");
+  if (!col.isPrimaryKey && !col.nullable) parts.push("NOT NULL");
+  if (col.defaultExpr) parts.push(`DEFAULT ${col.defaultExpr}`);
+  return parts.join(" ");
+}
+function createTableSQL(name, columns) {
+  const cols = columns.map(toDDL);
+  return `CREATE TABLE IF NOT EXISTS "${name}" (
+  ${cols.join(",\n  ")}
+)`;
+}
+function addColumnSQL(name, col) {
+  return `ALTER TABLE "${name}" ADD COLUMN IF NOT EXISTS ${toDDL(col)}`;
+}
+async function runMigrations(sql, tables) {
+  for (const table of tables) {
+    const existing = await sql`
+      SELECT column_name FROM information_schema.columns
+      WHERE table_schema = 'public' AND table_name = ${table.name}
+    `;
+    if (existing.length === 0) {
+      await sql.unsafe(createTableSQL(table.name, table.columns));
     } else {
-      compressed = gzipSync(body, { level: Math.min(level, 9) });
-      encoding = "deflate";
+      const colNames = new Set(existing.map((r) => r.column_name));
+      for (const col of table.columns) {
+        if (!colNames.has(col.name)) {
+          await sql.unsafe(addColumnSQL(table.name, col));
+        }
+      }
     }
-    const headers = new Headers(res.headers);
-    headers.set("Content-Encoding", encoding);
-    headers.set("Content-Length", String(compressed.byteLength));
-    headers.delete("Content-Range");
-    headers.set("Vary", "Accept-Encoding");
-    return new Response(compressed, {
-      status: res.status,
-      statusText: res.statusText,
-      headers
-    });
-  };
+  }
+}
+
+// postgres/client.ts
+function postgres(opts) {
+  const options = typeof opts === "string" ? { connection: opts } : opts ?? {};
+  const connection = options.connection ?? process.env.DATABASE_URL;
+  if (!connection) {
+    throw new Error(
+      "postgres: DATABASE_URL is not set. Pass a connection string or set the DATABASE_URL environment variable."
+    );
+  }
+  const sql = postgresFactory(connection);
+  const tables = [];
+  if (options.signal) {
+    options.signal.addEventListener("abort", () => {
+      sql.end();
+    }, { once: true });
+  }
+  const mw = ((req, ctx, next) => {
+    ctx.sql = sql;
+    return next(req, ctx);
+  });
+  mw.sql = sql;
+  mw.table = buildTable(sql, tables);
+  mw.migrate = () => runMigrations(sql, tables);
+  mw.close = () => sql.end({ timeout: 5 });
+  return mw;
 }
 export {
   Router,
   TsxContext,
+  ai,
   auth,
   compress,
   cors,
@@ -2005,7 +2231,9 @@ export {
   deleteCookie,
   generateWorkflow,
   getCookies,
+  graphql,
   logger,
+  postgres,
   rateLimit,
   serve,
   serveStatic,
@@ -2014,5 +2242,6 @@ export {
   tsx,
   upload,
   useTsx,
-  validate
+  validate,
+  workflow
 };