@teamvelix/velix-core 5.2.9 → 5.3.0

package/dist/index.js

@@ -1,14 +1,25 @@
 import fs from 'fs';
-import path2 from 'path';
+import path4 from 'path';
 import crypto from 'crypto';
 import { pathToFileURL } from 'url';
 import { z } from 'zod';
 import pc from 'picocolors';
+import { LRUCache } from 'lru-cache';
 import { glob } from 'glob';
 import { WebSocketServer } from 'ws';
 import chokidar from 'chokidar';
 
 // src/router/index.ts
+
+// src/router/types.ts
+var RouteType = {
+  PAGE: "page",
+  API: "api",
+  LAYOUT: "layout",
+  LOADING: "loading",
+  ERROR: "error",
+  NOT_FOUND: "not-found"
+};
 function generateHash(content) {
   return crypto.createHash("md5").update(content).digest("hex").slice(0, 8);
 }
@@ -26,7 +37,7 @@ 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);
+    const fullPath = path4.join(dir, entry.name);
     if (entry.isDirectory()) findFiles(fullPath, pattern, files);
     else if (pattern.test(entry.name)) files.push(fullPath);
   }
@@ -43,8 +54,8 @@ 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);
+    const srcPath = path4.join(src, entry.name);
+    const destPath = path4.join(dest, entry.name);
     if (entry.isDirectory()) copyDir(srcPath, destPath);
     else fs.copyFileSync(srcPath, destPath);
   }
@@ -107,40 +118,29 @@ function isIsland(filePath) {
   }
 }
 
-// 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);
+// src/router/parser.ts
+function createRoutePattern(routePath) {
+  let pattern = routePath.replace(/\*[^/]*/g, "(.*)").replace(/:[^/]+/g, "([^/]+)").replace(/\//g, "\\/");
+  return new RegExp(`^${pattern}$`);
+}
+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");
   }
-  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;
+  paramNames.forEach((name, index) => {
+    params[name] = match[index + 1];
+  });
+  return params;
 }
