theokit 0.1.0-alpha.0

package/dist/chunk-ATSTRYYT.js

@@ -0,0 +1,894 @@
+import {
+  AuthRequiredError,
+  createRateLimiter
+} from "./chunk-SAVVU5LG.js";
+
+// src/vite-plugin/index.ts
+import { resolve as resolve5, basename as basename2, dirname } from "path";
+import { existsSync as existsSync6, readFileSync } from "fs";
+import { fileURLToPath } from "url";
+
+// src/router/scan.ts
+import { readdirSync, statSync, existsSync } from "fs";
+import { join, resolve } from "path";
+
+// src/router/types.ts
+var ROUTE_FILE_NAMES = [
+  "page",
+  "layout",
+  "error",
+  "loading",
+  "not-found"
+];
+var ROUTE_FILE_EXTENSIONS = [".tsx", ".ts", ".jsx", ".js"];
+var ROUTE_FILE_REGEX = /^(page|layout|error|loading|not-found)\.(tsx|ts|jsx|js)$/;
+function isRouteFile(filename) {
+  return ROUTE_FILE_REGEX.test(filename);
+}
+
+// src/router/scan.ts
+function toNodeKey(name) {
+  if (name === "not-found") return "notFound";
+  return name;
+}
+function setRouteFile(node, key, value) {
+  switch (key) {
+    case "page":
+      node.page = value;
+      break;
+    case "layout":
+      node.layout = value;
+      break;
+    case "error":
+      node.error = value;
+      break;
+    case "loading":
+      node.loading = value;
+      break;
+    case "notFound":
+      node.notFound = value;
+      break;
+  }
+}
+function scanDir(dir, segment, routePath) {
+  const node = { segment, path: routePath, children: [] };
+  const entries = readdirSync(dir, { withFileTypes: true });
+  for (const name of ROUTE_FILE_NAMES) {
+    const key = toNodeKey(name);
+    if (node[key] !== void 0) continue;
+    for (const ext of ROUTE_FILE_EXTENSIONS) {
+      const filename = `${name}${ext}`;
+      if (existsSync(join(dir, filename))) {
+        setRouteFile(node, key, resolve(dir, filename));
+        break;
+      }
+    }
+  }
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    if (entry.name.startsWith("_") || entry.name.startsWith(".")) continue;
+    const childPath = routePath === "/" ? `/${entry.name}` : `${routePath}/${entry.name}`;
+    const child = scanDir(join(dir, entry.name), entry.name, childPath);
+    const hasRouteFile = child.page || child.layout || child.error || child.loading || child.notFound;
+    if (hasRouteFile || child.children.length > 0) {
+      node.children.push(child);
+    }
+  }
+  return node;
+}
+function scanRoutes(appDir) {
+  if (!existsSync(appDir)) {
+    throw new Error(`App directory does not exist: ${appDir}`);
+  }
+  if (!statSync(appDir).isDirectory()) {
+    throw new Error(`App path is not a directory: ${appDir}`);
+  }
+  return scanDir(appDir, "", "/");
+}
+
+// src/router/generate.ts
+function normalizePath(p) {
+  return p.replace(/\\/g, "/");
+}
+function safeVarName(segment, prefix) {
+  const safe = segment.replace(/[^a-zA-Z0-9]/g, "_") || "root";
+  return `${prefix}_${safe}`;
+}
+function generateRouteManifest(tree) {
+  const imports = [];
+  let hasLayout = false;
+  function collectImports(node) {
+    const seg = node.segment || "root";
+    if (node.page) {
+      imports.push({
+        varName: safeVarName(seg, "Page"),
+        importPath: normalizePath(node.page)
+      });
+    }
+    if (node.layout) {
+      hasLayout = true;
+      imports.push({
+        varName: safeVarName(seg, "Layout"),
+        importPath: normalizePath(node.layout)
+      });
+    }
+    if (node.error) {
+      imports.push({
+        varName: safeVarName(seg, "Error"),
+        importPath: normalizePath(node.error)
+      });
+    }
+    if (node.loading) {
+      imports.push({
+        varName: safeVarName(seg, "Loading"),
+        importPath: normalizePath(node.loading)
+      });
+    }
+    if (node.notFound) {
+      imports.push({
+        varName: safeVarName(seg, "NotFound"),
+        importPath: normalizePath(node.notFound)
+      });
+    }
+    for (const child of node.children) {
+      collectImports(child);
+    }
+  }
+  collectImports(tree);
+  const lines = [
+    `import React, { Suspense, lazy } from 'react'`
+  ];
+  if (hasLayout) {
+    lines.push(`import { Outlet } from 'react-router'`);
+  }
+  lines.push("");
+  for (const imp of imports) {
+    lines.push(
+      `const ${imp.varName} = lazy(() => import('${imp.importPath}'))`
+    );
+  }
+  lines.push("");
+  function genRouteConfig(node, isRoot) {
+    const seg = node.segment || "root";
+    const childConfigs = [];
+    if (node.page) {
+      const pageVar = safeVarName(seg, "Page");
+      let pageElement = `React.createElement(${pageVar})`;
+      if (node.loading) {
+        const loadVar = safeVarName(seg, "Loading");
+        pageElement = `React.createElement(Suspense, { fallback: React.createElement(${loadVar}) }, ${pageElement})`;
+      }
+      childConfigs.push(`{ index: true, element: ${pageElement} }`);
+    }
+    for (const child of node.children) {
+      childConfigs.push(genRouteConfig(child, false));
+    }
+    if (node.notFound) {
+      const nfVar = safeVarName(seg, "NotFound");
+      childConfigs.push(
+        `{ path: '*', element: React.createElement(${nfVar}) }`
+      );
+    }
+    let childrenArray = `[${childConfigs.join(", ")}]`;
+    if (node.error) {
+      const errVar = safeVarName(seg, "Error");
+      childrenArray = `[{ errorElement: React.createElement(${errVar}), children: ${childrenArray} }]`;
+    }
+    if (node.layout) {
+      const layoutVar = safeVarName(seg, "Layout");
+      const pathPart = isRoot ? `path: '/'` : `path: '${node.segment}'`;
+      return `{ ${pathPart}, element: React.createElement(${layoutVar}), children: ${childrenArray} }`;
+    }
+    if (isRoot) {
+      if (childConfigs.length === 0 && !node.page) {
+        return `{ path: '/', children: [] }`;
+      }
+      return `{ path: '/', children: ${childrenArray} }`;
+    }
+    if (node.page && node.children.length === 0 && !node.error && !node.notFound) {
+      const pageVar = safeVarName(seg, "Page");
+      let pageElement = `React.createElement(${pageVar})`;
+      if (node.loading) {
+        const loadVar = safeVarName(seg, "Loading");
+        pageElement = `React.createElement(Suspense, { fallback: React.createElement(${loadVar}) }, ${pageElement})`;
+      }
+      return `{ path: '${node.segment}', element: ${pageElement} }`;
+    }
+    return `{ path: '${node.segment}', children: ${childrenArray} }`;
+  }
+  const routeConfig = genRouteConfig(tree, true);
+  lines.push(`export const routes = [${routeConfig}]`);
+  return lines.join("\n");
+}
+
+// src/router/entry.ts
+function generateEntryClient(ssr) {
+  const rootMethod = ssr ? "hydrateRoot" : "createRoot";
+  const renderCall = ssr ? `  ${rootMethod}(el,
+    React.createElement(Suspense, { fallback: null },
+      React.createElement(RouterProvider, { router })
+    )
+  )` : `  ${rootMethod}(el).render(
+    React.createElement(Suspense, { fallback: null },
+      React.createElement(RouterProvider, { router })
+    )
+  )`;
+  return [
+    `import React, { Suspense } from 'react'`,
+    `import { ${rootMethod} } from 'react-dom/client'`,
+    `import { createBrowserRouter, RouterProvider } from 'react-router'`,
+    `import { routes } from '/@theo/route-manifest'`,
+    ``,
+    `const router = createBrowserRouter(routes)`,
+    `const el = document.getElementById('root')`,
+    `if (el) {`,
+    renderCall,
+    `}`
+  ].join("\n");
+}
+
+// src/router/entry-server.ts
+function generateEntryServer() {
+  return [
+    `import React from 'react'`,
+    `import { renderToPipeableStream } from 'react-dom/server'`,
+    `import { createStaticHandler, createStaticRouter, StaticRouterProvider } from 'react-router'`,
+    `import { PassThrough } from 'node:stream'`,
+    `import { routes } from '/@theo/route-manifest'`,
+    ``,
+    `export async function render(url) {`,
+    `  const handler = createStaticHandler(routes)`,
+    `  const request = new Request('http://localhost' + url)`,
+    `  const context = await handler.query(request)`,
+    ``,
+    `  if (context instanceof Response) {`,
+    `    return { redirect: context }`,
+    `  }`,
+    ``,
+    `  const router = createStaticRouter(handler.dataRoutes, context)`,
+    `  const app = React.createElement(StaticRouterProvider, { router, context })`,
+    ``,
+    `  return new Promise((resolve, reject) => {`,
+    `    let html = ''`,
+    `    const passthrough = new PassThrough()`,
+    `    passthrough.on('data', (chunk) => { html += chunk.toString() })`,
+    `    passthrough.on('end', () => { resolve(html) })`,
+    `    passthrough.on('error', reject)`,
+    ``,
+    `    const { pipe } = renderToPipeableStream(app, {`,
+    `      onAllReady() { pipe(passthrough) },`,
+    `      onShellError(err) { reject(err) },`,
+    `      onError(err) { console.error('[SSR Error]', err) },`,
+    `    })`,
+    `  })`,
+    `}`
+  ].join("\n");
+}
+
+// src/vite-plugin/api-middleware.ts
+import { randomUUID } from "crypto";
+
+// src/server/scan.ts
+import { readdirSync as readdirSync2, existsSync as existsSync2, statSync as statSync2 } from "fs";
+import { join as join2, resolve as resolve2, relative, extname } from "path";
+
+// src/server/match.ts
+function compilePattern(routePath) {
+  const paramNames = [];
+  const regexStr = routePath.replace(/:([^/]+)/g, (_, name) => {
+    paramNames.push(name);
+    return "([^/]+)";
+  });
+  return { pattern: new RegExp(`^${regexStr}$`), paramNames };
+}
+function matchRoute(url, routes) {
+  let path = url.split("?")[0];
+  if (path.length > 1 && path.endsWith("/")) {
+    path = path.slice(0, -1);
+  }
+  for (const route of routes) {
+    const match = route.pattern.exec(path);
+    if (match) {
+      const params = {};
+      route.paramNames.forEach((name, i) => {
+        params[name] = match[i + 1];
+      });
+      return { route, params };
+    }
+  }
+  return null;
+}
+
+// src/server/scan.ts
+var ROUTE_EXTENSIONS = [".ts", ".tsx", ".js", ".jsx"];
+function fileToRoutePath(filePath, routesDir) {
+  let rel = relative(routesDir, filePath);
+  const ext = extname(rel);
+  rel = rel.slice(0, -ext.length);
+  rel = rel.replace(/\\/g, "/");
+  if (rel.endsWith("/index")) {
+    rel = rel.slice(0, -6);
+  } else if (rel === "index") {
+    rel = "";
+  }
+  rel = rel.replace(/\[([^\]]+)\]/g, ":$1");
+  return `/api/${rel}`;
+}
+function scanDir2(dir, routesDir, results) {
+  const entries = readdirSync2(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = join2(dir, entry.name);
+    if (entry.isDirectory()) {
+      if (!entry.name.startsWith("_") && !entry.name.startsWith(".")) {
+        scanDir2(fullPath, routesDir, results);
+      }
+    } else if (entry.isFile()) {
+      const ext = extname(entry.name);
+      if (!ROUTE_EXTENSIONS.includes(ext)) continue;
+      const routePath = fileToRoutePath(fullPath, routesDir);
+      const { pattern, paramNames } = compilePattern(routePath);
+      results.push({
+        filePath: resolve2(fullPath),
+        routePath,
+        paramNames,
+        pattern
+      });
+    }
+  }
+}
+function scanServerRoutes(serverDir) {
+  const routesDir = join2(serverDir, "routes");
+  if (!existsSync2(routesDir) || !statSync2(routesDir).isDirectory()) {
+    return [];
+  }
+  const results = [];
+  scanDir2(routesDir, routesDir, results);
+  results.sort((a, b) => {
+    if (a.paramNames.length === 0 && b.paramNames.length > 0) return -1;
+    if (a.paramNames.length > 0 && b.paramNames.length === 0) return 1;
+    return a.routePath.localeCompare(b.routePath);
+  });
+  return results;
+}
+
+// src/server/middleware-runner.ts
+import { existsSync as existsSync3 } from "fs";
+import { join as join3 } from "path";
+async function runMiddlewareAndContext(req, res, loadModule, serverDir) {
+  const middlewarePath = join3(serverDir, "middleware.ts");
+  if (existsSync3(middlewarePath)) {
+    const mod = await loadModule(middlewarePath);
+    const mw = mod.default;
+    if (typeof mw === "function") {
+      let nextCalled = false;
+      await mw(req, res, async () => {
+        nextCalled = true;
+      });
+      if (!nextCalled || res.writableEnded) {
+        return { ctx: {}, aborted: true };
+      }
+    }
+  }
+  let ctx = {};
+  const contextPath = join3(serverDir, "context.ts");
+  if (existsSync3(contextPath)) {
+    const mod = await loadModule(contextPath);
+    if (typeof mod.createContext === "function") {
+      ctx = await mod.createContext({ request: req, response: res });
+    }
+  }
+  return { ctx, aborted: false };
+}
+
+// src/server/execute.ts
+var METHODS_WITH_BODY = ["POST", "PUT", "PATCH"];
+function sendJson(res, data, status = 200) {
+  const body = JSON.stringify(data);
+  res.writeHead(status, {
+    "Content-Type": "application/json",
+    "Content-Length": Buffer.byteLength(body)
+  });
+  res.end(body);
+}
+function sendError(res, code, message, status, issues, requestId) {
+  const errorMessage = code === "INTERNAL_ERROR" && process.env.NODE_ENV === "production" ? "Internal server error" : message;
+  if (code === "INTERNAL_ERROR") {
+    console.error(`[${requestId ?? "no-id"}] ${message}`);
+  }
+  sendJson(
+    res,
+    {
+      error: {
+        code,
+        message: errorMessage,
+        ...requestId ? { requestId } : {},
+        ...issues ? { issues } : {}
+      }
+    },
+    status
+  );
+}
+function parseBody(req) {
+  return new Promise((resolve6, reject) => {
+    const method = req.method?.toUpperCase() ?? "GET";
+    if (!METHODS_WITH_BODY.includes(method)) {
+      return resolve6(void 0);
+    }
+    const contentType = req.headers["content-type"] ?? "";
+    const chunks = [];
+    req.on("data", (chunk) => chunks.push(chunk));
+    req.on("end", () => {
+      const raw = Buffer.concat(chunks).toString();
+      if (!raw) return resolve6(void 0);
+      if (!contentType.includes("application/json")) {
+        return reject(new Error("Expected Content-Type: application/json"));
+      }
+      try {
+        resolve6(JSON.parse(raw));
+      } catch {
+        reject(new Error("Invalid JSON body"));
+      }
+    });
+    req.on("error", reject);
+  });
+}
+async function executeRoute(route, method, params, req, res, loadModule, serverDir, requestId) {
+  try {
+    let ctx = {};
+    if (serverDir) {
+      const result = await runMiddlewareAndContext(req, res, loadModule, serverDir);
+      if (result.aborted) return;
+      ctx = result.ctx;
+    }
+    const mod = await loadModule(route.filePath);
+    const routeConfig = mod[method];
+    if (!routeConfig) {
+      sendError(res, "METHOD_NOT_ALLOWED", `Method ${method} not allowed`, 405, void 0, requestId);
+      return;
+    }
+    const handler = typeof routeConfig === "function" ? routeConfig : routeConfig.handler;
+    if (typeof handler !== "function") {
+      sendError(res, "INTERNAL_ERROR", "Route handler is not a function", 500, void 0, requestId);
+      return;
+    }
+    const url = new URL(req.url ?? "/", `http://${req.headers.host ?? "localhost"}`);
+    const query = Object.fromEntries(url.searchParams);
+    let body;
+    try {
+      body = await parseBody(req);
+    } catch (err) {
+      sendError(res, "VALIDATION_ERROR", err.message, 400, void 0, requestId);
+      return;
+    }
+    const rc = routeConfig;
+    if (rc.query && typeof rc.query.safeParse === "function") {
+      const result = rc.query.safeParse(query);
+      if (!result.success) {
+        sendError(res, "VALIDATION_ERROR", "Invalid query parameters", 400, result.error.issues, requestId);
+        return;
+      }
+      Object.assign(query, result.data);
+    }
+    if (rc.body && typeof rc.body.safeParse === "function") {
+      const result = rc.body.safeParse(body);
+      if (!result.success) {
+        sendError(res, "VALIDATION_ERROR", "Invalid request body", 400, result.error.issues, requestId);
+        return;
+      }
+      body = result.data;
+    }
+    if (rc.params && typeof rc.params.safeParse === "function") {
+      const result = rc.params.safeParse(params);
+      if (!result.success) {
+        sendError(res, "VALIDATION_ERROR", "Invalid route parameters", 400, result.error.issues, requestId);
+        return;
+      }
+      Object.assign(params, result.data);
+    }
+    const handlerResult = await handler({ query, body, params, request: req, ctx });
+    if (handlerResult === void 0 || handlerResult === null) {
+      sendJson(res, null, rc.status ?? 204);
+      return;
+    }
+    if (handlerResult instanceof Response) {
+      res.writeHead(handlerResult.status, Object.fromEntries(handlerResult.headers));
+      if (handlerResult.body) {
+        const reader = handlerResult.body.getReader();
+        try {
+          while (true) {
+            const { done, value } = await reader.read();
+            if (done) break;
+            res.write(value);
+          }
+        } catch {
+        }
+      }
+      res.end();
+      return;
+    }
+    sendJson(res, handlerResult, rc.status ?? 200);
+  } catch (err) {
+    if (err instanceof AuthRequiredError) {
+      sendError(res, err.code, err.message, err.status, void 0, requestId);
+      return;
+    }
+    sendError(res, "INTERNAL_ERROR", err.message ?? "Internal server error", 500, void 0, requestId);
+  }
+}
+
+// src/server/module-loader.ts
+import { pathToFileURL } from "url";
+function createViteLoader(vite) {
+  return (path) => vite.ssrLoadModule(path);
+}
+
+// src/server/logger.ts
+var defaultLogger = (log) => {
+  console.log(JSON.stringify(log));
+};
+function logRequest(info, customLogger) {
+  const log = {
+    level: "info",
+    ...info,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  const logger = customLogger ?? defaultLogger;
+  logger(log);
+}
+
+// src/vite-plugin/api-middleware.ts
+function createApiMiddleware(vite, serverDir, rateLimitConfig) {
+  const loadModule = createViteLoader(vite);
+  const rateLimiter = rateLimitConfig ? createRateLimiter(rateLimitConfig) : null;
+  return async (req, res, next) => {
+    const url = req.url ?? "";
+    if (!url.startsWith("/api/")) {
+      return next();
+    }
+    const requestId = randomUUID();
+    const start = Date.now();
+    res.setHeader("x-request-id", requestId);
+    if (rateLimiter) {
+      const check = rateLimiter(req);
+      for (const [k, v] of Object.entries(check.headers)) res.setHeader(k, v);
+      if (check.limited) {
+        sendError(res, "RATE_LIMITED", "Too many requests", 429, void 0, requestId);
+        logRequest({ method: req.method ?? "GET", url, status: 429, duration: Date.now() - start, requestId });
+        return;
+      }
+    }
+    const routes = scanServerRoutes(serverDir);
+    const match = matchRoute(url, routes);
+    if (!match) {
+      sendError(res, "NOT_FOUND", "API route not found", 404, void 0, requestId);
+      logRequest({ method: req.method ?? "GET", url, status: 404, duration: Date.now() - start, requestId });
+      return;
+    }
+    const method = (req.method ?? "GET").toUpperCase();
+    await executeRoute(match.route, method, match.params, req, res, loadModule, serverDir, requestId);
+    logRequest({ method, url, status: res.statusCode, duration: Date.now() - start, requestId });
+  };
+}
+
+// src/vite-plugin/action-middleware.ts
+import { randomUUID as randomUUID2 } from "crypto";
+
+// src/server/action-scan.ts
+import { readdirSync as readdirSync3, existsSync as existsSync4, statSync as statSync3 } from "fs";
+import { join as join4, resolve as resolve3, relative as relative2, extname as extname2 } from "path";
+var ACTION_EXTENSIONS = [".ts", ".tsx", ".js", ".jsx"];
+function scanDir3(dir, actionsDir, results) {
+  const entries = readdirSync3(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = join4(dir, entry.name);
+    if (entry.isDirectory()) {
+      if (!entry.name.startsWith("_") && !entry.name.startsWith(".")) {
+        scanDir3(fullPath, actionsDir, results);
+      }
+    } else if (entry.isFile()) {
+      const ext = extname2(entry.name);
+      if (!ACTION_EXTENSIONS.includes(ext)) continue;
+      let rel = relative2(actionsDir, fullPath);
+      rel = rel.replace(/\\/g, "/");
+      rel = rel.slice(0, -ext.length);
+      results.push({
+        filePath: resolve3(fullPath),
+        actionPath: rel
+      });
+    }
+  }
+}
+function scanServerActions(serverDir) {
+  const actionsDir = join4(serverDir, "actions");
+  if (!existsSync4(actionsDir) || !statSync3(actionsDir).isDirectory()) {
+    return [];
+  }
+  const results = [];
+  scanDir3(actionsDir, actionsDir, results);
+  return results;
+}
+
+// src/server/csrf.ts
+function validateCsrf(req) {
+  if (req.headers["x-theo-action"] !== "1") {
+    return { valid: false, reason: "Missing X-Theo-Action header" };
+  }
+  const origin = req.headers["origin"];
+  if (!origin) {
+    return { valid: true };
+  }
+  const host = req.headers["host"];
+  if (!host) {
+    return { valid: true };
+  }
+  try {
+    const originHost = new URL(origin).host;
+    if (originHost !== host) {
+      return { valid: false, reason: `Origin ${origin} does not match host ${host}` };
+    }
+  } catch {
+    return { valid: false, reason: `Invalid origin: ${origin}` };
+  }
+  return { valid: true };
+}
+
+// src/server/action-execute.ts
+async function executeAction(filePath, exportName, req, res, loadModule, serverDir, requestId) {
+  try {
+    const method = (req.method ?? "GET").toUpperCase();
+    if (method !== "POST") {
+      sendError(res, "METHOD_NOT_ALLOWED", "Actions only accept POST", 405, void 0, requestId);
+      return;
+    }
+    const csrf = validateCsrf(req);
+    if (!csrf.valid) {
+      sendError(res, "FORBIDDEN", csrf.reason, 403, void 0, requestId);
+      return;
+    }
+    let ctx = {};
+    if (serverDir) {
+      const result2 = await runMiddlewareAndContext(req, res, loadModule, serverDir);
+      if (result2.aborted) return;
+      ctx = result2.ctx;
+    }
+    const mod = await loadModule(filePath);
+    const actionConfig = mod[exportName];
+    if (!actionConfig || typeof actionConfig.handler !== "function" || !actionConfig.input) {
+      sendError(res, "NOT_FOUND", `Action "${exportName}" not found`, 404, void 0, requestId);
+      return;
+    }
+    let body;
+    try {
+      body = await parseBody(req);
+    } catch (err) {
+      sendError(res, "VALIDATION_ERROR", err.message, 400, void 0, requestId);
+      return;
+    }
+    const input = actionConfig.input;
+    const result = input.safeParse(body);
+    if (!result.success) {
+      sendError(res, "VALIDATION_ERROR", "Invalid action input", 400, result.error?.issues, requestId);
+      return;
+    }
+    const handlerResult = await actionConfig.handler({ input: result.data, ctx });
+    if (handlerResult === void 0 || handlerResult === null) {
+      sendJson(res, null, 204);
+      return;
+    }
+    sendJson(res, handlerResult, 200);
+  } catch (err) {
+    if (err instanceof AuthRequiredError) {
+      sendError(res, err.code, err.message, err.status, void 0, requestId);
+      return;
+    }
+    sendError(res, "INTERNAL_ERROR", err.message ?? "Internal server error", 500, void 0, requestId);
+  }
+}
+
+// src/vite-plugin/action-middleware.ts
+var PREFIX = "/api/__actions/";
+function createActionMiddleware(vite, serverDir) {
+  const loadModule = createViteLoader(vite);
+  return async (req, res, next) => {
+    const url = req.url ?? "";
+    if (!url.startsWith(PREFIX)) {
+      return next();
+    }
+    const requestId = randomUUID2();
+    const start = Date.now();
+    res.setHeader("x-request-id", requestId);
+    const pathAfterPrefix = url.slice(PREFIX.length).split("?")[0];
+    const segments = pathAfterPrefix.split("/").filter(Boolean);
+    if (segments.length < 2) {
+      sendError(res, "BAD_REQUEST", "Action URL must be /api/__actions/{file}/{exportName}", 400, void 0, requestId);
+      logRequest({ method: req.method ?? "POST", url, status: 400, duration: Date.now() - start, requestId });
+      return;
+    }
+    const exportName = segments[segments.length - 1];
+    const actionPath = segments.slice(0, -1).join("/");
+    const actions = scanServerActions(serverDir);
+    const action = actions.find((a) => a.actionPath === actionPath);
+    if (!action) {
+      sendError(res, "NOT_FOUND", `Action file "${actionPath}" not found`, 404, void 0, requestId);
+      logRequest({ method: req.method ?? "POST", url, status: 404, duration: Date.now() - start, requestId });
+      return;
+    }
+    await executeAction(action.filePath, exportName, req, res, loadModule, serverDir, requestId);
+    logRequest({ method: req.method ?? "POST", url, status: res.statusCode, duration: Date.now() - start, requestId });
+  };
+}
+
+// src/server/ws-scan.ts
+import { readdirSync as readdirSync4, existsSync as existsSync5, statSync as statSync4 } from "fs";
+import { join as join5, resolve as resolve4, relative as relative3, extname as extname3 } from "path";
+var WS_EXTENSIONS = [".ts", ".tsx", ".js", ".jsx"];
+function scanDir4(dir, wsDir, results) {
+  const entries = readdirSync4(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = join5(dir, entry.name);
+    if (entry.isDirectory()) {
+      if (!entry.name.startsWith("_") && !entry.name.startsWith(".")) {
+        scanDir4(fullPath, wsDir, results);
+      }
+    } else if (entry.isFile()) {
+      const ext = extname3(entry.name);
+      if (!WS_EXTENSIONS.includes(ext)) continue;
+      let rel = relative3(wsDir, fullPath);
+      rel = rel.replace(/\\/g, "/");
+      rel = rel.slice(0, -ext.length);
+      if (rel.endsWith("/index")) rel = rel.slice(0, -6);
+      else if (rel === "index") rel = "";
+      results.push({
+        filePath: resolve4(fullPath),
+        wsPath: `/ws/${rel}`
+      });
+    }
+  }
+}
+function scanWebSocketRoutes(serverDir) {
+  const wsDir = join5(serverDir, "ws");
+  if (!existsSync5(wsDir) || !statSync4(wsDir).isDirectory()) {
+    return [];
+  }
+  const results = [];
+  scanDir4(wsDir, wsDir, results);
+  return results;
+}
+
+// src/vite-plugin/index.ts
+var VIRTUAL_ENTRY_ID = "/@theo/entry-client";
+var RESOLVED_ENTRY_ID = "\0@theo/entry-client";
+var VIRTUAL_MANIFEST_ID = "/@theo/route-manifest";
+var RESOLVED_MANIFEST_ID = "\0@theo/route-manifest";
+var VIRTUAL_ENTRY_SERVER_ID = "/@theo/entry-server";
+var RESOLVED_ENTRY_SERVER_ID = "\0@theo/entry-server";
+function theoPlugin(rootOrOptions) {
+  const options = typeof rootOrOptions === "string" ? { root: rootOrOptions } : rootOrOptions ?? {};
+  const projectRoot = options.root ?? process.cwd();
+  const appDir = resolve5(projectRoot, "app");
+  const ssrEnabled = options.ssr ?? false;
+  const currentDir = dirname(fileURLToPath(import.meta.url));
+  const theoSrcDir = resolve5(currentDir, "..");
+  return {
+    name: "theo",
+    config() {
+      const ext = existsSync6(resolve5(theoSrcDir, "index.ts")) ? ".ts" : ".js";
+      return {
+        envPrefix: "THEO_PUBLIC_",
+        resolve: {
+          alias: [
+            { find: "theokit/server", replacement: resolve5(theoSrcDir, `server/index${ext}`) },
+            { find: "theokit", replacement: resolve5(theoSrcDir, `index${ext}`) }
+          ]
+        }
+      };
+    },
+    resolveId(id) {
+      if (id === VIRTUAL_ENTRY_ID) return RESOLVED_ENTRY_ID;
+      if (id === VIRTUAL_MANIFEST_ID) return RESOLVED_MANIFEST_ID;
+      if (id === VIRTUAL_ENTRY_SERVER_ID) return RESOLVED_ENTRY_SERVER_ID;
+    },
+    load(id) {
+      if (id === RESOLVED_ENTRY_ID) {
+        return generateEntryClient(ssrEnabled);
+      }
+      if (id === RESOLVED_MANIFEST_ID) {
+        const tree = scanRoutes(appDir);
+        return generateRouteManifest(tree);
+      }
+      if (id === RESOLVED_ENTRY_SERVER_ID) {
+        return generateEntryServer();
+      }
+    },
+    configureServer(server) {
+      const serverDir = resolve5(projectRoot, "server");
+      server.middlewares.use(createActionMiddleware(server, serverDir));
+      server.middlewares.use(createApiMiddleware(server, serverDir, options.rateLimit));
+      if (ssrEnabled) {
+        server.middlewares.use(async (req, res, next) => {
+          const url = req.url ?? "/";
+          if (url.startsWith("/api/") || url.startsWith("/@") || url.startsWith("/node_modules/") || url.includes(".")) {
+            return next();
+          }
+          try {
+            const indexPath = resolve5(projectRoot, "index.html");
+            let template = readFileSync(indexPath, "utf-8");
+            template = await server.transformIndexHtml(url, template);
+            const mod = await server.ssrLoadModule(VIRTUAL_ENTRY_SERVER_ID);
+            const result = await mod.render(url);
+            if (result && typeof result === "object" && "redirect" in result) {
+              res.writeHead(302, { Location: result.redirect.headers.get("location") ?? "/" });
+              res.end();
+              return;
+            }
+            const ssrHtml = result;
+            const rootDivMatch = template.match(/<div id=["']root["'][^>]*>/);
+            if (!rootDivMatch) {
+              res.writeHead(200, { "Content-Type": "text/html" });
+              res.end(template);
+              return;
+            }
+            const splitIdx = template.indexOf(rootDivMatch[0]) + rootDivMatch[0].length;
+            const html = template.slice(0, splitIdx) + ssrHtml + template.slice(splitIdx);
+            res.writeHead(200, { "Content-Type": "text/html" });
+            res.end(html);
+          } catch (err) {
+            server.ssrFixStacktrace(err);
+            console.error("[SSR Dev Error]", err);
+            return next();
+          }
+        });
+      }
+      function handleRouteChange(filePath) {
+        if (!isRouteFile(basename2(filePath))) return;
+        if (!filePath.startsWith(appDir)) return;
+        const mod = server.moduleGraph.getModuleById(RESOLVED_MANIFEST_ID);
+        if (mod) {
+          server.moduleGraph.invalidateModule(mod);
+          server.ws.send({ type: "full-reload" });
+        }
+      }
+      server.watcher.on("add", handleRouteChange);
+      server.watcher.on("unlink", handleRouteChange);
+      const wsRoutes = scanWebSocketRoutes(resolve5(projectRoot, "server"));
+      if (wsRoutes.length > 0 && server.httpServer) {
+        import("ws").then(({ WebSocketServer }) => {
+          const wss = new WebSocketServer({ noServer: true });
+          server.httpServer.on("upgrade", async (request, socket, head) => {
+            const url = request.url ?? "/";
+            if (!url.startsWith("/ws/")) return;
+            const wsPath = url.split("?")[0];
+            const match = wsRoutes.find((r) => r.wsPath === wsPath);
+            if (!match) {
+              socket.destroy();
+              return;
+            }
+            try {
+              const mod = await server.ssrLoadModule(match.filePath);
+              const handler = mod.default ?? mod;
+              wss.handleUpgrade(request, socket, head, (ws) => {
+                handler.onOpen?.(ws, request);
+                ws.on("message", (data) => handler.onMessage?.(ws, data.toString()));
+                ws.on("close", (code, reason) => handler.onClose?.(ws, code, reason));
+                ws.on("error", (err) => handler.onError?.(ws, err));
+              });
+            } catch {
+              socket.destroy();
+            }
+          });
+        }).catch(() => {
+          console.warn('[Theo] WebSocket routes found but "ws" package not installed. Run: npm install ws');
+        });
+      }
+    }
+  };
+}
+
+export {
+  isRouteFile,
+  scanRoutes,
+  generateRouteManifest,
+  generateEntryClient,
+  theoPlugin
+};
+//# sourceMappingURL=chunk-ATSTRYYT.js.map