@teamvelix/velix-core 5.1.7

package/dist/index.js

@@ -0,0 +1,1731 @@
+import fs from 'fs';
+import path2 from 'path';
+import crypto from 'crypto';
+import { pathToFileURL } from 'url';
+import { z } from 'zod';
+import pc from 'picocolors';
+
+// src/router/index.ts
+function generateHash(content) {
+  return crypto.createHash("md5").update(content).digest("hex").slice(0, 8);
+}
+function escapeHtml(str) {
+  const htmlEntities = {
+    "&": "&",
+    "<": "&lt;",
+    ">": "&gt;",
+    '"': "&quot;",
+    "'": "&#39;"
+  };
+  return String(str).replace(/[&<>"']/g, (char) => htmlEntities[char]);
+}
+function findFiles(dir, pattern, files = []) {
+  if (!fs.existsSync(dir)) return files;
+  const entries = fs.readdirSync(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = path2.join(dir, entry.name);
+    if (entry.isDirectory()) findFiles(fullPath, pattern, files);
+    else if (pattern.test(entry.name)) files.push(fullPath);
+  }
+  return files;
+}
+function ensureDir(dir) {
+  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+}
+function cleanDir(dir) {
+  if (fs.existsSync(dir)) fs.rmSync(dir, { recursive: true, force: true });
+  fs.mkdirSync(dir, { recursive: true });
+}
+function copyDir(src, dest) {
+  ensureDir(dest);
+  const entries = fs.readdirSync(src, { withFileTypes: true });
+  for (const entry of entries) {
+    const srcPath = path2.join(src, entry.name);
+    const destPath = path2.join(dest, entry.name);
+    if (entry.isDirectory()) copyDir(srcPath, destPath);
+    else fs.copyFileSync(srcPath, destPath);
+  }
+}
+function debounce(fn, delay) {
+  let timeout;
+  return (...args) => {
+    clearTimeout(timeout);
+    timeout = setTimeout(() => fn(...args), delay);
+  };
+}
+function formatBytes(bytes) {
+  if (bytes === 0) return "0 B";
+  const k = 1024;
+  const sizes = ["B", "KB", "MB", "GB"];
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + " " + sizes[i];
+}
+function formatTime(ms) {
+  if (ms < 1e3) return `${ms}ms`;
+  return `${(ms / 1e3).toFixed(2)}s`;
+}
+function createDeferred() {
+  let resolve;
+  let reject;
+  const promise = new Promise((res, rej) => {
+    resolve = res;
+    reject = rej;
+  });
+  return { promise, resolve, reject };
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function isServerComponent(filePath) {
+  try {
+    const content = fs.readFileSync(filePath, "utf-8");
+    const firstLine = content.split("\n")[0].trim();
+    return firstLine === "'use server'" || firstLine === '"use server"';
+  } catch {
+    return false;
+  }
+}
+function isClientComponent(filePath) {
+  try {
+    const content = fs.readFileSync(filePath, "utf-8");
+    const firstLine = content.split("\n")[0].trim();
+    return firstLine === "'use client'" || firstLine === '"use client"';
+  } catch {
+    return false;
+  }
+}
+function isIsland(filePath) {
+  try {
+    const content = fs.readFileSync(filePath, "utf-8");
+    const firstLine = content.split("\n")[0].trim();
+    return firstLine === "'use island'" || firstLine === '"use island"';
+  } catch {
+    return false;
+  }
+}
+
+// src/router/index.ts
+var RouteType = {
+  PAGE: "page",
+  API: "api",
+  LAYOUT: "layout",
+  LOADING: "loading",
+  ERROR: "error",
+  NOT_FOUND: "not-found"
+};
+function buildRouteTree(appDir) {
+  const projectRoot = path2.dirname(appDir);
+  const routes = {
+    pages: [],
+    api: [],
+    layouts: /* @__PURE__ */ new Map(),
+    tree: { children: {}, routes: [] },
+    appRoutes: []
+  };
+  if (fs.existsSync(appDir)) {
+    scanAppDirectory(appDir, appDir, routes);
+  }
+  const serverApiDir = path2.join(projectRoot, "server", "api");
+  if (fs.existsSync(serverApiDir)) {
+    scanApiDirectory(serverApiDir, serverApiDir, routes);
+  }
+  const rootLayoutTsx = path2.join(appDir, "layout.tsx");
+  const rootLayoutJsx = path2.join(appDir, "layout.jsx");
+  if (fs.existsSync(rootLayoutTsx)) routes.rootLayout = rootLayoutTsx;
+  else if (fs.existsSync(rootLayoutJsx)) routes.rootLayout = rootLayoutJsx;
+  routes.tree = buildTree(routes.appRoutes);
+  return routes;
+}
+function scanAppDirectory(baseDir, currentDir, routes, parentSegments = [], parentLayout = null, parentMiddleware = null) {
+  const entries = fs.readdirSync(currentDir, { withFileTypes: true });
+  const specialFiles = {
+    page: null,
+    layout: null,
+    loading: null,
+    error: null,
+    notFound: null,
+    template: null,
+    middleware: null
+  };
+  for (const entry of entries) {
+    if (entry.isFile()) {
+      const name = entry.name.replace(/\.(jsx|js|tsx|ts)$/, "");
+      const fullPath = path2.join(currentDir, entry.name);
+      const ext = path2.extname(entry.name);
+      if (![".tsx", ".jsx", ".ts", ".js"].includes(ext)) continue;
+      if (name === "page") specialFiles.page = fullPath;
+      if (name === "layout") specialFiles.layout = fullPath;
+      if (name === "loading") specialFiles.loading = fullPath;
+      if (name === "error") specialFiles.error = fullPath;
+      if (name === "not-found") specialFiles.notFound = fullPath;
+      if (name === "template") specialFiles.template = fullPath;
+      if (name === "middleware" || name === "_middleware") specialFiles.middleware = fullPath;
+      if (name.startsWith("[") && name.endsWith("]") && [".tsx", ".jsx"].includes(ext)) {
+        const paramName = name.slice(1, -1);
+        let segmentName;
+        if (paramName.startsWith("...")) {
+          segmentName = "*" + paramName.slice(3);
+        } else {
+          segmentName = ":" + paramName;
+        }
+        const routePath = "/" + [...parentSegments, segmentName].join("/");
+        routes.appRoutes.push({
+          type: RouteType.PAGE,
+          path: routePath.replace(/\/+/g, "/"),
+          filePath: fullPath,
+          pattern: createRoutePattern(routePath),
+          segments: [...parentSegments, segmentName],
+          layout: specialFiles.layout || parentLayout,
+          loading: specialFiles.loading,
+          error: specialFiles.error,
+          notFound: specialFiles.notFound,
+          template: specialFiles.template,
+          middleware: specialFiles.middleware || parentMiddleware,
+          isServerComponent: isServerComponent(fullPath),
+          isClientComponent: isClientComponent(fullPath),
+          isIsland: isIsland(fullPath)
+        });
+      }
+    }
+  }
+  if (specialFiles.page) {
+    const routePath = "/" + parentSegments.join("/") || "/";
+    routes.appRoutes.push({
+      type: RouteType.PAGE,
+      path: routePath.replace(/\/+/g, "/") || "/",
+      filePath: specialFiles.page,
+      pattern: createRoutePattern(routePath),
+      segments: parentSegments,
+      layout: specialFiles.layout || parentLayout,
+      loading: specialFiles.loading,
+      error: specialFiles.error,
+      notFound: specialFiles.notFound,
+      template: specialFiles.template,
+      middleware: specialFiles.middleware || parentMiddleware,
+      isServerComponent: isServerComponent(specialFiles.page),
+      isClientComponent: isClientComponent(specialFiles.page),
+      isIsland: isIsland(specialFiles.page)
+    });
+  }
+  for (const entry of entries) {
+    if (entry.isDirectory()) {
+      const fullPath = path2.join(currentDir, entry.name);
+      if (entry.name.startsWith("_") || entry.name.startsWith(".")) continue;
+      const isGroup = entry.name.startsWith("(") && entry.name.endsWith(")");
+      let segmentName = entry.name;
+      if (entry.name.startsWith("[") && entry.name.endsWith("]")) {
+        segmentName = ":" + entry.name.slice(1, -1);
+        if (entry.name.startsWith("[...")) {
+          segmentName = "*" + entry.name.slice(4, -1);
+        }
+        if (entry.name.startsWith("[[...")) {
+          segmentName = "*" + entry.name.slice(5, -2);
+        }
+      }
+      const newSegments = isGroup ? parentSegments : [...parentSegments, segmentName];
+      const newLayout = specialFiles.layout || parentLayout;
+      const newMiddleware = specialFiles.middleware || parentMiddleware;
+      scanAppDirectory(baseDir, fullPath, routes, newSegments, newLayout, newMiddleware);
+    }
+  }
+}
+function scanApiDirectory(baseDir, currentDir, routes, parentSegments = []) {
+  const entries = fs.readdirSync(currentDir, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = path2.join(currentDir, entry.name);
+    if (entry.isDirectory()) {
+      scanApiDirectory(baseDir, fullPath, routes, [...parentSegments, entry.name]);
+    } else if (entry.isFile()) {
+      const ext = path2.extname(entry.name);
+      if (![".ts", ".js"].includes(ext)) continue;
+      const baseName = path2.basename(entry.name, ext);
+      const apiSegments = baseName === "route" || baseName === "index" ? parentSegments : [...parentSegments, baseName];
+      const apiPath = "/api/" + apiSegments.join("/");
+      routes.api.push({
+        type: RouteType.API,
+        path: apiPath.replace(/\/+/g, "/") || "/api",
+        filePath: fullPath,
+        pattern: createRoutePattern(apiPath),
+        segments: ["api", ...apiSegments].filter(Boolean)
+      });
+    }
+  }
+}
+function createRoutePattern(routePath) {
+  let pattern = routePath.replace(/\*[^/]*/g, "(.*)").replace(/:[^/]+/g, "([^/]+)").replace(/\//g, "\\/");
+  return new RegExp(`^${pattern}$`);
+}
+function matchRoute(urlPath, routes) {
+  const normalizedPath = urlPath === "" ? "/" : urlPath.split("?")[0];
+  for (const route of routes) {
+    const match = normalizedPath.match(route.pattern);
+    if (match) {
+      const params = extractParams(route.path, match);
+      return { ...route, params };
+    }
+  }
+  return null;
+}
+function extractParams(routePath, match) {
+  const params = {};
+  const paramNames = [];
+  const paramRegex = /:([^/]+)|\*([^/]*)/g;
+  let paramMatch;
+  while ((paramMatch = paramRegex.exec(routePath)) !== null) {
+    paramNames.push(paramMatch[1] || paramMatch[2] || "splat");
+  }
+  paramNames.forEach((name, index) => {
+    params[name] = match[index + 1];
+  });
+  return params;
+}
+function findRouteLayouts(route, layoutsMap) {
+  const layouts = [];
+  for (const segment of route.segments) {
+    if (layoutsMap.has(segment)) {
+      layouts.push({ name: segment, filePath: layoutsMap.get(segment) });
+    }
+  }
+  if (route.layout) {
+    layouts.push({ name: "route", filePath: route.layout });
+  }
+  if (layoutsMap.has("root")) {
+    layouts.unshift({ name: "root", filePath: layoutsMap.get("root") });
+  }
+  return layouts;
+}
+function buildTree(routes) {
+  const tree = { children: {}, routes: [] };
+  for (const route of routes) {
+    let current = tree;
+    for (const segment of route.segments) {
+      if (!current.children[segment]) {
+        current.children[segment] = { children: {}, routes: [] };
+      }
+      current = current.children[segment];
+    }
+    current.routes.push(route);
+  }
+  return tree;
+}
+var AppConfigSchema = z.object({
+  name: z.string().default("Velix App"),
+  url: z.string().url().optional()
+}).default({});
+var ServerConfigSchema = z.object({
+  port: z.number().min(1).max(65535).default(3e3),
+  host: z.string().default("localhost")
+}).default({});
+var RoutingConfigSchema = z.object({
+  trailingSlash: z.boolean().default(false)
+}).default({});
+var SEOConfigSchema = z.object({
+  sitemap: z.boolean().default(true),
+  robots: z.boolean().default(true),
+  openGraph: z.boolean().default(true)
+}).default({});
+var BuildConfigSchema = z.object({
+  target: z.string().default("es2022"),
+  minify: z.boolean().default(true),
+  sourcemap: z.boolean().default(true),
+  splitting: z.boolean().default(true),
+  outDir: z.string().default(".velix")
+}).default({});
+var ExperimentalConfigSchema = z.object({
+  islands: z.boolean().default(true),
+  streaming: z.boolean().default(true)
+}).default({});
+var PluginSchema = z.union([
+  z.string(),
+  z.object({
+    name: z.string()
+  }).passthrough()
+]);
+var VelixConfigSchema = z.object({
+  // App identity
+  app: AppConfigSchema,
+  // DevTools toggle
+  devtools: z.boolean().default(true),
+  // Server options
+  server: ServerConfigSchema,
+  // Routing options
+  routing: RoutingConfigSchema,
+  // SEO configuration
+  seo: SEOConfigSchema,
+  // Build options
+  build: BuildConfigSchema,
+  // Experimental features
+  experimental: ExperimentalConfigSchema,
+  // Plugins
+  plugins: z.array(PluginSchema).default([]),
+  // Directories (resolved automatically)
+  appDir: z.string().default("app"),
+  publicDir: z.string().default("public"),
+  // Stylesheets
+  styles: z.array(z.string()).default([]),
+  // Favicon
+  favicon: z.string().nullable().default(null)
+});
+var defaultConfig = VelixConfigSchema.parse({});
+function defineConfig(config) {
+  return config;
+}
+async function loadConfig(projectRoot) {
+  const configPathTs = path2.join(projectRoot, "velix.config.ts");
+  const configPathJs = path2.join(projectRoot, "velix.config.js");
+  const configPathLegacyTs = path2.join(projectRoot, "flexireact.config.ts");
+  const configPathLegacyJs = path2.join(projectRoot, "flexireact.config.js");
+  let configPath = null;
+  if (fs.existsSync(configPathTs)) configPath = configPathTs;
+  else if (fs.existsSync(configPathJs)) configPath = configPathJs;
+  else if (fs.existsSync(configPathLegacyTs)) configPath = configPathLegacyTs;
+  else if (fs.existsSync(configPathLegacyJs)) configPath = configPathLegacyJs;
+  let userConfig = {};
+  if (configPath) {
+    try {
+      const configUrl = pathToFileURL(configPath).href;
+      const module = await import(`${configUrl}?t=${Date.now()}`);
+      userConfig = module.default || module;
+    } catch (error) {
+      console.warn(pc.yellow(`\u26A0 Failed to load config: ${error.message}`));
+    }
+  }
+  const merged = deepMerge(defaultConfig, userConfig);
+  try {
+    return VelixConfigSchema.parse(merged);
+  } catch (err) {
+    if (err instanceof z.ZodError) {
+      console.error(pc.red("\u2716 Configuration validation failed:"));
+      for (const issue of err.issues) {
+        console.error(pc.dim(`  - ${issue.path.join(".")}: ${issue.message}`));
+      }
+      process.exit(1);
+    }
+    throw err;
+  }
+}
+function resolvePaths(config, projectRoot) {
+  return {
+    ...config,
+    resolvedAppDir: path2.resolve(projectRoot, config.appDir),
+    resolvedPublicDir: path2.resolve(projectRoot, config.publicDir),
+    resolvedOutDir: path2.resolve(projectRoot, config.build.outDir)
+  };
+}
+function deepMerge(target, source) {
+  const result = { ...target };
+  for (const key in source) {
+    if (source[key] && typeof source[key] === "object" && !Array.isArray(source[key])) {
+      result[key] = deepMerge(target[key] || {}, source[key]);
+    } else {
+      result[key] = source[key];
+    }
+  }
+  return result;
+}
+
+// src/version.ts
+var VERSION = "5.1.7";
+
+// src/logger.ts
+var colors = {
+  reset: "\x1B[0m",
+  bold: "\x1B[1m",
+  dim: "\x1B[2m",
+  red: "\x1B[31m",
+  green: "\x1B[32m",
+  yellow: "\x1B[33m",
+  cyan: "\x1B[36m",
+  white: "\x1B[37m",
+  gray: "\x1B[90m"
+};
+var c = colors;
+function getStatusColor(status) {
+  if (status >= 500) return c.red;
+  if (status >= 400) return c.yellow;
+  if (status >= 300) return c.cyan;
+  if (status >= 200) return c.green;
+  return c.white;
+}
+function fmtTime(ms) {
+  if (ms < 1) return `${c.gray}<1ms${c.reset}`;
+  if (ms < 100) return `${c.green}${ms}ms${c.reset}`;
+  if (ms < 500) return `${c.yellow}${ms}ms${c.reset}`;
+  return `${c.red}${ms}ms${c.reset}`;
+}
+var LOGO = `
+  ${c.cyan}\u25B2${c.reset} ${c.bold}Velix${c.reset} ${c.dim}v${VERSION}${c.reset}
+`;
+var logger = {
+  logo() {
+    console.log(LOGO);
+    console.log(`${c.dim}  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500${c.reset}`);
+    console.log("");
+  },
+  serverStart(config, startTime = Date.now()) {
+    const { port, host, mode, pagesDir } = config;
+    const elapsed = Date.now() - startTime;
+    console.log(LOGO);
+    console.log(`  ${c.green}\u2714${c.reset} ${c.bold}Ready${c.reset} in ${elapsed}ms`);
+    console.log("");
+    console.log(`  ${c.bold}Local:${c.reset}      ${c.cyan}http://${host}:${port}${c.reset}`);
+    console.log(`  ${c.bold}Mode:${c.reset}       ${mode === "development" ? c.yellow : c.green}${mode}${c.reset}`);
+    if (pagesDir) console.log(`  ${c.bold}App:${c.reset}        ${c.dim}${pagesDir}${c.reset}`);
+    console.log("");
+  },
+  request(method, path6, status, time, extra = {}) {
+    const statusColor = getStatusColor(status);
+    const timeStr = fmtTime(time);
+    let badge = `${c.dim}\u25CB${c.reset}`;
+    if (extra.type === "dynamic" || extra.type === "ssr") badge = `${c.white}\u0192${c.reset}`;
+    else if (extra.type === "api") badge = `${c.cyan}\u03BB${c.reset}`;
+    const statusStr = `${statusColor}${status}${c.reset}`;
+    console.log(`  ${badge} ${c.white}${method}${c.reset} ${path6} ${statusStr} ${c.dim}${timeStr}${c.reset}`);
+  },
+  info(msg) {
+    console.log(`  ${c.cyan}\u2139${c.reset} ${msg}`);
+  },
+  success(msg) {
+    console.log(`  ${c.green}\u2714${c.reset} ${msg}`);
+  },
+  warn(msg) {
+    console.log(`  ${c.yellow}\u26A0${c.reset} ${c.yellow}${msg}${c.reset}`);
+  },
+  error(msg, err = null) {
+    console.log(`  ${c.red}\u2716${c.reset} ${c.red}${msg}${c.reset}`);
+    if (err?.stack) {
+      console.log("");
+      console.log(`${c.dim}${err.stack.split("\n").slice(1, 4).join("\n")}${c.reset}`);
+      console.log("");
+    }
+  },
+  compile(file, time) {
+    console.log(`  ${c.white}\u25CF${c.reset} Compiling ${c.dim}${file}${c.reset} ${c.dim}(${time}ms)${c.reset}`);
+  },
+  hmr(file) {
+    console.log(`  ${c.green}\u21BB${c.reset} Fast Refresh ${c.dim}${file}${c.reset}`);
+  },
+  plugin(name) {
+    console.log(`  ${c.cyan}\u25C6${c.reset} Plugin ${c.dim}${name}${c.reset}`);
+  },
+  route(path6, type) {
+    const typeLabel = type === "api" ? "\u03BB" : type === "dynamic" ? "\u0192" : "\u25CB";
+    const color = type === "api" ? c.cyan : type === "dynamic" ? c.white : c.dim;
+    console.log(`  ${color}${typeLabel}${c.reset} ${path6}`);
+  },
+  divider() {
+    console.log(`${c.dim}  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500${c.reset}`);
+  },
+  blank() {
+    console.log("");
+  },
+  portInUse(port) {
+    this.error(`Port ${port} is already in use.`);
+    this.blank();
+    console.log(`  ${c.dim}Try:${c.reset}`);
+    console.log(`  1. Kill the process on port ${port}`);
+    console.log(`  2. Use a different port via PORT env var`);
+    this.blank();
+  },
+  build(stats) {
+    this.blank();
+    console.log(`  ${c.green}\u2714${c.reset} Build completed`);
+    this.blank();
+    console.log(`  ${c.dim}Total time:${c.reset} ${c.white}${stats.time}ms${c.reset}`);
+    this.blank();
+  }
+};
+
+// src/metadata/index.ts
+function generateMetadataTags(metadata, baseUrl) {
+  const tags = [];
+  const base = baseUrl || metadata.metadataBase?.toString() || "";
+  if (metadata.title) {
+    const title = typeof metadata.title === "string" ? metadata.title : metadata.title.absolute || (metadata.title.template ? metadata.title.template.replace("%s", metadata.title.default) : metadata.title.default);
+    tags.push(`<title>${escapeHtml2(title)}</title>`);
+  }
+  if (metadata.description) tags.push(`<meta name="description" content="${escapeHtml2(metadata.description)}">`);
+  if (metadata.keywords) {
+    const kw = Array.isArray(metadata.keywords) ? metadata.keywords.join(", ") : metadata.keywords;
+    tags.push(`<meta name="keywords" content="${escapeHtml2(kw)}">`);
+  }
+  if (metadata.authors) {
+    const authors = Array.isArray(metadata.authors) ? metadata.authors : [metadata.authors];
+    authors.forEach((a) => {
+      if (a.name) tags.push(`<meta name="author" content="${escapeHtml2(a.name)}">`);
+      if (a.url) tags.push(`<link rel="author" href="${a.url}">`);
+    });
+  }
+  if (metadata.generator) tags.push(`<meta name="generator" content="${escapeHtml2(metadata.generator)}">`);
+  if (metadata.applicationName) tags.push(`<meta name="application-name" content="${escapeHtml2(metadata.applicationName)}">`);
+  if (metadata.referrer) tags.push(`<meta name="referrer" content="${metadata.referrer}">`);
+  if (metadata.robots) {
+    if (typeof metadata.robots === "string") {
+      tags.push(`<meta name="robots" content="${metadata.robots}">`);
+    } else {
+      tags.push(`<meta name="robots" content="${generateRobotsContent(metadata.robots)}">`);
+      if (metadata.robots.googleBot) {
+        const gbc = typeof metadata.robots.googleBot === "string" ? metadata.robots.googleBot : generateRobotsContent(metadata.robots.googleBot);
+        tags.push(`<meta name="googlebot" content="${gbc}">`);
+      }
+    }
+  }
+  if (metadata.viewport) {
+    const vc = typeof metadata.viewport === "string" ? metadata.viewport : generateViewportContent(metadata.viewport);
+    tags.push(`<meta name="viewport" content="${vc}">`);
+  }
+  if (metadata.themeColor) {
+    const tcs = Array.isArray(metadata.themeColor) ? metadata.themeColor : [metadata.themeColor];
+    tcs.forEach((tc) => {
+      const media = typeof tc !== "string" && tc.media ? ` media="${tc.media}"` : "";
+      const color = typeof tc === "string" ? tc : tc.color;
+      tags.push(`<meta name="theme-color" content="${color}"${media}>`);
+    });
+  }
+  if (metadata.colorScheme) tags.push(`<meta name="color-scheme" content="${metadata.colorScheme}">`);
+  if (metadata.icons) {
+    const addIcon = (icon, defaultRel) => {
+      const rel = icon.rel || defaultRel;
+      const attrs = [
+        icon.type ? ` type="${icon.type}"` : "",
+        icon.sizes ? ` sizes="${icon.sizes}"` : "",
+        icon.color ? ` color="${icon.color}"` : ""
+      ].join("");
+      tags.push(`<link rel="${rel}" href="${resolveUrl(icon.url, base)}"${attrs}>`);
+    };
+    if (metadata.icons.icon) {
+      (Array.isArray(metadata.icons.icon) ? metadata.icons.icon : [metadata.icons.icon]).forEach((i) => addIcon(i, "icon"));
+    }
+    if (metadata.icons.apple) {
+      (Array.isArray(metadata.icons.apple) ? metadata.icons.apple : [metadata.icons.apple]).forEach((i) => addIcon(i, "apple-touch-icon"));
+    }
+  }
+  if (metadata.manifest) tags.push(`<link rel="manifest" href="${resolveUrl(metadata.manifest, base)}">`);
+  if (metadata.openGraph) {
+    const og = metadata.openGraph;
+    if (og.type) tags.push(`<meta property="og:type" content="${og.type}">`);
+    if (og.title) tags.push(`<meta property="og:title" content="${escapeHtml2(og.title)}">`);
+    if (og.description) tags.push(`<meta property="og:description" content="${escapeHtml2(og.description)}">`);
+    if (og.url) tags.push(`<meta property="og:url" content="${resolveUrl(og.url, base)}">`);
+    if (og.siteName) tags.push(`<meta property="og:site_name" content="${escapeHtml2(og.siteName)}">`);
+    if (og.locale) tags.push(`<meta property="og:locale" content="${og.locale}">`);
+    if (og.images) {
+      (Array.isArray(og.images) ? og.images : [og.images]).forEach((img) => {
+        tags.push(`<meta property="og:image" content="${resolveUrl(img.url, base)}">`);
+        if (img.width) tags.push(`<meta property="og:image:width" content="${img.width}">`);
+        if (img.height) tags.push(`<meta property="og:image:height" content="${img.height}">`);
+        if (img.alt) tags.push(`<meta property="og:image:alt" content="${escapeHtml2(img.alt)}">`);
+      });
+    }
+    if (og.type === "article") {
+      if (og.publishedTime) tags.push(`<meta property="article:published_time" content="${og.publishedTime}">`);
+      if (og.modifiedTime) tags.push(`<meta property="article:modified_time" content="${og.modifiedTime}">`);
+      if (og.tags) og.tags.forEach((t) => tags.push(`<meta property="article:tag" content="${escapeHtml2(t)}">`));
+    }
+  }
+  if (metadata.twitter) {
+    const tw = metadata.twitter;
+    if (tw.card) tags.push(`<meta name="twitter:card" content="${tw.card}">`);
+    if (tw.site) tags.push(`<meta name="twitter:site" content="${tw.site}">`);
+    if (tw.creator) tags.push(`<meta name="twitter:creator" content="${tw.creator}">`);
+    if (tw.title) tags.push(`<meta name="twitter:title" content="${escapeHtml2(tw.title)}">`);
+    if (tw.description) tags.push(`<meta name="twitter:description" content="${escapeHtml2(tw.description)}">`);
+    if (tw.images) {
+      (Array.isArray(tw.images) ? tw.images : [tw.images]).forEach((img) => {
+        const url = typeof img === "string" ? img : img.url;
+        tags.push(`<meta name="twitter:image" content="${resolveUrl(url, base)}">`);
+      });
+    }
+  }
+  if (metadata.verification) {
+    if (metadata.verification.google) {
+      (Array.isArray(metadata.verification.google) ? metadata.verification.google : [metadata.verification.google]).forEach((v) => tags.push(`<meta name="google-site-verification" content="${v}">`));
+    }
+  }
+  if (metadata.alternates) {
+    if (metadata.alternates.canonical) tags.push(`<link rel="canonical" href="${resolveUrl(metadata.alternates.canonical, base)}">`);
+    if (metadata.alternates.languages) {
+      Object.entries(metadata.alternates.languages).forEach(([lang, url]) => {
+        tags.push(`<link rel="alternate" hreflang="${lang}" href="${resolveUrl(url, base)}">`);
+      });
+    }
+  }
+  return tags.join("\n    ");
+}
+function mergeMetadata(parent, child) {
+  return {
+    ...parent,
+    ...child,
+    openGraph: child.openGraph ? { ...parent.openGraph, ...child.openGraph } : parent.openGraph,
+    twitter: child.twitter ? { ...parent.twitter, ...child.twitter } : parent.twitter,
+    icons: child.icons ? { ...parent.icons, ...child.icons } : parent.icons,
+    alternates: child.alternates ? { ...parent.alternates, ...child.alternates } : parent.alternates
+  };
+}
+function generateJsonLd(data) {
+  return `<script type="application/ld+json">${JSON.stringify(data)}</script>`;
+}
+var jsonLd = {
+  website: (c2) => ({
+    "@context": "https://schema.org",
+    "@type": "WebSite",
+    name: c2.name,
+    url: c2.url,
+    description: c2.description
+  }),
+  article: (c2) => ({
+    "@context": "https://schema.org",
+    "@type": "Article",
+    headline: c2.headline,
+    description: c2.description,
+    image: c2.image,
+    datePublished: c2.datePublished,
+    dateModified: c2.dateModified || c2.datePublished,
+    author: Array.isArray(c2.author) ? c2.author.map((a) => ({ "@type": "Person", ...a })) : { "@type": "Person", ...c2.author }
+  }),
+  organization: (c2) => ({
+    "@context": "https://schema.org",
+    "@type": "Organization",
+    name: c2.name,
+    url: c2.url,
+    logo: c2.logo,
+    sameAs: c2.sameAs
+  }),
+  breadcrumb: (items) => ({
+    "@context": "https://schema.org",
+    "@type": "BreadcrumbList",
+    itemListElement: items.map((item, i) => ({ "@type": "ListItem", position: i + 1, name: item.name, item: item.url }))
+  })
+};
+function generateSitemap(routes, baseUrl) {
+  const urls = routes.filter((r) => r.type === "page" && !r.path.includes(":") && !r.path.includes("*")).map((r) => {
+    const loc = `${baseUrl.replace(/\/$/, "")}${r.path}`;
+    return `  <url>
+    <loc>${loc}</loc>
+    <lastmod>${(/* @__PURE__ */ new Date()).toISOString().split("T")[0]}</lastmod>
+    <changefreq>weekly</changefreq>
+    <priority>${r.path === "/" ? "1.0" : "0.8"}</priority>
+  </url>`;
+  });
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
+${urls.join("\n")}
+</urlset>`;
+}
+function generateRobotsTxt(baseUrl, options = {}) {
+  const lines = ["User-agent: *"];
+  if (options.allow) options.allow.forEach((p) => lines.push(`Allow: ${p}`));
+  if (options.disallow) options.disallow.forEach((p) => lines.push(`Disallow: ${p}`));
+  else lines.push("Allow: /");
+  lines.push("", `Sitemap: ${baseUrl.replace(/\/$/, "")}/sitemap.xml`);
+  return lines.join("\n");
+}
+function escapeHtml2(str) {
+  return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#039;");
+}
+function resolveUrl(url, base) {
+  if (url.startsWith("http://") || url.startsWith("https://") || url.startsWith("//")) return url;
+  return base ? `${base.replace(/\/$/, "")}${url.startsWith("/") ? "" : "/"}${url}` : url;
+}
+function generateRobotsContent(robots) {
+  const parts = [];
+  if (robots.index !== void 0) parts.push(robots.index ? "index" : "noindex");
+  if (robots.follow !== void 0) parts.push(robots.follow ? "follow" : "nofollow");
+  if (robots.noarchive) parts.push("noarchive");
+  if (robots.nosnippet) parts.push("nosnippet");
+  if (robots.noimageindex) parts.push("noimageindex");
+  return parts.join(", ") || "index, follow";
+}
+function generateViewportContent(viewport) {
+  const parts = [];
+  if (viewport.width) parts.push(`width=${viewport.width}`);
+  if (viewport.height) parts.push(`height=${viewport.height}`);
+  if (viewport.initialScale !== void 0) parts.push(`initial-scale=${viewport.initialScale}`);
+  if (viewport.maximumScale !== void 0) parts.push(`maximum-scale=${viewport.maximumScale}`);
+  if (viewport.userScalable !== void 0) parts.push(`user-scalable=${viewport.userScalable ? "yes" : "no"}`);
+  return parts.join(", ") || "width=device-width, initial-scale=1";
+}
+var middlewares = {
+  cors(options = {}) {
+    const {
+      origin = "*",
+      methods = ["GET", "POST", "PUT", "DELETE", "PATCH", "OPTIONS"],
+      headers: allowHeaders = ["Content-Type", "Authorization"],
+      credentials = false,
+      maxAge = 86400
+    } = options;
+    return async (req, res, next) => {
+      const originHeader = typeof origin === "string" ? origin : origin.includes(req.headers.origin) ? req.headers.origin : "";
+      res.header("Access-Control-Allow-Origin", originHeader);
+      res.header("Access-Control-Allow-Methods", methods.join(", "));
+      res.header("Access-Control-Allow-Headers", allowHeaders.join(", "));
+      res.header("Access-Control-Max-Age", String(maxAge));
+      if (credentials) {
+        res.header("Access-Control-Allow-Credentials", "true");
+      }
+      if (req.method === "OPTIONS") {
+        res.status(204);
+        return;
+      }
+      await next();
+    };
+  },
+  rateLimit(options = {}) {
+    const { windowMs = 6e4, max = 100, message = "Too many requests" } = options;
+    const store = /* @__PURE__ */ new Map();
+    return async (req, res, next) => {
+      const ip = req.headers["x-forwarded-for"] || "unknown";
+      const now = Date.now();
+      const record = store.get(ip);
+      if (!record || now > record.resetTime) {
+        store.set(ip, { count: 1, resetTime: now + windowMs });
+      } else if (record.count >= max) {
+        res.status(429).json({ error: message });
+        return;
+      } else {
+        record.count++;
+      }
+      await next();
+    };
+  },
+  security() {
+    return async (_req, res, next) => {
+      res.header("X-Content-Type-Options", "nosniff");
+      res.header("X-Frame-Options", "DENY");
+      res.header("X-XSS-Protection", "1; mode=block");
+      res.header("Referrer-Policy", "strict-origin-when-cross-origin");
+      await next();
+    };
+  }
+};
+async function loadMiddleware(projectRoot) {
+  const fns = [];
+  const possibleFiles = ["proxy.ts", "proxy.js"];
+  for (const file of possibleFiles) {
+    const filePath = path2.join(projectRoot, file);
+    if (!fs.existsSync(filePath)) continue;
+    try {
+      const { pathToFileURL: pathToFileURL3 } = await import('url');
+      const url = pathToFileURL3(filePath).href;
+      const mod = await import(`${url}?t=${Date.now()}`);
+      const fn = mod.default || mod.proxy || mod.middleware;
+      if (typeof fn === "function") {
+        fns.push(fn);
+        break;
+      }
+    } catch (err) {
+      const error = err;
+      console.warn(`\u26A0 Failed to load proxy ${file}: ${error.message}`);
+    }
+  }
+  return fns;
+}
+async function runMiddleware(req, res, fns) {
+  const result = { continue: true, rewritten: false };
+  if (fns.length === 0) return result;
+  const url = new URL(req.url || "/", `http://${req.headers.host || "localhost"}`);
+  const cookies = {};
+  const cookieHeader = req.headers.cookie;
+  if (cookieHeader) {
+    cookieHeader.split(";").forEach((c2) => {
+      const [k, ...v] = c2.split("=");
+      if (k) cookies[k.trim()] = v.join("=").trim();
+    });
+  }
+  const mReq = {
+    url: req.url || "/",
+    method: req.method || "GET",
+    headers: req.headers,
+    cookies,
+    params: {},
+    query: Object.fromEntries(url.searchParams),
+    raw: req
+  };
+  let ended = false;
+  const mRes = {
+    _statusCode: 200,
+    _headers: {},
+    _redirectUrl: null,
+    _rewriteUrl: null,
+    _ended: false,
+    status(code) {
+      this._statusCode = code;
+      return this;
+    },
+    header(name, value) {
+      this._headers[name] = value;
+      return this;
+    },
+    json(data) {
+      this._headers["Content-Type"] = "application/json";
+      res.writeHead(this._statusCode, this._headers);
+      res.end(JSON.stringify(data));
+      this._ended = true;
+      ended = true;
+    },
+    redirect(url2, status = 307) {
+      this._redirectUrl = url2;
+      this._statusCode = status;
+      res.writeHead(status, { Location: url2, ...this._headers });
+      res.end();
+      this._ended = true;
+      ended = true;
+    },
+    rewrite(url2) {
+      this._rewriteUrl = url2;
+      req.url = url2;
+      result.rewritten = true;
+    },
+    async next() {
+    }
+  };
+  let index = 0;
+  const next = async () => {
+    if (ended || index >= fns.length) return;
+    const fn = fns[index++];
+    await fn(mReq, mRes, next);
+  };
+  await next();
+  if (!ended) {
+    for (const [key, value] of Object.entries(mRes._headers)) {
+      res.setHeader(key, value);
+    }
+  }
+  result.continue = !ended;
+  return result;
+}
+function composeMiddleware(...fns) {
+  return async (req, res, next) => {
+    let index = 0;
+    const run = async () => {
+      if (index >= fns.length) {
+        await next();
+        return;
+      }
+      const fn = fns[index++];
+      await fn(req, res, run);
+    };
+    await run();
+  };
+}
+var PluginHooks = {
+  CONFIG: "config",
+  SERVER_START: "server:start",
+  REQUEST: "request",
+  RESPONSE: "response",
+  ROUTES_LOADED: "routes:loaded",
+  BEFORE_RENDER: "render:before",
+  AFTER_RENDER: "render:after",
+  BUILD_START: "build:start",
+  BUILD_END: "build:end"
+};
+var PluginManager = class {
+  plugins = [];
+  hooks = /* @__PURE__ */ new Map();
+  /**
+   * Register a plugin
+   */
+  register(plugin) {
+    this.plugins.push(plugin);
+    if (plugin.hooks) {
+      for (const [hookName, handler] of Object.entries(plugin.hooks)) {
+        if (handler) {
+          const existing = this.hooks.get(hookName) || [];
+          existing.push(handler);
+          this.hooks.set(hookName, existing);
+        }
+      }
+    }
+  }
+  /**
+   * Run a hook with arguments
+   */
+  async runHook(hookName, ...args) {
+    const handlers = this.hooks.get(hookName) || [];
+    for (const handler of handlers) {
+      await handler(...args);
+    }
+  }
+  /**
+   * Run a waterfall hook — each handler transforms the first argument
+   */
+  async runWaterfallHook(hookName, value, ...args) {
+    const handlers = this.hooks.get(hookName) || [];
+    let result = value;
+    for (const handler of handlers) {
+      const transformed = await handler(result, ...args);
+      if (transformed !== void 0) result = transformed;
+    }
+    return result;
+  }
+  /**
+   * Get all registered plugins
+   */
+  getPlugins() {
+    return [...this.plugins];
+  }
+  /**
+   * Check if a plugin is registered
+   */
+  hasPlugin(name) {
+    return this.plugins.some((p) => p.name === name);
+  }
+};
+var pluginManager = new PluginManager();
+async function loadPlugins(projectRoot, config) {
+  const pluginEntries = config.plugins || [];
+  for (const entry of pluginEntries) {
+    try {
+      if (typeof entry === "string") {
+        const localPath = path2.join(projectRoot, "plugins", entry + ".ts");
+        const localPathJs = path2.join(projectRoot, "plugins", entry + ".js");
+        const localPathDir = path2.join(projectRoot, "plugins", entry, "index.ts");
+        let pluginPath = null;
+        if (fs.existsSync(localPath)) pluginPath = localPath;
+        else if (fs.existsSync(localPathJs)) pluginPath = localPathJs;
+        else if (fs.existsSync(localPathDir)) pluginPath = localPathDir;
+        if (pluginPath) {
+          const url = pathToFileURL(pluginPath).href;
+          const mod = await import(`${url}?t=${Date.now()}`);
+          const plugin = mod.default || mod;
+          if (plugin.name) {
+            pluginManager.register(plugin);
+          }
+        } else {
+          try {
+            const mod = await import(entry);
+            const plugin = mod.default || mod;
+            if (plugin.name) pluginManager.register(plugin);
+          } catch {
+            console.warn(`\u26A0 Plugin not found: ${entry}`);
+          }
+        }
+      } else if (typeof entry === "object" && entry !== null && "name" in entry) {
+        pluginManager.register(entry);
+      }
+    } catch (err) {
+      const error = err;
+      console.warn(`\u26A0 Failed to load plugin: ${error?.message || String(error)}`);
+    }
+  }
+}
+function definePlugin(definition) {
+  return definition;
+}
+var builtinPlugins = {
+  /**
+   * Security headers plugin
+   */
+  security: definePlugin({
+    name: "velix:security",
+    hooks: {
+      [PluginHooks.RESPONSE]: (_req, res) => {
+        const response = res;
+        if (!response.headersSent) {
+          response.setHeader("X-Content-Type-Options", "nosniff");
+          response.setHeader("X-Frame-Options", "DENY");
+          response.setHeader("X-XSS-Protection", "1; mode=block");
+        }
+      }
+    }
+  }),
+  /**
+   * Request logging plugin
+   */
+  logger: definePlugin({
+    name: "velix:logger",
+    hooks: {
+      [PluginHooks.RESPONSE]: (req, _res, duration) => {
+        const request = req;
+        console.log(`  ${request.method} ${request.url} ${duration}ms`);
+      }
+    }
+  })
+};
+
+// src/plugins/ai/utils.ts
+async function retry(fn, options = { maxRetries: 3, retryDelay: 1e3 }) {
+  let lastError;
+  for (let i = 0; i < options.maxRetries; i++) {
+    try {
+      return await fn();
+    } catch (error) {
+      lastError = error;
+      if (i < options.maxRetries - 1) {
+        const delay = options.retryDelay * Math.pow(2, i);
+        await new Promise((resolve) => setTimeout(resolve, delay));
+      }
+    }
+  }
+  throw lastError || new Error("Retry failed");
+}
+function safeJsonParse(text, fallback) {
+  try {
+    const jsonMatch = text.match(/```json\n([\s\S]*?)\n```/);
+    if (jsonMatch) {
+      return JSON.parse(jsonMatch[1]);
+    }
+    return JSON.parse(text);
+  } catch {
+    return fallback ?? null;
+  }
+}
+function buildPrompt(template, variables) {
+  return template.replace(/\{\{(\w+)\}\}/g, (_, key) => {
+    const val = variables[key];
+    return val != null ? String(val) : "";
+  });
+}
+function validateApiKey(apiKey, provider) {
+  if (!apiKey || apiKey.trim() === "") {
+    throw new Error(`API key is required for ${provider} provider`);
+  }
+}
+function validateInput(input, requiredFields) {
+  for (const field of requiredFields) {
+    if (!(field in input) || input[field] === void 0 || input[field] === null) {
+      throw new Error(`Missing required field: ${field}`);
+    }
+  }
+}
+function createStreamDecoder() {
+  const decoder = new TextDecoder();
+  return (chunk) => {
+    return decoder.decode(chunk, { stream: true });
+  };
+}
+function parseSSE(line) {
+  if (!line.startsWith("data: ")) {
+    return null;
+  }
+  const data = line.slice(6);
+  if (data === "[DONE]") {
+    return { done: true };
+  }
+  try {
+    return JSON.parse(data);
+  } catch {
+    return null;
+  }
+}
+function sanitizeInput(text) {
+  return text.trim().replace(/\0/g, "");
+}
+function estimateTokens(text) {
+  return Math.ceil(text.length / 4);
+}
+function truncateToTokens(text, maxTokens) {
+  const estimatedTokens = estimateTokens(text);
+  if (estimatedTokens <= maxTokens) {
+    return text;
+  }
+  const maxChars = maxTokens * 4;
+  return text.slice(0, maxChars) + "...";
+}
+
+// src/plugins/ai/providers/openai.ts
+var OpenAIProvider = class {
+  name = "openai";
+  apiKey;
+  baseUrl;
+  defaultModel;
+  organization;
+  retryConfig;
+  constructor(config) {
+    validateApiKey(config.apiKey, "OpenAI");
+    this.apiKey = config.apiKey;
+    this.baseUrl = config.baseUrl || "https://api.openai.com/v1";
+    this.defaultModel = config.defaultModel || "gpt-4o-mini";
+    this.organization = config.organization;
+    this.retryConfig = config.retry || { maxRetries: 3, retryDelay: 1e3 };
+  }
+  async generate(input) {
+    return retry(async () => {
+      const response = await fetch(`${this.baseUrl}/chat/completions`, {
+        method: "POST",
+        headers: this.getHeaders(),
+        body: JSON.stringify({
+          model: input.model || this.defaultModel,
+          messages: [
+            ...input.system ? [{ role: "system", content: input.system }] : [],
+            { role: "user", content: input.prompt }
+          ],
+          temperature: input.temperature ?? 0.7,
+          max_tokens: input.maxTokens,
+          stop: input.stop,
+          ...input.options
+        })
+      });
+      if (!response.ok) {
+        const error = await response.json();
+        throw new Error(`OpenAI API error: ${error.error?.message || response.statusText}`);
+      }
+      const data = await response.json();
+      return {
+        text: data.choices[0].message.content,
+        provider: "openai",
+        model: data.model,
+        usage: {
+          promptTokens: data.usage.prompt_tokens,
+          completionTokens: data.usage.completion_tokens,
+          totalTokens: data.usage.total_tokens
+        },
+        raw: data
+      };
+    }, this.retryConfig);
+  }
+  async chat(input) {
+    return retry(async () => {
+      const response = await fetch(`${this.baseUrl}/chat/completions`, {
+        method: "POST",
+        headers: this.getHeaders(),
+        body: JSON.stringify({
+          model: input.model || this.defaultModel,
+          messages: input.messages,
+          temperature: input.temperature ?? 0.7,
+          max_tokens: input.maxTokens,
+          stop: input.stop,
+          ...input.options
+        })
+      });
+      if (!response.ok) {
+        const error = await response.json();
+        throw new Error(`OpenAI API error: ${error.error?.message || response.statusText}`);
+      }
+      const data = await response.json();
+      return {
+        text: data.choices[0].message.content,
+        provider: "openai",
+        model: data.model,
+        usage: {
+          promptTokens: data.usage.prompt_tokens,
+          completionTokens: data.usage.completion_tokens,
+          totalTokens: data.usage.total_tokens
+        },
+        raw: data
+      };
+    }, this.retryConfig);
+  }
+  async *stream(input) {
+    const response = await fetch(`${this.baseUrl}/chat/completions`, {
+      method: "POST",
+      headers: this.getHeaders(),
+      body: JSON.stringify({
+        model: input.model || this.defaultModel,
+        messages: [
+          ...input.system ? [{ role: "system", content: input.system }] : [],
+          { role: "user", content: input.prompt }
+        ],
+        temperature: input.temperature ?? 0.7,
+        max_tokens: input.maxTokens,
+        stop: input.stop,
+        stream: true,
+        ...input.options
+      })
+    });
+    if (!response.ok) {
+      const error = await response.json();
+      throw new Error(`OpenAI API error: ${error.error?.message || response.statusText}`);
+    }
+    const reader = response.body?.getReader();
+    if (!reader) {
+      throw new Error("Response body is not readable");
+    }
+    const decoder = new TextDecoder();
+    let buffer = "";
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split("\n");
+        buffer = lines.pop() || "";
+        for (const line of lines) {
+          const trimmed = line.trim();
+          if (!trimmed || trimmed === "data: [DONE]") continue;
+          const parsed = parseSSE(trimmed);
+          if (!parsed) continue;
+          const delta = parsed.choices?.[0]?.delta?.content;
+          if (delta) {
+            yield {
+              text: delta,
+              done: false,
+              provider: "openai",
+              model: parsed.model
+            };
+          }
+        }
+      }
+      yield { text: "", done: true, provider: "openai" };
+    } finally {
+      reader.releaseLock();
+    }
+  }
+  async embed(input) {
+    return retry(async () => {
+      const response = await fetch(`${this.baseUrl}/embeddings`, {
+        method: "POST",
+        headers: this.getHeaders(),
+        body: JSON.stringify({
+          model: input.model || "text-embedding-3-small",
+          input: input.text
+        })
+      });
+      if (!response.ok) {
+        const error = await response.json();
+        throw new Error(`OpenAI API error: ${error.error?.message || response.statusText}`);
+      }
+      const data = await response.json();
+      return {
+        embedding: data.data[0].embedding,
+        provider: "openai",
+        model: data.model
+      };
+    }, this.retryConfig);
+  }
+  getHeaders() {
+    const headers = {
+      "Content-Type": "application/json",
+      "Authorization": `Bearer ${this.apiKey}`
+    };
+    if (this.organization) {
+      headers["OpenAI-Organization"] = this.organization;
+    }
+    return headers;
+  }
+};
+
+// src/plugins/ai/providers/ollama.ts
+var OllamaProvider = class {
+  name = "ollama";
+  baseUrl;
+  defaultModel;
+  retryConfig;
+  constructor(config = {}) {
+    this.baseUrl = config.baseUrl || "http://localhost:11434";
+    this.defaultModel = config.defaultModel || "llama3.2";
+    this.retryConfig = config.retry || { maxRetries: 3, retryDelay: 1e3 };
+  }
+  async generate(input) {
+    return retry(async () => {
+      const response = await fetch(`${this.baseUrl}/api/generate`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          model: input.model || this.defaultModel,
+          prompt: input.prompt,
+          system: input.system,
+          options: {
+            temperature: input.temperature ?? 0.7,
+            num_predict: input.maxTokens,
+            stop: input.stop,
+            ...input.options
+          },
+          stream: false
+        })
+      });
+      if (!response.ok) {
+        throw new Error(`Ollama API error: ${response.statusText}`);
+      }
+      const data = await response.json();
+      return {
+        text: data.response,
+        provider: "ollama",
+        model: data.model,
+        usage: {
+          promptTokens: data.prompt_eval_count || 0,
+          completionTokens: data.eval_count || 0,
+          totalTokens: (data.prompt_eval_count || 0) + (data.eval_count || 0)
+        },
+        raw: data
+      };
+    }, this.retryConfig);
+  }
+  async chat(input) {
+    return retry(async () => {
+      const response = await fetch(`${this.baseUrl}/api/chat`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          model: input.model || this.defaultModel,
+          messages: input.messages,
+          options: {
+            temperature: input.temperature ?? 0.7,
+            num_predict: input.maxTokens,
+            stop: input.stop,
+            ...input.options
+          },
+          stream: false
+        })
+      });
+      if (!response.ok) {
+        throw new Error(`Ollama API error: ${response.statusText}`);
+      }
+      const data = await response.json();
+      return {
+        text: data.message.content,
+        provider: "ollama",
+        model: data.model,
+        usage: {
+          promptTokens: data.prompt_eval_count || 0,
+          completionTokens: data.eval_count || 0,
+          totalTokens: (data.prompt_eval_count || 0) + (data.eval_count || 0)
+        },
+        raw: data
+      };
+    }, this.retryConfig);
+  }
+  async *stream(input) {
+    const response = await fetch(`${this.baseUrl}/api/generate`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        model: input.model || this.defaultModel,
+        prompt: input.prompt,
+        system: input.system,
+        options: {
+          temperature: input.temperature ?? 0.7,
+          num_predict: input.maxTokens,
+          stop: input.stop,
+          ...input.options
+        },
+        stream: true
+      })
+    });
+    if (!response.ok) {
+      throw new Error(`Ollama API error: ${response.statusText}`);
+    }
+    const reader = response.body?.getReader();
+    if (!reader) {
+      throw new Error("Response body is not readable");
+    }
+    const decoder = new TextDecoder();
+    let buffer = "";
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split("\n");
+        buffer = lines.pop() || "";
+        for (const line of lines) {
+          const trimmed = line.trim();
+          if (!trimmed) continue;
+          try {
+            const data = JSON.parse(trimmed);
+            if (data.response) {
+              yield {
+                text: data.response,
+                done: data.done || false,
+                provider: "ollama",
+                model: data.model
+              };
+            }
+            if (data.done) {
+              return;
+            }
+          } catch {
+          }
+        }
+      }
+      yield { text: "", done: true, provider: "ollama" };
+    } finally {
+      reader.releaseLock();
+    }
+  }
+  async embed(input) {
+    return retry(async () => {
+      const response = await fetch(`${this.baseUrl}/api/embeddings`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          model: input.model || this.defaultModel,
+          prompt: input.text
+        })
+      });
+      if (!response.ok) {
+        throw new Error(`Ollama API error: ${response.statusText}`);
+      }
+      const data = await response.json();
+      return {
+        embedding: data.embedding,
+        provider: "ollama",
+        model: data.model || input.model || this.defaultModel
+      };
+    }, this.retryConfig);
+  }
+};
+
+// src/plugins/ai/client.ts
+function createAIClient(config) {
+  const provider = createProvider(config);
+  return {
+    async generate(input) {
+      return provider.generate(input);
+    },
+    async chat(input) {
+      return provider.chat(input);
+    },
+    stream(input) {
+      return provider.stream(input);
+    },
+    async embed(input) {
+      return provider.embed(input);
+    },
+    getProvider() {
+      return provider;
+    }
+  };
+}
+function createProvider(config) {
+  switch (config.provider) {
+    case "openai":
+      return new OpenAIProvider({
+        apiKey: config.apiKey,
+        baseUrl: config.baseUrl,
+        defaultModel: config.defaultModel,
+        retry: config.retry
+      });
+    case "ollama":
+      return new OllamaProvider({
+        baseUrl: config.baseUrl,
+        defaultModel: config.defaultModel,
+        retry: config.retry
+      });
+    default:
+      throw new Error(`Unsupported AI provider: ${config.provider}`);
+  }
+}
+
+// src/plugins/ai/index.ts
+function useAI() {
+  if (typeof globalThis === "undefined" || !globalThis.__VELIX_AI__) {
+    throw new Error("AI client not initialized. Make sure aiPlugin is configured.");
+  }
+  return globalThis.__VELIX_AI__;
+}
+function createAIAction(config) {
+  return async (input) => {
+    const ai = useAI();
+    const prompt = config.prompt(input);
+    const response = await ai.generate({
+      prompt,
+      system: config.system,
+      model: config.model,
+      temperature: config.temperature
+    });
+    if (config.transform) {
+      return config.transform(response.text);
+    }
+    return response.text;
+  };
+}
+
+// src/cache/index.ts
+var VelixCache = class {
+  maxSize;
+  defaultTtl;
+  defaultSwr;
+  store = /* @__PURE__ */ new Map();
+  tagIndex = /* @__PURE__ */ new Map();
+  // LRU doubly-linked list sentinel nodes
+  head;
+  tail;
+  constructor(config = {}) {
+    this.maxSize = config.maxSize ?? 1e3;
+    this.defaultTtl = config.defaultTtl ?? 6e4;
+    this.defaultSwr = config.defaultSwr ?? 1e4;
+    this.head = this.createSentinel("__HEAD__");
+    this.tail = this.createSentinel("__TAIL__");
+    this.head.next = this.tail;
+    this.tail.prev = this.head;
+  }
+  /** Current number of entries */
+  get size() {
+    return this.store.size;
+  }
+  /**
+   * Store a value with optional TTL, SWR, and tags.
+   */
+  set(key, value, options) {
+    if (this.store.has(key)) {
+      this.removeEntry(this.store.get(key));
+    }
+    const entry = {
+      key,
+      value,
+      tags: new Set(options?.tags ?? []),
+      createdAt: Date.now(),
+      ttl: options?.ttl ?? this.defaultTtl,
+      swr: options?.swr ?? this.defaultSwr,
+      prev: null,
+      next: null
+    };
+    this.store.set(key, entry);
+    this.addToHead(entry);
+    for (const tag of entry.tags) {
+      if (!this.tagIndex.has(tag)) {
+        this.tagIndex.set(tag, /* @__PURE__ */ new Set());
+      }
+      this.tagIndex.get(tag).add(key);
+    }
+    while (this.store.size > this.maxSize) {
+      this.evictLRU();
+    }
+  }
+  /**
+   * Get a cached value. Returns `null` if not found or expired beyond SWR window.
+   *
+   * @returns `{ value, stale }` — `stale` is true when the entry is past TTL but within SWR window.
+   */
+  get(key) {
+    const entry = this.store.get(key);
+    if (!entry) return null;
+    const now = Date.now();
+    const age = now - entry.createdAt;
+    if (age > entry.ttl + entry.swr) {
+      this.removeEntry(entry);
+      return null;
+    }
+    this.moveToHead(entry);
+    const stale = age > entry.ttl;
+    return { value: entry.value, stale };
+  }
+  /**
+   * Simple get that returns only the value (ignoring staleness).
+   * Returns `null` if not found or expired.
+   */
+  getValue(key) {
+    const result = this.get(key);
+    return result ? result.value : null;
+  }
+  /** Check whether a key exists and is not expired */
+  has(key) {
+    return this.get(key) !== null;
+  }
+  /** Remove a specific key */
+  delete(key) {
+    const entry = this.store.get(key);
+    if (!entry) return false;
+    this.removeEntry(entry);
+    return true;
+  }
+  /** Invalidate a specific path/key */
+  revalidatePath(path6) {
+    this.delete(path6);
+  }
+  /** Invalidate all entries associated with a tag */
+  revalidateTag(tag) {
+    const keys = this.tagIndex.get(tag);
+    if (!keys) return;
+    for (const key of keys) {
+      const entry = this.store.get(key);
+      if (entry) {
+        this.removeEntry(entry);
+      }
+    }
+    this.tagIndex.delete(tag);
+  }
+  /** Clear all entries */
+  invalidateAll() {
+    this.store.clear();
+    this.tagIndex.clear();
+    this.head.next = this.tail;
+    this.tail.prev = this.head;
+  }
+  /** Get cache stats for debugging/monitoring */
+  stats() {
+    return {
+      size: this.store.size,
+      maxSize: this.maxSize,
+      tags: this.tagIndex.size
+    };
+  }
+  // ── Internal LRU operations ──
+  createSentinel(key) {
+    return {
+      key,
+      value: null,
+      tags: /* @__PURE__ */ new Set(),
+      createdAt: 0,
+      ttl: 0,
+      swr: 0,
+      prev: null,
+      next: null
+    };
+  }
+  addToHead(entry) {
+    entry.prev = this.head;
+    entry.next = this.head.next;
+    this.head.next.prev = entry;
+    this.head.next = entry;
+  }
+  removeFromList(entry) {
+    if (entry.prev) entry.prev.next = entry.next;
+    if (entry.next) entry.next.prev = entry.prev;
+    entry.prev = null;
+    entry.next = null;
+  }
+  moveToHead(entry) {
+    this.removeFromList(entry);
+    this.addToHead(entry);
+  }
+  evictLRU() {
+    const lru = this.tail.prev;
+    if (lru && lru !== this.head) {
+      this.removeEntry(lru);
+    }
+  }
+  removeEntry(entry) {
+    this.removeFromList(entry);
+    this.store.delete(entry.key);
+    for (const tag of entry.tags) {
+      const keys = this.tagIndex.get(tag);
+      if (keys) {
+        keys.delete(entry.key);
+        if (keys.size === 0) {
+          this.tagIndex.delete(tag);
+        }
+      }
+    }
+  }
+};
+var cacheManager = new VelixCache();
+function revalidatePath(path6, _type = "path") {
+  cacheManager.revalidatePath(path6);
+  if (typeof global !== "undefined" && global.__VELIX_HMR_SERVER__) {
+    global.__VELIX_HMR_SERVER__.broadcast(JSON.stringify({
+      type: "revalidate",
+      path: path6,
+      revalidationType: _type
+    }));
+  }
+}
+function revalidateTag(tag) {
+  cacheManager.revalidateTag(tag);
+  if (typeof global !== "undefined" && global.__VELIX_HMR_SERVER__) {
+    global.__VELIX_HMR_SERVER__.broadcast(JSON.stringify({
+      type: "revalidate",
+      tag
+    }));
+  }
+}
+function unstable_cache(fn, keys, options) {
+  return async () => {
+    const cacheKey = keys.join(":");
+    const cached = cacheManager.get(cacheKey);
+    if (cached && !cached.stale) {
+      return cached.value;
+    }
+    const result = await fn();
+    cacheManager.set(cacheKey, result, {
+      tags: options?.tags,
+      ttl: options?.revalidate ? options.revalidate * 1e3 : void 0
+    });
+    return result;
+  };
+}
+
+export { OllamaProvider, OpenAIProvider, PluginHooks, PluginManager, RouteType, VelixCache, VelixConfigSchema, buildPrompt, buildRouteTree, builtinPlugins, cacheManager, cleanDir, composeMiddleware, copyDir, createAIAction, createAIClient, createDeferred, createStreamDecoder, debounce, defaultConfig, defineConfig, definePlugin, ensureDir, escapeHtml, estimateTokens, findFiles, findRouteLayouts, formatBytes, formatTime, generateHash, generateJsonLd, generateMetadataTags, generateRobotsTxt, generateSitemap, isClientComponent, isIsland, isServerComponent, jsonLd, loadConfig, loadMiddleware, loadPlugins, logger, matchRoute, mergeMetadata, middlewares, parseSSE, pluginManager, resolvePaths, retry, revalidatePath, revalidateTag, runMiddleware, safeJsonParse, sanitizeInput, sleep, truncateToTokens, unstable_cache, useAI, validateApiKey, validateInput };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map