-function scanAppDirectory(baseDir, currentDir, routes, parentSegments = [], parentLayout = null, parentMiddleware = null) {
-  const entries = fs.readdirSync(currentDir, { withFileTypes: true });
+
+// src/router/scanner.ts
+async function scanAppDirectory(baseDir, currentDir, parentSegments = [], parentLayout = null, parentMiddleware = null) {
+  const routes = [];
+  const entries = await fs.promises.readdir(currentDir, { withFileTypes: true });
   const specialFiles = {
     page: null,
     layout: null,
@@ -153,8 +153,8 @@ function scanAppDirectory(baseDir, currentDir, routes, parentSegments = [], pare
   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);
+      const fullPath = path4.join(currentDir, entry.name);
+      const ext = path4.extname(entry.name);
       if (![".tsx", ".jsx", ".ts", ".js"].includes(ext)) continue;
       if (name === "page") specialFiles.page = fullPath;
       if (name === "layout") specialFiles.layout = fullPath;
@@ -172,7 +172,7 @@ function scanAppDirectory(baseDir, currentDir, routes, parentSegments = [], pare
           segmentName = ":" + paramName;
         }
         const routePath = "/" + [...parentSegments, segmentName].join("/");
-        routes.appRoutes.push({
+        routes.push({
           type: RouteType.PAGE,
           path: routePath.replace(/\/+/g, "/"),
           filePath: fullPath,
@@ -193,7 +193,7 @@ function scanAppDirectory(baseDir, currentDir, routes, parentSegments = [], pare
   }
   if (specialFiles.page) {
     const routePath = "/" + parentSegments.join("/") || "/";
-    routes.appRoutes.push({
+    routes.push({
       type: RouteType.PAGE,
       path: routePath.replace(/\/+/g, "/") || "/",
       filePath: specialFiles.page,
@@ -210,78 +210,58 @@ function scanAppDirectory(baseDir, currentDir, routes, parentSegments = [], pare
       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 ignoredDirs = ["node_modules", ".velix", "dist"];
+  const dirPromises = entries.filter(
+    (entry) => entry.isDirectory() && !entry.name.startsWith("_") && !entry.name.startsWith(".") && !ignoredDirs.includes(entry.name)
+  ).map(async (entry) => {
+    const fullPath = path4.join(currentDir, entry.name);
+    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);
+    const newSegments = isGroup ? parentSegments : [...parentSegments, segmentName];
+    const newLayout = specialFiles.layout || parentLayout;
+    const newMiddleware = specialFiles.middleware || parentMiddleware;
+    return scanAppDirectory(baseDir, fullPath, newSegments, newLayout, newMiddleware);
+  });
+  const subRoutes = await Promise.all(dirPromises);
+  return routes.concat(...subRoutes);
+}
+async function scanApiDirectory(baseDir, currentDir, parentSegments = []) {
+  const entries = await fs.promises.readdir(currentDir, { withFileTypes: true });
+  const routes = [];
+  const promises = entries.map(async (entry) => {
+    const fullPath = path4.join(currentDir, entry.name);
     if (entry.isDirectory()) {
-      scanApiDirectory(baseDir, fullPath, routes, [...parentSegments, entry.name]);
+      return scanApiDirectory(baseDir, fullPath, [...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 ext = path4.extname(entry.name);
+      if (![".ts", ".js"].includes(ext)) return [];
+      const baseName = path4.basename(entry.name, ext);
       const apiSegments = baseName === "route" || baseName === "index" ? parentSegments : [...parentSegments, baseName];
       const apiPath = "/api/" + apiSegments.join("/");
-      routes.api.push({
+      return [{
         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 [];
   });
-  return params;
+  const subRoutes = await Promise.all(promises);
+  return routes.concat(...subRoutes);
 }
+
+// src/router/tree-builder.ts
 function findRouteLayouts(route, layoutsMap) {
   const layouts = [];
   for (const segment of route.segments) {
@@ -311,6 +291,44 @@ function buildTree(routes) {
   }
   return tree;
 }
+
+// src/router/matcher.ts
+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;
+}
+
+// src/router/index.ts
+async function buildRouteTree(appDir) {
+  const projectRoot = path4.dirname(appDir);
+  const routes = {
+    pages: [],
+    api: [],
+    layouts: /* @__PURE__ */ new Map(),
+    tree: { children: {}, routes: [] },
+    appRoutes: []
+  };
+  if (fs.existsSync(appDir)) {
+    routes.appRoutes = await scanAppDirectory(appDir, appDir);
+  }
+  const serverApiDir = path4.join(projectRoot, "server", "api");
+  if (fs.existsSync(serverApiDir)) {
+    routes.api = await scanApiDirectory(serverApiDir, serverApiDir);
+  }
+  const rootLayoutTsx = path4.join(appDir, "layout.tsx");
+  const rootLayoutJsx = path4.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;
+}
 var AppConfigSchema = z.object({
   name: z.string().default("Velix App"),
   url: z.string().url().optional()
@@ -374,10 +392,10 @@ 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");
+  const configPathTs = path4.join(projectRoot, "velix.config.ts");
+  const configPathJs = path4.join(projectRoot, "velix.config.js");
+  const configPathLegacyTs = path4.join(projectRoot, "flexireact.config.ts");
+  const configPathLegacyJs = path4.join(projectRoot, "flexireact.config.js");
   let configPath = null;
   if (fs.existsSync(configPathTs)) configPath = configPathTs;
   else if (fs.existsSync(configPathJs)) configPath = configPathJs;
@@ -410,9 +428,9 @@ async function loadConfig(projectRoot) {
 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)
+    resolvedAppDir: path4.resolve(projectRoot, config.appDir),
+    resolvedPublicDir: path4.resolve(projectRoot, config.publicDir),
+    resolvedOutDir: path4.resolve(projectRoot, config.build.outDir)
   };
 }
 function deepMerge(target, source) {
@@ -428,7 +446,7 @@ function deepMerge(target, source) {
 }
 
 // src/version.ts
-var VERSION = "5.2.8";
+var VERSION = "5.3.0";
 
 // src/logger.ts
 var colors = {
@@ -476,14 +494,14 @@ var logger = {
     if (pagesDir) console.log(`  ${c.bold}App:${c.reset}        ${c.dim}${pagesDir}${c.reset}`);
     console.log("");
   },
-  request(method, path8, status, time, extra = {}) {
+  request(method, path9, 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} ${path8} ${statusStr} ${c.dim}${timeStr}${c.reset}`);
+    console.log(`  ${badge} ${c.white}${method}${c.reset} ${path9} ${statusStr} ${c.dim}${timeStr}${c.reset}`);
   },
   info(msg) {
     console.log(`  ${c.cyan}\u2139${c.reset} ${msg}`);
@@ -511,10 +529,10 @@ var logger = {
   plugin(name) {
     console.log(`  ${c.cyan}\u25C6${c.reset} Plugin ${c.dim}${name}${c.reset}`);
   },
-  route(path8, type) {
+  route(path9, 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} ${path8}`);
+    console.log(`  ${color}${typeLabel}${c.reset} ${path9}`);
   },
   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}`);
@@ -805,7 +823,7 @@ async function loadMiddleware(projectRoot) {
   const fns = [];
   const possibleFiles = ["proxy.ts", "proxy.js"];
   for (const file of possibleFiles) {
-    const filePath = path2.join(projectRoot, file);
+    const filePath = path4.join(projectRoot, file);
     if (!fs.existsSync(filePath)) continue;
     try {
       const { pathToFileURL: pathToFileURL4 } = await import('url');
@@ -980,9 +998,9 @@ async function loadPlugins(projectRoot, config) {
   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");
+        const localPath = path4.join(projectRoot, "plugins", entry + ".ts");
+        const localPathJs = path4.join(projectRoot, "plugins", entry + ".js");
+        const localPathDir = path4.join(projectRoot, "plugins", entry, "index.ts");
         let pluginPath = null;
         if (fs.existsSync(localPath)) pluginPath = localPath;
         else if (fs.existsSync(localPathJs)) pluginPath = localPathJs;
@@ -1523,189 +1541,113 @@ function createAIAction(config) {
     return response.text;
   };
 }
-
-// src/cache/index.ts
-var VelixCache = class {
-  maxSize;
-  defaultTtl;
-  defaultSwr;
-  store = /* @__PURE__ */ new Map();
+var MemoryCacheAdapter = class {
+  lru;
   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;
+  constructor(options = {}) {
+    this.lru = new LRUCache({ max: options.maxSize ?? 500 });
   }
-  /**
-   * Store a value with optional TTL, SWR, and tags.
-   */
-  set(key, value, options) {
-    if (this.store.has(key)) {
-      this.removeEntry(this.store.get(key));
+  async get(key) {
+    const entry = this.lru.get(key);
+    if (!entry) return null;
+    if (entry.expiresAt && Date.now() > entry.expiresAt) {
+      this.lru.delete(key);
+      return null;
     }
+    return entry.value;
+  }
+  async set(key, value, options = {}) {
     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
+      tags: options.tags ?? [],
+      expiresAt: options.ttl ? Date.now() + options.ttl : 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.lru.set(key, entry);
+    options.tags?.forEach((tag) => {
+      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 };
+  async delete(key) {
+    this.lru.delete(key);
   }
-  /**
-   * 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(path8) {
-    this.delete(path8);
-  }
-  /** Invalidate all entries associated with a tag */
-  revalidateTag(tag) {
+  async deleteByTag(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);
-      }
-    }
+    keys.forEach((key) => this.lru.delete(key));
     this.tagIndex.delete(tag);
   }
-  /** Clear all entries */
-  invalidateAll() {
-    this.store.clear();
-    this.tagIndex.clear();
-    this.head.next = this.tail;
-    this.tail.prev = this.head;
+  async deleteByPrefix(prefix) {
+    for (const key of this.lru.keys()) {
+      if (key.startsWith(prefix)) this.lru.delete(key);
+    }
   }
-  /** Get cache stats for debugging/monitoring */
-  stats() {
-    return {
-      size: this.store.size,
-      maxSize: this.maxSize,
-      tags: this.tagIndex.size
-    };
+  async clear() {
+    this.lru.clear();
+    this.tagIndex.clear();
   }
-  // ── Internal LRU operations ──
-  createSentinel(key) {
-    return {
-      key,
-      value: null,
-      tags: /* @__PURE__ */ new Set(),
-      createdAt: 0,
-      ttl: 0,
-      swr: 0,
-      prev: null,
-      next: null
-    };
+  async has(key) {
+    return this.lru.has(key);
   }
-  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);
+};
+
+// src/cache/deduplicator.ts
+var RequestDeduplicator = class {
+  inFlight = /* @__PURE__ */ new Map();
+  async dedupe(key, fn) {
+    if (this.inFlight.has(key)) {
+      return this.inFlight.get(key);
     }
+    const promise = fn().finally(() => {
+      this.inFlight.delete(key);
+    });
+    this.inFlight.set(key, promise);
+    return promise;
   }
-  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);
-        }
-      }
-    }
+};
+
+// src/cache/index.ts
+var VelixCache = class {
+  adapter;
+  deduplicator;
+  constructor(adapter = new MemoryCacheAdapter()) {
+    this.adapter = adapter;
+    this.deduplicator = new RequestDeduplicator();
+  }
+  async revalidatePath(path9) {
+    await this.adapter.deleteByPrefix(`route:${path9}`);
+  }
+  async revalidateTag(tag) {
+    await this.adapter.deleteByTag(tag);
+  }
+  // unstable_cache — avec déduplication
+  unstable_cache(fn, keys, options) {
+    const key = keys.join(":");
+    return async () => {
+      const cached = await this.adapter.get(key);
+      if (cached !== null) return cached;
+      const value = await this.deduplicator.dedupe(key, fn);
+      await this.adapter.set(key, value, {
+        ttl: options?.revalidate ? options.revalidate * 1e3 : void 0,
+        tags: options?.tags
+      });
+      return value;
+    };
   }
 };
 var cacheManager = new VelixCache();
-function revalidatePath(path8, _type = "path") {
-  cacheManager.revalidatePath(path8);
+async function revalidatePath(path9, _type = "path") {
+  await cacheManager.revalidatePath(path9);
   if (typeof global !== "undefined" && global.__VELIX_HMR_SERVER__) {
     global.__VELIX_HMR_SERVER__.broadcast(JSON.stringify({
       type: "revalidate",
-      path: path8,
+      path: path9,
       revalidationType: _type
     }));
   }
 }
-function revalidateTag(tag) {
-  cacheManager.revalidateTag(tag);
+async function revalidateTag(tag) {
+  await cacheManager.revalidateTag(tag);
   if (typeof global !== "undefined" && global.__VELIX_HMR_SERVER__) {
     global.__VELIX_HMR_SERVER__.broadcast(JSON.stringify({
       type: "revalidate",
@@ -1714,19 +1656,7 @@ function revalidateTag(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;
-  };
+  return cacheManager.unstable_cache(fn, keys, options);
 }
 var VelixHttpError = class extends Error {
   status;
@@ -1783,7 +1713,7 @@ async function buildApiManifest(serverDir) {
   return files.map((file) => filePathToRoute(file, serverDir));
 }
 function filePathToRoute(filePath, serverDir) {
-  const relative = path2.relative(path2.join(serverDir, "api"), filePath);
+  const relative = path4.relative(path4.join(serverDir, "api"), filePath);
   const normalizedRelative = relative.replace(/\\/g, "/");
   const withoutExt = normalizedRelative.replace(/\.ts$/, "");
   const params = [];
@@ -1873,7 +1803,7 @@ function serverAction(options) {
     }
   };
 }
-function createHMRServer(httpServer, projectRoot) {
+function createHMRServer(httpServer, projectRoot, options) {
   const wss = new WebSocketServer({ server: httpServer, path: "/__velix_hmr" });
   const clients = /* @__PURE__ */ new Set();
   wss.on("connection", (ws) => {
@@ -1886,19 +1816,26 @@ function createHMRServer(httpServer, projectRoot) {
     persistent: true,
     ignoreInitial: true
   });
-  function broadcast(event) {
+  function broadcastLocal(event) {
     const msg = JSON.stringify(event);
     clients.forEach((ws) => {
       if (ws.readyState === ws.OPEN) ws.send(msg);
     });
   }
+  function broadcast(event) {
+    broadcastLocal(event);
+    options?.pubsub?.publish(event);
+  }
+  options?.pubsub?.onEvent((event) => {
+    broadcastLocal(event);
+  });
   watcher.on("change", (file) => {
     broadcast({ type: "file-changed", file, timestamp: Date.now() });
   });
   watcher.on("add", (file) => {
     broadcast({ type: "file-added", file, timestamp: Date.now() });
   });
-  return { broadcast, watcher, wss, clients };
+  return { broadcast, broadcastLocal, watcher, wss, clients };
 }
 function getErrorBoundaryType(error) {
   if (error instanceof NotFoundError) return "not-found";
@@ -1906,18 +1843,18 @@ function getErrorBoundaryType(error) {
   return "error";
 }
 function resolveErrorBoundary(routeFilePath, appDir, type) {
-  let currentDir = path2.dirname(routeFilePath);
+  let currentDir = path4.dirname(routeFilePath);
   while (currentDir.length >= appDir.length && currentDir.startsWith(appDir)) {
-    const boundaryPath = path2.join(currentDir, `${type}.tsx`);
+    const boundaryPath = path4.join(currentDir, `${type}.tsx`);
     if (fs.existsSync(boundaryPath)) {
-      const scope = currentDir === appDir ? "root" : path2.basename(currentDir);
+      const scope = currentDir === appDir ? "root" : path4.basename(currentDir);
       return {
         filePath: boundaryPath,
         type,
         scope
       };
     }
-    const parentDir = path2.dirname(currentDir);
+    const parentDir = path4.dirname(currentDir);
     if (parentDir === currentDir) break;
     currentDir = parentDir;
   }
@@ -1932,6 +1869,6 @@ function defineNotFound(component) {
   return component;
 }
 
-export { ForbiddenError, NotFoundError, OllamaProvider, OpenAIProvider, PluginHooks, PluginManager, RouteType, UnauthorizedError, VelixCache, VelixConfigSchema, VelixHttpError, buildApiManifest, buildPrompt, buildRouteTree, builtinPlugins, cacheManager, cleanDir, composeMiddleware, copyDir, createAIAction, createAIClient, createDeferred, createHMRServer, createStreamDecoder, debounce, defaultConfig, defineConfig, defineError, defineLoader, defineNotFound, definePlugin, defineRoute, ensureDir, escapeHtml, estimateTokens, filePathToRoute, findFiles, findRouteLayouts, formatBytes, formatTime, generateHash, generateJsonLd, generateMetadataTags, generateRobotsTxt, generateSitemap, getErrorBoundaryType, handleApiRequest, isClientComponent, isIsland, isServerComponent, jsonLd, loadConfig, loadMiddleware, loadPlugins, logger, matchRoute, mergeMetadata, middlewares, parseSSE, pluginManager, resolveErrorBoundary, resolvePaths, retry, revalidatePath, revalidateTag, runMiddleware, safeJsonParse, sanitizeInput, serverAction, sleep, truncateToTokens, unstable_cache, useAI, validateApiKey, validateInput };
+export { ForbiddenError, NotFoundError, OllamaProvider, OpenAIProvider, PluginHooks, PluginManager, RouteType, UnauthorizedError, VelixCache, VelixConfigSchema, VelixHttpError, buildApiManifest, buildPrompt, buildRouteTree, builtinPlugins, cacheManager, cleanDir, composeMiddleware, copyDir, createAIAction, createAIClient, createDeferred, createHMRServer, createRoutePattern, createStreamDecoder, debounce, defaultConfig, defineConfig, defineError, defineLoader, defineNotFound, definePlugin, defineRoute, ensureDir, escapeHtml, estimateTokens, filePathToRoute, findFiles, findRouteLayouts, formatBytes, formatTime, generateHash, generateJsonLd, generateMetadataTags, generateRobotsTxt, generateSitemap, getErrorBoundaryType, handleApiRequest, isClientComponent, isIsland, isServerComponent, jsonLd, loadConfig, loadMiddleware, loadPlugins, logger, matchRoute, mergeMetadata, middlewares, parseSSE, pluginManager, resolveErrorBoundary, resolvePaths, retry, revalidatePath, revalidateTag, runMiddleware, safeJsonParse, sanitizeInput, serverAction, sleep, truncateToTokens, unstable_cache, useAI, validateApiKey, validateInput };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map