@sonicjs-cms/core 2.5.0 → 2.7.0

package/dist/index.js

@@ -1,18 +1,19 @@
-import { api_default, api_media_default, api_system_default, admin_api_default, router, adminCollectionsRoutes, adminSettingsRoutes, admin_content_default, adminMediaRoutes, adminPluginRoutes, adminLogsRoutes, userRoutes, auth_default, test_cleanup_default, checkAdminUserExists } from './chunk-OJZ45OJD.js';
-export { ROUTES_INFO, admin_api_default as adminApiRoutes, adminCheckboxRoutes, admin_code_examples_default as adminCodeExamplesRoutes, adminCollectionsRoutes, admin_content_default as adminContentRoutes, router as adminDashboardRoutes, adminDesignRoutes, adminLogsRoutes, adminMediaRoutes, adminPluginRoutes, adminSettingsRoutes, admin_testimonials_default as adminTestimonialsRoutes, userRoutes as adminUsersRoutes, api_content_crud_default as apiContentCrudRoutes, api_media_default as apiMediaRoutes, api_default as apiRoutes, api_system_default as apiSystemRoutes, auth_default as authRoutes } from './chunk-OJZ45OJD.js';
+import { renderConfirmationDialog, getConfirmationDialogScript, api_default, api_media_default, api_system_default, admin_api_default, router, adminCollectionsRoutes, adminSettingsRoutes, admin_content_default, adminMediaRoutes, adminPluginRoutes, adminLogsRoutes, userRoutes, auth_default, test_cleanup_default } from './chunk-UISZ2MBW.js';
+export { ROUTES_INFO, admin_api_default as adminApiRoutes, adminCheckboxRoutes, admin_code_examples_default as adminCodeExamplesRoutes, adminCollectionsRoutes, admin_content_default as adminContentRoutes, router as adminDashboardRoutes, adminDesignRoutes, adminLogsRoutes, adminMediaRoutes, adminPluginRoutes, adminSettingsRoutes, admin_testimonials_default as adminTestimonialsRoutes, userRoutes as adminUsersRoutes, api_content_crud_default as apiContentCrudRoutes, api_media_default as apiMediaRoutes, api_default as apiRoutes, api_system_default as apiSystemRoutes, auth_default as authRoutes } from './chunk-UISZ2MBW.js';
 import { schema_exports } from './chunk-3YNNVSMC.js';
 export { Logger, apiTokens, collections, content, contentVersions, getLogger, initLogger, insertCollectionSchema, insertContentSchema, insertLogConfigSchema, insertMediaSchema, insertPluginActivityLogSchema, insertPluginAssetSchema, insertPluginHookSchema, insertPluginRouteSchema, insertPluginSchema, insertSystemLogSchema, insertUserSchema, insertWorkflowHistorySchema, logConfig, media, pluginActivityLog, pluginAssets, pluginHooks, pluginRoutes, plugins, selectCollectionSchema, selectContentSchema, selectLogConfigSchema, selectMediaSchema, selectPluginActivityLogSchema, selectPluginAssetSchema, selectPluginHookSchema, selectPluginRouteSchema, selectPluginSchema, selectSystemLogSchema, selectUserSchema, selectWorkflowHistorySchema, systemLogs, users, workflowHistory } from './chunk-3YNNVSMC.js';
-import { AuthManager, metricsMiddleware, bootstrapMiddleware, requireAuth } from './chunk-TJTWRO4G.js';
-export { AuthManager, PermissionManager, bootstrapMiddleware, cacheHeaders, compressionMiddleware, detailedLoggingMiddleware, getActivePlugins, isPluginActive, logActivity, loggingMiddleware, optionalAuth, performanceLoggingMiddleware, requireActivePlugin, requireActivePlugins, requireAnyPermission, requireAuth, requirePermission, requireRole, securityHeaders, securityLoggingMiddleware } from './chunk-TJTWRO4G.js';
-export { PluginBootstrapService, PluginService as PluginServiceClass, cleanupRemovedCollections, fullCollectionSync, getAvailableCollectionNames, getManagedCollections, isCollectionManaged, loadCollectionConfig, loadCollectionConfigs, registerCollections, syncCollection, syncCollections, validateCollectionConfig } from './chunk-SGAG6FD3.js';
-export { MigrationService } from './chunk-VEL7QRYI.js';
-export { renderFilterBar } from './chunk-AVPUX57O.js';
-import { init_admin_layout_catalyst_template, renderAdminLayout, adminLayoutV2, renderAdminLayoutCatalyst } from './chunk-V5LBQN3I.js';
-export { getConfirmationDialogScript, renderAlert, renderConfirmationDialog, renderForm, renderFormField, renderPagination, renderTable } from './chunk-V5LBQN3I.js';
-export { HookSystemImpl, HookUtils, PluginManager as PluginManagerClass, PluginRegistryImpl, PluginValidator as PluginValidatorClass, ScopedHookSystem as ScopedHookSystemClass } from './chunk-3YUHXWSG.js';
-import { PluginBuilder } from './chunk-QDBNW7KQ.js';
-import { package_default, getCoreVersion } from './chunk-BHNDALCA.js';
-export { QueryFilterBuilder, SONICJS_VERSION, TemplateRenderer, buildQuery, escapeHtml, getCoreVersion, renderTemplate, sanitizeInput, sanitizeObject, templateRenderer } from './chunk-BHNDALCA.js';
+import { requireAuth, AuthManager, metricsMiddleware, bootstrapMiddleware } from './chunk-Y3EWJQ4D.js';
+export { AuthManager, PermissionManager, bootstrapMiddleware, cacheHeaders, compressionMiddleware, detailedLoggingMiddleware, getActivePlugins, isPluginActive, logActivity, loggingMiddleware, optionalAuth, performanceLoggingMiddleware, requireActivePlugin, requireActivePlugins, requireAnyPermission, requireAuth, requirePermission, requireRole, securityHeaders, securityLoggingMiddleware } from './chunk-Y3EWJQ4D.js';
+export { PluginBootstrapService, PluginService as PluginServiceClass, cleanupRemovedCollections, fullCollectionSync, getAvailableCollectionNames, getManagedCollections, isCollectionManaged, loadCollectionConfig, loadCollectionConfigs, registerCollections, syncCollection, syncCollections, validateCollectionConfig } from './chunk-YFJJU26H.js';
+export { MigrationService } from './chunk-L2IDZI7F.js';
+export { renderFilterBar } from './chunk-V3KVSEG6.js';
+import { init_admin_layout_catalyst_template, renderAdminLayout, adminLayoutV2, renderAdminLayoutCatalyst } from './chunk-GRN3GHUG.js';
+export { getConfirmationDialogScript, renderAlert, renderConfirmationDialog, renderForm, renderFormField, renderPagination, renderTable } from './chunk-GRN3GHUG.js';
+export { HookSystemImpl, HookUtils, PluginManager as PluginManagerClass, PluginRegistryImpl, PluginValidator as PluginValidatorClass, ScopedHookSystem as ScopedHookSystemClass } from './chunk-F332TENF.js';
+import { PluginBuilder } from './chunk-CLIH2T74.js';
+export { PluginBuilder, PluginHelpers } from './chunk-CLIH2T74.js';
+import { package_default, getCoreVersion } from './chunk-DNHJS6RN.js';
+export { QueryFilterBuilder, SONICJS_VERSION, TemplateRenderer, buildQuery, escapeHtml, getCoreVersion, renderTemplate, sanitizeInput, sanitizeObject, templateRenderer } from './chunk-DNHJS6RN.js';
 import './chunk-X7ZAEI5S.js';
 export { metricsTracker } from './chunk-FICTAGD4.js';
 export { HOOKS } from './chunk-LOUJRBXV.js';
@@ -23,33 +24,6 @@ import { setCookie } from 'hono/cookie';
 import { z } from 'zod';
 import { drizzle } from 'drizzle-orm/d1';
 
-// src/middleware/admin-setup.ts
-function adminSetupMiddleware() {
-  return async (c, next) => {
-    const path = new URL(c.req.url).pathname;
-    if (path.startsWith("/auth/")) {
-      return next();
-    }
-    if (path.match(/\.(js|css|ico|png|jpg|jpeg|gif|svg|woff|woff2|ttf|eot)$/)) {
-      return next();
-    }
-    if (path === "/health") {
-      return next();
-    }
-    if (path.startsWith("/api/")) {
-      return next();
-    }
-    const db = c.env.DB;
-    const adminExists = await checkAdminUserExists(db);
-    if (!adminExists) {
-      if (path.startsWith("/admin")) {
-        return c.redirect("/auth/register?setup=true");
-      }
-    }
-    return next();
-  };
-}
-
 // src/plugins/core-plugins/database-tools-plugin/services/database-service.ts
 var DatabaseToolsService = class {
   constructor(db) {
@@ -1354,10 +1328,10 @@ function createEmailPlugin() {
   emailRoutes.get("/settings", async (c) => {
     const user = c.get("user");
     const db = c.env.DB;
-    const plugin = await db.prepare(`
+    const plugin2 = await db.prepare(`
       SELECT settings FROM plugins WHERE id = 'email'
     `).first();
-    const settings = plugin?.settings ? JSON.parse(plugin.settings) : {};
+    const settings = plugin2?.settings ? JSON.parse(plugin2.settings) : {};
     const contentHTML = await html`
       <div class="p-8">
         <!-- Header -->
@@ -1618,16 +1592,16 @@ function createEmailPlugin() {
     try {
       const db = c.env.DB;
       const body = await c.req.json();
-      const plugin = await db.prepare(`
+      const plugin2 = await db.prepare(`
         SELECT settings FROM plugins WHERE id = 'email'
       `).first();
-      if (!plugin?.settings) {
+      if (!plugin2?.settings) {
         return c.json({
           success: false,
           error: "Email settings not configured. Please save your settings first."
         }, 400);
       }
-      const settings = JSON.parse(plugin.settings);
+      const settings = JSON.parse(plugin2.settings);
       if (!settings.apiKey || !settings.fromEmail || !settings.fromName) {
         return c.json({
           success: false,
@@ -2233,8 +2207,8 @@ function createOTPLoginPlugin() {
     requiresAuth: false,
     priority: 100
   });
-  const adminRoutes = new Hono();
-  adminRoutes.get("/settings", async (c) => {
+  const adminRoutes2 = new Hono();
+  adminRoutes2.get("/settings", async (c) => {
     const user = c.get("user");
     const contentHTML = await html`
       <div class="p-8">
@@ -2414,7 +2388,7 @@ function createOTPLoginPlugin() {
       })
     );
   });
-  builder.addRoute("/admin/plugins/otp-login", adminRoutes, {
+  builder.addRoute("/admin/plugins/otp-login", adminRoutes2, {
     description: "OTP login admin interface",
     requiresAuth: true,
     priority: 85
@@ -2435,363 +2409,4056 @@ function createOTPLoginPlugin() {
   return builder.build();
 }
 var otpLoginPlugin = createOTPLoginPlugin();
-var magicLinkRequestSchema = z.object({
-  email: z.string().email("Valid email is required")
-});
-function createMagicLinkAuthPlugin() {
-  const magicLinkRoutes = new Hono();
-  magicLinkRoutes.post("/request", async (c) => {
+
+// src/plugins/core-plugins/ai-search-plugin/services/embedding.service.ts
+var EmbeddingService = class {
+  constructor(ai) {
+    this.ai = ai;
+  }
+  /**
+   * Generate embedding for a single text
+   */
+  async generateEmbedding(text) {
     try {
-      const body = await c.req.json();
-      const validation = magicLinkRequestSchema.safeParse(body);
-      if (!validation.success) {
-        return c.json({
-          error: "Validation failed",
-          details: validation.error.issues
-        }, 400);
+      const response = await this.ai.run("@cf/baai/bge-base-en-v1.5", {
+        text: this.preprocessText(text)
+      });
+      if (response.data && response.data.length > 0) {
+        return response.data[0];
       }
-      const { email } = validation.data;
-      const normalizedEmail = email.toLowerCase();
-      const db = c.env.DB;
-      const oneHourAgo = Date.now() - 60 * 60 * 1e3;
-      const recentLinks = await db.prepare(`
-        SELECT COUNT(*) as count
-        FROM magic_links
-        WHERE user_email = ? AND created_at > ?
-      `).bind(normalizedEmail, oneHourAgo).first();
-      const rateLimitPerHour = 5;
-      if (recentLinks && recentLinks.count >= rateLimitPerHour) {
-        return c.json({
-          error: "Too many requests. Please try again later."
-        }, 429);
+      throw new Error("No embedding data returned");
+    } catch (error) {
+      console.error("[EmbeddingService] Error generating embedding:", error);
+      throw error;
+    }
+  }
+  /**
+   * Generate embeddings for multiple texts (batch processing)
+   */
+  async generateBatch(texts) {
+    try {
+      const batchSize = 10;
+      const batches = [];
+      for (let i = 0; i < texts.length; i += batchSize) {
+        batches.push(texts.slice(i, i + batchSize));
       }
-      const user = await db.prepare(`
-        SELECT id, email, role, is_active
-        FROM users
-        WHERE email = ?
-      `).bind(normalizedEmail).first();
-      const allowNewUsers = false;
-      if (!user && !allowNewUsers) {
-        return c.json({
-          message: "If an account exists for this email, you will receive a magic link shortly."
+      const allEmbeddings = [];
+      for (const batch of batches) {
+        const batchEmbeddings = await Promise.all(
+          batch.map((text) => this.generateEmbedding(text))
+        );
+        allEmbeddings.push(...batchEmbeddings);
+      }
+      return allEmbeddings;
+    } catch (error) {
+      console.error("[EmbeddingService] Error generating batch embeddings:", error);
+      throw error;
+    }
+  }
+  /**
+   * Preprocess text before generating embedding
+   * - Trim whitespace
+   * - Limit length to avoid token limits
+   * - Remove special characters that might cause issues
+   */
+  preprocessText(text) {
+    if (!text) return "";
+    let processed = text.trim().replace(/\s+/g, " ");
+    if (processed.length > 8e3) {
+      processed = processed.substring(0, 8e3);
+    }
+    return processed;
+  }
+  /**
+   * Calculate cosine similarity between two embeddings
+   */
+  cosineSimilarity(a, b) {
+    if (a.length !== b.length) {
+      throw new Error("Embeddings must have same dimensions");
+    }
+    let dotProduct = 0;
+    let normA = 0;
+    let normB = 0;
+    for (let i = 0; i < a.length; i++) {
+      const aVal = a[i] ?? 0;
+      const bVal = b[i] ?? 0;
+      dotProduct += aVal * bVal;
+      normA += aVal * aVal;
+      normB += bVal * bVal;
+    }
+    return dotProduct / (Math.sqrt(normA) * Math.sqrt(normB));
+  }
+};
+
+// src/plugins/core-plugins/ai-search-plugin/services/chunking.service.ts
+var ChunkingService = class {
+  // Default chunk size (in approximate tokens)
+  CHUNK_SIZE = 500;
+  CHUNK_OVERLAP = 50;
+  /**
+   * Chunk a single content item
+   */
+  chunkContent(contentId, collectionId, title, data, metadata = {}) {
+    const text = this.extractText(data);
+    if (!text || text.trim().length === 0) {
+      console.warn(`[ChunkingService] No text found for content ${contentId}`);
+      return [];
+    }
+    const textChunks = this.splitIntoChunks(text);
+    return textChunks.map((chunkText, index) => ({
+      id: `${contentId}_chunk_${index}`,
+      content_id: contentId,
+      collection_id: collectionId,
+      title,
+      text: chunkText,
+      chunk_index: index,
+      metadata: {
+        ...metadata,
+        total_chunks: textChunks.length
+      }
+    }));
+  }
+  /**
+   * Chunk multiple content items
+   */
+  chunkContentBatch(items) {
+    const allChunks = [];
+    for (const item of items) {
+      const chunks = this.chunkContent(
+        item.id,
+        item.collection_id,
+        item.title,
+        item.data,
+        item.metadata
+      );
+      allChunks.push(...chunks);
+    }
+    return allChunks;
+  }
+  /**
+   * Extract all text from content data
+   */
+  extractText(data) {
+    const parts = [];
+    if (data.title) parts.push(String(data.title));
+    if (data.name) parts.push(String(data.name));
+    if (data.description) parts.push(String(data.description));
+    if (data.content) parts.push(String(data.content));
+    if (data.body) parts.push(String(data.body));
+    if (data.text) parts.push(String(data.text));
+    if (data.summary) parts.push(String(data.summary));
+    const extractRecursive = (obj) => {
+      if (typeof obj === "string") {
+        if (obj.length > 10 && !obj.startsWith("http")) {
+          parts.push(obj);
+        }
+      } else if (Array.isArray(obj)) {
+        obj.forEach(extractRecursive);
+      } else if (obj && typeof obj === "object") {
+        const skipKeys = ["id", "slug", "url", "image", "thumbnail", "metadata"];
+        Object.entries(obj).forEach(([key, value]) => {
+          if (!skipKeys.includes(key.toLowerCase())) {
+            extractRecursive(value);
+          }
         });
       }
-      if (user && !user.is_active) {
-        return c.json({
-          error: "This account has been deactivated."
-        }, 403);
+    };
+    extractRecursive(data);
+    return parts.join("\n\n").trim();
+  }
+  /**
+   * Split text into overlapping chunks
+   */
+  splitIntoChunks(text) {
+    const words = text.split(/\s+/);
+    if (words.length <= this.CHUNK_SIZE) {
+      return [text];
+    }
+    const chunks = [];
+    let startIndex = 0;
+    while (startIndex < words.length) {
+      const endIndex = Math.min(startIndex + this.CHUNK_SIZE, words.length);
+      const chunk = words.slice(startIndex, endIndex).join(" ");
+      chunks.push(chunk);
+      startIndex += this.CHUNK_SIZE - this.CHUNK_OVERLAP;
+      if (startIndex >= words.length - this.CHUNK_OVERLAP) {
+        break;
       }
-      const token = crypto.randomUUID() + "-" + crypto.randomUUID();
-      const tokenId = crypto.randomUUID();
-      const linkExpiryMinutes = 15;
-      const expiresAt = Date.now() + linkExpiryMinutes * 60 * 1e3;
-      await db.prepare(`
-        INSERT INTO magic_links (
-          id, user_email, token, expires_at, used, created_at, ip_address, user_agent
-        ) VALUES (?, ?, ?, ?, 0, ?, ?, ?)
-      `).bind(
-        tokenId,
-        normalizedEmail,
-        token,
-        expiresAt,
-        Date.now(),
-        c.req.header("cf-connecting-ip") || c.req.header("x-forwarded-for") || "unknown",
-        c.req.header("user-agent") || "unknown"
-      ).run();
-      const baseUrl = new URL(c.req.url).origin;
-      const magicLink = `${baseUrl}/auth/magic-link/verify?token=${token}`;
-      try {
-        const emailPlugin2 = c.env.plugins?.get("email");
-        if (emailPlugin2 && emailPlugin2.sendEmail) {
-          await emailPlugin2.sendEmail({
-            to: normalizedEmail,
-            subject: "Your Magic Link to Sign In",
-            html: renderMagicLinkEmail(magicLink, linkExpiryMinutes)
-          });
-        } else {
-          console.error("Email plugin not available");
-          console.log(`Magic link for ${normalizedEmail}: ${magicLink}`);
+    }
+    return chunks;
+  }
+  /**
+   * Get optimal chunk size based on content type
+   */
+  getOptimalChunkSize(contentType) {
+    switch (contentType) {
+      case "blog_posts":
+      case "articles":
+        return 600;
+      // Larger chunks for long-form content
+      case "products":
+      case "pages":
+        return 400;
+      // Medium chunks for structured content
+      case "messages":
+      case "comments":
+        return 200;
+      // Small chunks for short content
+      default:
+        return this.CHUNK_SIZE;
+    }
+  }
+};
+
+// src/plugins/core-plugins/ai-search-plugin/services/custom-rag.service.ts
+var CustomRAGService = class {
+  constructor(db, ai, vectorize) {
+    this.db = db;
+    this.ai = ai;
+    this.vectorize = vectorize;
+    this.embeddingService = new EmbeddingService(ai);
+    this.chunkingService = new ChunkingService();
+  }
+  embeddingService;
+  chunkingService;
+  /**
+   * Index all content from a collection
+   */
+  async indexCollection(collectionId) {
+    console.log(`[CustomRAG] Starting indexing for collection: ${collectionId}`);
+    try {
+      const { results: contentItems } = await this.db.prepare(`
+          SELECT c.id, c.title, c.data, c.collection_id, c.status,
+                 c.created_at, c.updated_at, c.author_id,
+                 col.name as collection_name, col.display_name as collection_display_name
+          FROM content c
+          JOIN collections col ON c.collection_id = col.id
+          WHERE c.collection_id = ? AND c.status = 'published'
+        `).bind(collectionId).all();
+      const totalItems = contentItems?.length || 0;
+      if (totalItems === 0) {
+        console.log(`[CustomRAG] No content found in collection ${collectionId}`);
+        return { total_items: 0, total_chunks: 0, indexed_chunks: 0, errors: 0 };
+      }
+      const items = (contentItems || []).map((item) => ({
+        id: item.id,
+        collection_id: item.collection_id,
+        title: item.title || "Untitled",
+        data: typeof item.data === "string" ? JSON.parse(item.data) : item.data,
+        metadata: {
+          status: item.status,
+          created_at: item.created_at,
+          updated_at: item.updated_at,
+          author_id: item.author_id,
+          collection_name: item.collection_name,
+          collection_display_name: item.collection_display_name
+        }
+      }));
+      const chunks = this.chunkingService.chunkContentBatch(items);
+      const totalChunks = chunks.length;
+      console.log(`[CustomRAG] Generated ${totalChunks} chunks from ${totalItems} items`);
+      const embeddings = await this.embeddingService.generateBatch(
+        chunks.map((c) => `${c.title}
+
+${c.text}`)
+      );
+      console.log(`[CustomRAG] Generated ${embeddings.length} embeddings`);
+      let indexedChunks = 0;
+      let errors = 0;
+      const batchSize = 100;
+      for (let i = 0; i < chunks.length; i += batchSize) {
+        const chunkBatch = chunks.slice(i, i + batchSize);
+        const embeddingBatch = embeddings.slice(i, i + batchSize);
+        try {
+          await this.vectorize.upsert(
+            chunkBatch.map((chunk, idx) => ({
+              id: chunk.id,
+              values: embeddingBatch[idx],
+              metadata: {
+                content_id: chunk.content_id,
+                collection_id: chunk.collection_id,
+                title: chunk.title,
+                text: chunk.text.substring(0, 500),
+                // Store snippet for display
+                chunk_index: chunk.chunk_index,
+                ...chunk.metadata
+              }
+            }))
+          );
+          indexedChunks += chunkBatch.length;
+          console.log(`[CustomRAG] Indexed batch ${i / batchSize + 1}: ${chunkBatch.length} chunks`);
+        } catch (error) {
+          console.error(`[CustomRAG] Error indexing batch ${i / batchSize + 1}:`, error);
+          errors += chunkBatch.length;
         }
-      } catch (error) {
-        console.error("Failed to send magic link email:", error);
-        return c.json({
-          error: "Failed to send email. Please try again later."
-        }, 500);
       }
-      return c.json({
-        message: "If an account exists for this email, you will receive a magic link shortly.",
-        // For development only - remove in production
-        ...c.env.ENVIRONMENT === "development" && { dev_link: magicLink }
-      });
+      console.log(`[CustomRAG] Indexing complete: ${indexedChunks}/${totalChunks} chunks indexed`);
+      return {
+        total_items: totalItems,
+        total_chunks: totalChunks,
+        indexed_chunks: indexedChunks,
+        errors
+      };
     } catch (error) {
-      console.error("Magic link request error:", error);
-      return c.json({ error: "Failed to process request" }, 500);
+      console.error(`[CustomRAG] Error indexing collection ${collectionId}:`, error);
+      throw error;
     }
-  });
-  magicLinkRoutes.get("/verify", async (c) => {
+  }
+  /**
+   * Search using RAG (semantic search with Vectorize)
+   */
+  async search(query, settings) {
+    const startTime = Date.now();
     try {
-      const token = c.req.query("token");
-      if (!token) {
-        return c.redirect("/auth/login?error=Invalid magic link");
+      console.log(`[CustomRAG] Searching for: "${query.query}"`);
+      const queryEmbedding = await this.embeddingService.generateEmbedding(query.query);
+      const filter = {};
+      if (query.filters?.collections && query.filters.collections.length > 0) {
+        filter.collection_id = { $in: query.filters.collections };
+      } else if (settings.selected_collections.length > 0) {
+        filter.collection_id = { $in: settings.selected_collections };
       }
-      const db = c.env.DB;
-      const magicLink = await db.prepare(`
-        SELECT * FROM magic_links
-        WHERE token = ? AND used = 0
-      `).bind(token).first();
-      if (!magicLink) {
-        return c.redirect("/auth/login?error=Invalid or expired magic link");
+      if (query.filters?.status && query.filters.status.length > 0) {
+        filter.status = { $in: query.filters.status };
       }
-      if (magicLink.expires_at < Date.now()) {
-        return c.redirect("/auth/login?error=This magic link has expired");
+      const vectorResults = await this.vectorize.query(queryEmbedding, {
+        topK: 50,
+        // Max allowed with returnMetadata: true
+        returnMetadata: true
+      });
+      let filteredMatches = vectorResults.matches || [];
+      if (filter.collection_id?.$in && Array.isArray(filter.collection_id.$in)) {
+        const allowedCollections = filter.collection_id.$in;
+        filteredMatches = filteredMatches.filter(
+          (match) => allowedCollections.includes(match.metadata?.collection_id)
+        );
       }
-      let user = await db.prepare(`
-        SELECT * FROM users WHERE email = ? AND is_active = 1
-      `).bind(magicLink.user_email).first();
-      const allowNewUsers = false;
-      if (!user && allowNewUsers) {
-        const userId = crypto.randomUUID();
-        const username = magicLink.user_email.split("@")[0];
-        const now = Date.now();
-        await db.prepare(`
-          INSERT INTO users (
-            id, email, username, first_name, last_name,
-            password_hash, role, is_active, created_at, updated_at
-          ) VALUES (?, ?, ?, ?, ?, NULL, 'viewer', 1, ?, ?)
-        `).bind(
-          userId,
-          magicLink.user_email,
-          username,
-          username,
-          "",
-          now,
-          now
-        ).run();
-        user = {
-          id: userId,
-          email: magicLink.user_email,
-          username,
-          role: "viewer"
+      if (filter.status?.$in && Array.isArray(filter.status.$in)) {
+        const allowedStatuses = filter.status.$in;
+        filteredMatches = filteredMatches.filter(
+          (match) => allowedStatuses.includes(match.metadata?.status)
+        );
+      }
+      const topK = query.limit || settings.results_limit || 20;
+      filteredMatches = filteredMatches.slice(0, topK);
+      vectorResults.matches = filteredMatches;
+      if (!vectorResults.matches || vectorResults.matches.length === 0) {
+        return {
+          results: [],
+          total: 0,
+          query_time_ms: Date.now() - startTime,
+          mode: "ai"
         };
-      } else if (!user) {
-        return c.redirect("/auth/login?error=No account found for this email");
       }
-      await db.prepare(`
-        UPDATE magic_links
-        SET used = 1, used_at = ?
-        WHERE id = ?
-      `).bind(Date.now(), magicLink.id).run();
-      const jwtToken = await AuthManager.generateToken(
-        user.id,
-        user.email,
-        user.role
+      const contentIds = [...new Set(
+        vectorResults.matches.map((m) => m.metadata.content_id)
+      )];
+      const placeholders = contentIds.map(() => "?").join(",");
+      const { results: contentItems } = await this.db.prepare(`
+          SELECT c.id, c.title, c.slug, c.collection_id, c.status,
+                 c.created_at, c.updated_at, c.author_id,
+                 col.display_name as collection_name
+          FROM content c
+          JOIN collections col ON c.collection_id = col.id
+          WHERE c.id IN (${placeholders})
+        `).bind(...contentIds).all();
+      const searchResults = (contentItems || []).map((item) => {
+        const matchingChunks = vectorResults.matches.filter(
+          (m) => m.metadata.content_id === item.id
+        );
+        const bestMatch = matchingChunks.reduce(
+          (best, current) => current.score > (best?.score || 0) ? current : best,
+          null
+        );
+        return {
+          id: item.id,
+          title: item.title || "Untitled",
+          slug: item.slug || "",
+          collection_id: item.collection_id,
+          collection_name: item.collection_name,
+          snippet: bestMatch?.metadata?.text || "",
+          relevance_score: bestMatch?.score || 0,
+          status: item.status,
+          created_at: item.created_at,
+          updated_at: item.updated_at
+        };
+      });
+      searchResults.sort((a, b) => (b.relevance_score || 0) - (a.relevance_score || 0));
+      const queryTime = Date.now() - startTime;
+      console.log(`[CustomRAG] Search completed in ${queryTime}ms, ${searchResults.length} results`);
+      return {
+        results: searchResults,
+        total: searchResults.length,
+        query_time_ms: queryTime,
+        mode: "ai"
+      };
+    } catch (error) {
+      console.error("[CustomRAG] Search error:", error);
+      throw error;
+    }
+  }
+  /**
+   * Update index for a single content item
+   */
+  async updateContentIndex(contentId) {
+    try {
+      const content2 = await this.db.prepare(`
+          SELECT c.id, c.title, c.data, c.collection_id, c.status,
+                 c.created_at, c.updated_at, c.author_id,
+                 col.name as collection_name, col.display_name as collection_display_name
+          FROM content c
+          JOIN collections col ON c.collection_id = col.id
+          WHERE c.id = ?
+        `).bind(contentId).first();
+      if (!content2) {
+        console.warn(`[CustomRAG] Content ${contentId} not found`);
+        return;
+      }
+      if (content2.status !== "published") {
+        await this.removeContentFromIndex(contentId);
+        return;
+      }
+      const chunks = this.chunkingService.chunkContent(
+        content2.id,
+        content2.collection_id,
+        content2.title || "Untitled",
+        typeof content2.data === "string" ? JSON.parse(content2.data) : content2.data,
+        {
+          status: content2.status,
+          created_at: content2.created_at,
+          updated_at: content2.updated_at,
+          author_id: content2.author_id,
+          collection_name: content2.collection_name,
+          collection_display_name: content2.collection_display_name
+        }
       );
-      AuthManager.setAuthCookie(c, jwtToken);
-      await db.prepare(`
-        UPDATE users SET last_login_at = ? WHERE id = ?
-      `).bind(Date.now(), user.id).run();
-      return c.redirect("/admin/dashboard?message=Successfully signed in");
+      const embeddings = await this.embeddingService.generateBatch(
+        chunks.map((c) => `${c.title}
+
+${c.text}`)
+      );
+      await this.vectorize.upsert(
+        chunks.map((chunk, idx) => ({
+          id: chunk.id,
+          values: embeddings[idx],
+          metadata: {
+            content_id: chunk.content_id,
+            collection_id: chunk.collection_id,
+            title: chunk.title,
+            text: chunk.text.substring(0, 500),
+            chunk_index: chunk.chunk_index,
+            ...chunk.metadata
+          }
+        }))
+      );
+      console.log(`[CustomRAG] Updated index for content ${contentId}: ${chunks.length} chunks`);
     } catch (error) {
-      console.error("Magic link verification error:", error);
-      return c.redirect("/auth/login?error=Authentication failed");
+      console.error(`[CustomRAG] Error updating index for ${contentId}:`, error);
+      throw error;
     }
-  });
-  return {
-    name: "magic-link-auth",
-    version: "1.0.0",
-    description: "Passwordless authentication via email magic links",
-    author: {
-      name: "SonicJS Team",
-      email: "team@sonicjs.com"
-    },
-    dependencies: ["email"],
-    routes: [{
-      path: "/auth/magic-link",
-      handler: magicLinkRoutes,
-      description: "Magic link authentication endpoints",
-      requiresAuth: false
-    }],
-    async install(context) {
-      console.log("Installing magic-link-auth plugin...");
-    },
-    async activate(context) {
-      console.log("Magic link authentication activated");
-      console.log("Users can now sign in via /auth/magic-link/request");
-    },
-    async deactivate(context) {
-      console.log("Magic link authentication deactivated");
-    },
-    async uninstall(context) {
-      console.log("Uninstalling magic-link-auth plugin...");
+  }
+  /**
+   * Remove content from index
+   */
+  async removeContentFromIndex(contentId) {
+    try {
+      console.log(`[CustomRAG] Removing content ${contentId} from index`);
+    } catch (error) {
+      console.error(`[CustomRAG] Error removing content ${contentId}:`, error);
+      throw error;
     }
-  };
-}
-function renderMagicLinkEmail(magicLink, expiryMinutes) {
-  return `
-    <!DOCTYPE html>
-    <html>
-    <head>
-      <meta charset="utf-8">
-      <meta name="viewport" content="width=device-width, initial-scale=1.0">
-      <title>Your Magic Link</title>
-      <style>
-        body {
-          font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, 'Helvetica Neue', Arial, sans-serif;
-          line-height: 1.6;
-          color: #333;
-          max-width: 600px;
-          margin: 0 auto;
-          padding: 20px;
-        }
-        .container {
-          background: #ffffff;
-          border-radius: 8px;
-          padding: 40px;
-          box-shadow: 0 2px 4px rgba(0,0,0,0.1);
-        }
-        .header {
-          text-align: center;
-          margin-bottom: 30px;
-        }
-        .header h1 {
-          color: #0ea5e9;
-          margin: 0;
-          font-size: 24px;
+  }
+  /**
+   * Get search suggestions based on query
+   */
+  async getSuggestions(partialQuery, limit = 5) {
+    try {
+      const queryEmbedding = await this.embeddingService.generateEmbedding(partialQuery);
+      const results = await this.vectorize.query(queryEmbedding, {
+        topK: limit * 2,
+        // Get more to filter
+        returnMetadata: true
+      });
+      const suggestions = [...new Set(
+        results.matches?.map((m) => m.metadata.title).filter(Boolean) || []
+      )].slice(0, limit);
+      return suggestions;
+    } catch (error) {
+      console.error("[CustomRAG] Error getting suggestions:", error);
+      return [];
+    }
+  }
+  /**
+   * Check if Vectorize is available and configured
+   */
+  isAvailable() {
+    return !!this.vectorize && !!this.ai;
+  }
+};
+
+// src/plugins/core-plugins/ai-search-plugin/services/ai-search.ts
+var AISearchService = class {
+  constructor(db, ai, vectorize) {
+    this.db = db;
+    this.ai = ai;
+    this.vectorize = vectorize;
+    if (this.ai && this.vectorize) {
+      this.customRAG = new CustomRAGService(db, ai, vectorize);
+      console.log("[AISearchService] Custom RAG initialized");
+    } else {
+      console.log("[AISearchService] Custom RAG not available, using keyword search only");
+    }
+  }
+  customRAG;
+  /**
+   * Get plugin settings
+   */
+  async getSettings() {
+    try {
+      const plugin2 = await this.db.prepare(`SELECT settings FROM plugins WHERE id = ? LIMIT 1`).bind("ai-search").first();
+      if (!plugin2 || !plugin2.settings) {
+        return this.getDefaultSettings();
+      }
+      return JSON.parse(plugin2.settings);
+    } catch (error) {
+      console.error("Error fetching AI Search settings:", error);
+      return this.getDefaultSettings();
+    }
+  }
+  /**
+   * Get default settings
+   */
+  getDefaultSettings() {
+    return {
+      enabled: true,
+      ai_mode_enabled: true,
+      selected_collections: [],
+      dismissed_collections: [],
+      autocomplete_enabled: true,
+      cache_duration: 1,
+      results_limit: 20,
+      index_media: false
+    };
+  }
+  /**
+   * Update plugin settings
+   */
+  async updateSettings(settings) {
+    const existing = await this.getSettings();
+    const updated = {
+      ...existing,
+      ...settings
+    };
+    try {
+      await this.db.prepare(`
+          UPDATE plugins
+          SET settings = ?,
+              updated_at = unixepoch()
+          WHERE id = 'ai-search'
+        `).bind(JSON.stringify(updated)).run();
+      return updated;
+    } catch (error) {
+      console.error("Error updating AI Search settings:", error);
+      throw error;
+    }
+  }
+  /**
+   * Detect new collections that aren't indexed or dismissed
+   */
+  async detectNewCollections() {
+    try {
+      const collectionsStmt = this.db.prepare(
+        "SELECT id, name, display_name, description FROM collections WHERE is_active = 1"
+      );
+      const { results: allCollections } = await collectionsStmt.all();
+      const collections2 = (allCollections || []).filter(
+        (col) => {
+          if (!col.name) return false;
+          const name = col.name.toLowerCase();
+          return !name.startsWith("test_") && !name.endsWith("_test") && name !== "test_collection" && !name.includes("_test_") && name !== "large_payload_test" && name !== "concurrent_test";
         }
-        .content {
-          margin-bottom: 30px;
+      );
+      const settings = await this.getSettings();
+      const selected = settings?.selected_collections || [];
+      const dismissed = settings?.dismissed_collections || [];
+      const notifications = [];
+      for (const collection of collections2 || []) {
+        const collectionId = String(collection.id);
+        if (selected.includes(collectionId) || dismissed.includes(collectionId)) {
+          continue;
         }
-        .button {
-          display: inline-block;
-          padding: 14px 32px;
-          background: linear-gradient(135deg, #0ea5e9 0%, #06b6d4 100%);
-          color: #ffffff !important;
-          text-decoration: none;
-          border-radius: 6px;
-          font-weight: 600;
-          text-align: center;
-          margin: 20px 0;
+        const countStmt = this.db.prepare(
+          "SELECT COUNT(*) as count FROM content WHERE collection_id = ?"
+        );
+        const countResult = await countStmt.bind(collectionId).first();
+        const itemCount = countResult?.count || 0;
+        notifications.push({
+          collection: {
+            id: collectionId,
+            name: collection.name,
+            display_name: collection.display_name,
+            description: collection.description,
+            item_count: itemCount,
+            is_indexed: false,
+            is_dismissed: false,
+            is_new: true
+          },
+          message: `New collection "${collection.display_name}" with ${itemCount} items available for indexing`
+        });
+      }
+      return notifications;
+    } catch (error) {
+      console.error("Error detecting new collections:", error);
+      return [];
+    }
+  }
+  /**
+   * Get all collections with indexing status
+   */
+  async getAllCollections() {
+    try {
+      const collectionsStmt = this.db.prepare(
+        "SELECT id, name, display_name, description FROM collections WHERE is_active = 1 ORDER BY display_name"
+      );
+      const { results: allCollections } = await collectionsStmt.all();
+      console.log("[AISearchService.getAllCollections] Raw collections from DB:", allCollections?.length || 0);
+      const firstCollection = allCollections?.[0];
+      if (firstCollection) {
+        console.log("[AISearchService.getAllCollections] Sample collection:", {
+          id: firstCollection.id,
+          name: firstCollection.name,
+          display_name: firstCollection.display_name
+        });
+      }
+      const collections2 = (allCollections || []).filter(
+        (col) => col.id && col.name
+      );
+      console.log("[AISearchService.getAllCollections] After filtering test collections:", collections2.length);
+      console.log("[AISearchService.getAllCollections] Remaining collections:", collections2.map((c) => c.name).join(", "));
+      const settings = await this.getSettings();
+      const selected = settings?.selected_collections || [];
+      const dismissed = settings?.dismissed_collections || [];
+      console.log("[AISearchService.getAllCollections] Settings:", {
+        selected_count: selected.length,
+        dismissed_count: dismissed.length,
+        selected
+      });
+      const collectionInfos = [];
+      for (const collection of collections2) {
+        if (!collection.id || !collection.name) continue;
+        const collectionId = String(collection.id);
+        if (!collectionId) {
+          console.warn("[AISearchService] Skipping invalid collection:", collection);
+          continue;
         }
-        .button:hover {
-          opacity: 0.9;
+        const countStmt = this.db.prepare(
+          "SELECT COUNT(*) as count FROM content WHERE collection_id = ?"
+        );
+        const countResult = await countStmt.bind(collectionId).first();
+        const itemCount = countResult?.count || 0;
+        collectionInfos.push({
+          id: collectionId,
+          name: collection.name,
+          display_name: collection.display_name || collection.name,
+          description: collection.description,
+          item_count: itemCount,
+          is_indexed: selected.includes(collectionId),
+          is_dismissed: dismissed.includes(collectionId),
+          is_new: !selected.includes(collectionId) && !dismissed.includes(collectionId)
+        });
+      }
+      console.log("[AISearchService.getAllCollections] Returning collectionInfos:", collectionInfos.length);
+      const firstInfo = collectionInfos[0];
+      if (collectionInfos.length > 0 && firstInfo) {
+        console.log("[AISearchService.getAllCollections] First collectionInfo:", {
+          id: firstInfo.id,
+          name: firstInfo.name,
+          display_name: firstInfo.display_name,
+          item_count: firstInfo.item_count
+        });
+      }
+      return collectionInfos;
+    } catch (error) {
+      console.error("[AISearchService] Error fetching collections:", error);
+      return [];
+    }
+  }
+  /**
+   * Execute search query
+   */
+  async search(query) {
+    const settings = await this.getSettings();
+    if (!settings?.enabled) {
+      return {
+        results: [],
+        total: 0,
+        query_time_ms: 0,
+        mode: query.mode
+      };
+    }
+    if (query.mode === "ai" && settings.ai_mode_enabled && this.customRAG?.isAvailable()) {
+      return this.searchAI(query, settings);
+    }
+    return this.searchKeyword(query, settings);
+  }
+  /**
+   * AI-powered semantic search using Custom RAG
+   */
+  async searchAI(query, settings) {
+    try {
+      if (!this.customRAG) {
+        console.warn("[AISearchService] CustomRAG not available, falling back to keyword search");
+        return this.searchKeyword(query, settings);
+      }
+      const result = await this.customRAG.search(query, settings);
+      return result;
+    } catch (error) {
+      console.error("[AISearchService] AI search error, falling back to keyword:", error);
+      return this.searchKeyword(query, settings);
+    }
+  }
+  /**
+   * Traditional keyword search
+   */
+  async searchKeyword(query, settings) {
+    const startTime = Date.now();
+    try {
+      const conditions = [];
+      const params = [];
+      if (query.query) {
+        conditions.push("(c.title LIKE ? OR c.slug LIKE ? OR c.data LIKE ?)");
+        const searchTerm = `%${query.query}%`;
+        params.push(searchTerm, searchTerm, searchTerm);
+      }
+      if (query.filters?.collections && query.filters.collections.length > 0) {
+        const placeholders = query.filters.collections.map(() => "?").join(",");
+        conditions.push(`c.collection_id IN (${placeholders})`);
+        params.push(...query.filters.collections);
+      } else if (settings.selected_collections.length > 0) {
+        const placeholders = settings.selected_collections.map(() => "?").join(",");
+        conditions.push(`c.collection_id IN (${placeholders})`);
+        params.push(...settings.selected_collections);
+      }
+      if (query.filters?.status && query.filters.status.length > 0) {
+        const placeholders = query.filters.status.map(() => "?").join(",");
+        conditions.push(`c.status IN (${placeholders})`);
+        params.push(...query.filters.status);
+      } else {
+        conditions.push("c.status != 'deleted'");
+      }
+      if (query.filters?.dateRange) {
+        const field = query.filters.dateRange.field || "created_at";
+        if (query.filters.dateRange.start) {
+          conditions.push(`c.${field} >= ?`);
+          params.push(query.filters.dateRange.start.getTime());
         }
-        .expiry {
-          color: #ef4444;
-          font-size: 14px;
-          margin-top: 20px;
+        if (query.filters.dateRange.end) {
+          conditions.push(`c.${field} <= ?`);
+          params.push(query.filters.dateRange.end.getTime());
         }
-        .footer {
-          margin-top: 40px;
-          padding-top: 20px;
-          border-top: 1px solid #e5e7eb;
-          font-size: 12px;
-          color: #6b7280;
-          text-align: center;
+      }
+      if (query.filters?.author) {
+        conditions.push("c.author_id = ?");
+        params.push(query.filters.author);
+      }
+      const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+      const countStmt = this.db.prepare(`
+        SELECT COUNT(*) as count 
+        FROM content c
+        ${whereClause}
+      `);
+      const countResult = await countStmt.bind(...params).first();
+      const total = countResult?.count || 0;
+      const limit = query.limit || settings.results_limit;
+      const offset = query.offset || 0;
+      const resultsStmt = this.db.prepare(`
+        SELECT 
+          c.id, c.title, c.slug, c.collection_id, c.status,
+          c.created_at, c.updated_at, c.author_id, c.data,
+          col.name as collection_name, col.display_name as collection_display_name,
+          u.email as author_email
+        FROM content c
+        JOIN collections col ON c.collection_id = col.id
+        LEFT JOIN users u ON c.author_id = u.id
+        ${whereClause}
+        ORDER BY c.updated_at DESC
+        LIMIT ? OFFSET ?
+      `);
+      const { results } = await resultsStmt.bind(...params, limit, offset).all();
+      const searchResults = (results || []).map((row) => ({
+        id: String(row.id),
+        title: row.title || "Untitled",
+        slug: row.slug || "",
+        collection_id: String(row.collection_id),
+        collection_name: row.collection_display_name || row.collection_name,
+        snippet: this.extractSnippet(row.data, query.query),
+        status: row.status,
+        created_at: Number(row.created_at),
+        updated_at: Number(row.updated_at),
+        author_name: row.author_email
+      }));
+      const queryTime = Date.now() - startTime;
+      await this.logSearch(query.query, query.mode, searchResults.length);
+      return {
+        results: searchResults,
+        total,
+        query_time_ms: queryTime,
+        mode: query.mode
+      };
+    } catch (error) {
+      console.error("Keyword search error:", error);
+      return {
+        results: [],
+        total: 0,
+        query_time_ms: Date.now() - startTime,
+        mode: query.mode
+      };
+    }
+  }
+  /**
+   * Extract snippet from content data
+   */
+  extractSnippet(data, query) {
+    try {
+      const parsed = typeof data === "string" ? JSON.parse(data) : data;
+      const text = JSON.stringify(parsed).toLowerCase();
+      const queryLower = query.toLowerCase();
+      const index = text.indexOf(queryLower);
+      if (index === -1) {
+        return JSON.stringify(parsed).substring(0, 200) + "...";
+      }
+      const start = Math.max(0, index - 50);
+      const end = Math.min(text.length, index + query.length + 50);
+      return text.substring(start, end) + "...";
+    } catch {
+      return data.substring(0, 200) + "...";
+    }
+  }
+  /**
+   * Get search suggestions (autocomplete)
+   */
+  async getSearchSuggestions(partial) {
+    try {
+      const settings = await this.getSettings();
+      if (!settings?.autocomplete_enabled) {
+        return [];
+      }
+      if (this.customRAG?.isAvailable()) {
+        try {
+          const aiSuggestions = await this.customRAG.getSuggestions(partial, 5);
+          if (aiSuggestions.length > 0) {
+            return aiSuggestions;
+          }
+        } catch (error) {
+          console.error("[AISearchService] Error getting AI suggestions:", error);
         }
-        .security-note {
-          background: #fef3c7;
-          border-left: 4px solid #f59e0b;
-          padding: 12px 16px;
-          margin-top: 20px;
-          border-radius: 4px;
-          font-size: 14px;
+      }
+      const stmt = this.db.prepare(`
+        SELECT DISTINCT query 
+        FROM ai_search_history 
+        WHERE query LIKE ? 
+        ORDER BY created_at DESC 
+        LIMIT 10
+      `);
+      const { results } = await stmt.bind(`%${partial}%`).all();
+      return (results || []).map((r) => r.query);
+    } catch (error) {
+      console.error("Error getting suggestions:", error);
+      return [];
+    }
+  }
+  /**
+   * Log search query to history
+   */
+  async logSearch(query, mode, resultsCount) {
+    try {
+      const stmt = this.db.prepare(`
+        INSERT INTO ai_search_history (query, mode, results_count, created_at)
+        VALUES (?, ?, ?, ?)
+      `);
+      await stmt.bind(query, mode, resultsCount, Date.now()).run();
+    } catch (error) {
+      console.error("Error logging search:", error);
+    }
+  }
+  /**
+   * Get search analytics
+   */
+  async getSearchAnalytics() {
+    try {
+      const totalStmt = this.db.prepare(`
+        SELECT COUNT(*) as count 
+        FROM ai_search_history 
+        WHERE created_at >= ?
+      `);
+      const thirtyDaysAgo = Date.now() - 30 * 24 * 60 * 60 * 1e3;
+      const totalResult = await totalStmt.bind(thirtyDaysAgo).first();
+      const modeStmt = this.db.prepare(`
+        SELECT mode, COUNT(*) as count 
+        FROM ai_search_history 
+        WHERE created_at >= ?
+        GROUP BY mode
+      `);
+      const { results: modeResults } = await modeStmt.bind(thirtyDaysAgo).all();
+      const aiCount = modeResults?.find((r) => r.mode === "ai")?.count || 0;
+      const keywordCount = modeResults?.find((r) => r.mode === "keyword")?.count || 0;
+      const popularStmt = this.db.prepare(`
+        SELECT query, COUNT(*) as count 
+        FROM ai_search_history 
+        WHERE created_at >= ?
+        GROUP BY query 
+        ORDER BY count DESC 
+        LIMIT 10
+      `);
+      const { results: popularResults } = await popularStmt.bind(thirtyDaysAgo).all();
+      return {
+        total_queries: totalResult?.count || 0,
+        ai_queries: aiCount,
+        keyword_queries: keywordCount,
+        popular_queries: (popularResults || []).map((r) => ({
+          query: r.query,
+          count: r.count
+        })),
+        average_query_time: 0
+        // TODO: Track query times
+      };
+    } catch (error) {
+      console.error("Error getting analytics:", error);
+      return {
+        total_queries: 0,
+        ai_queries: 0,
+        keyword_queries: 0,
+        popular_queries: [],
+        average_query_time: 0
+      };
+    }
+  }
+  /**
+   * Verify Custom RAG is available
+   */
+  verifyBinding() {
+    return this.customRAG?.isAvailable() ?? false;
+  }
+  /**
+   * Get Custom RAG service instance (for indexer)
+   */
+  getCustomRAG() {
+    return this.customRAG;
+  }
+};
+
+// src/plugins/core-plugins/ai-search-plugin/services/indexer.ts
+var IndexManager = class {
+  constructor(db, ai, vectorize) {
+    this.db = db;
+    this.ai = ai;
+    this.vectorize = vectorize;
+    if (this.ai && this.vectorize) {
+      this.customRAG = new CustomRAGService(db, ai, vectorize);
+      console.log("[IndexManager] Custom RAG initialized");
+    }
+  }
+  customRAG;
+  /**
+   * Index all content items within a collection using Custom RAG
+   */
+  async indexCollection(collectionId) {
+    try {
+      const collectionStmt = this.db.prepare(
+        "SELECT id, name, display_name FROM collections WHERE id = ?"
+      );
+      const collection = await collectionStmt.bind(collectionId).first();
+      if (!collection) {
+        throw new Error(`Collection ${collectionId} not found`);
+      }
+      await this.updateIndexStatus(collectionId, {
+        collection_id: collectionId,
+        collection_name: collection.display_name,
+        total_items: 0,
+        indexed_items: 0,
+        status: "indexing"
+      });
+      if (this.customRAG?.isAvailable()) {
+        console.log(`[IndexManager] Using Custom RAG to index collection ${collectionId}`);
+        const result = await this.customRAG.indexCollection(collectionId);
+        const finalStatus = {
+          collection_id: collectionId,
+          collection_name: collection.display_name,
+          total_items: result.total_items,
+          indexed_items: result.indexed_chunks,
+          last_sync_at: Date.now(),
+          status: result.errors > 0 ? "error" : "completed",
+          error_message: result.errors > 0 ? `${result.errors} errors during indexing` : void 0
+        };
+        await this.updateIndexStatus(collectionId, finalStatus);
+        return finalStatus;
+      }
+      console.warn(`[IndexManager] Custom RAG not available, skipping indexing for ${collectionId}`);
+      const fallbackStatus = {
+        collection_id: collectionId,
+        collection_name: collection.display_name,
+        total_items: 0,
+        indexed_items: 0,
+        last_sync_at: Date.now(),
+        status: "completed",
+        error_message: "Custom RAG not available - using keyword search only"
+      };
+      await this.updateIndexStatus(collectionId, fallbackStatus);
+      return fallbackStatus;
+    } catch (error) {
+      console.error(`[IndexManager] Error indexing collection ${collectionId}:`, error);
+      const errorStatus = {
+        collection_id: collectionId,
+        collection_name: "Unknown",
+        total_items: 0,
+        indexed_items: 0,
+        status: "error",
+        error_message: error instanceof Error ? error.message : String(error)
+      };
+      await this.updateIndexStatus(collectionId, errorStatus);
+      return errorStatus;
+    }
+  }
+  /**
+   * Index a single content item
+   */
+  async indexContentItem(item, collectionId) {
+    try {
+      let parsedData = {};
+      try {
+        parsedData = typeof item.data === "string" ? JSON.parse(item.data) : item.data;
+      } catch {
+        parsedData = {};
+      }
+      const document = {
+        id: `content_${item.id}`,
+        title: item.title || "Untitled",
+        slug: item.slug || "",
+        content: this.extractSearchableText(parsedData),
+        metadata: {
+          collection_id: collectionId,
+          collection_name: item.collection_name,
+          collection_display_name: item.collection_display_name,
+          status: item.status,
+          created_at: item.created_at,
+          updated_at: item.updated_at,
+          author_id: item.author_id
         }
-      </style>
-    </head>
-    <body>
-      <div class="container">
-        <div class="header">
-          <h1>\u{1F517} Your Magic Link</h1>
+      };
+      console.log(`Indexed content item: ${item.id}`);
+    } catch (error) {
+      console.error(`Error indexing content item ${item.id}:`, error);
+      throw error;
+    }
+  }
+  /**
+   * Extract searchable text from content data
+   */
+  extractSearchableText(data) {
+    const parts = [];
+    if (data.title) parts.push(String(data.title));
+    if (data.name) parts.push(String(data.name));
+    if (data.description) parts.push(String(data.description));
+    if (data.content) parts.push(String(data.content));
+    if (data.body) parts.push(String(data.body));
+    if (data.text) parts.push(String(data.text));
+    const extractStrings = (obj) => {
+      if (typeof obj === "string") {
+        parts.push(obj);
+      } else if (Array.isArray(obj)) {
+        obj.forEach(extractStrings);
+      } else if (obj && typeof obj === "object") {
+        Object.values(obj).forEach(extractStrings);
+      }
+    };
+    extractStrings(data);
+    return parts.join(" ");
+  }
+  /**
+   * Update a single content item in the index
+   */
+  async updateIndex(collectionId, contentId) {
+    try {
+      const stmt = this.db.prepare(`
+            SELECT 
+              c.id, c.title, c.slug, c.data, c.status,
+              c.created_at, c.updated_at, c.author_id,
+              col.name as collection_name, col.display_name as collection_display_name
+            FROM content c
+            JOIN collections col ON c.collection_id = col.id
+            WHERE c.id = ? AND c.collection_id = ?
+          `);
+      const item = await stmt.bind(contentId, collectionId).first();
+      if (!item) {
+        throw new Error(`Content item ${contentId} not found`);
+      }
+      await this.indexContentItem(item, String(collectionId));
+      const status = await this.getIndexStatus(String(collectionId));
+      if (status) {
+        await this.updateIndexStatus(String(collectionId), {
+          ...status,
+          last_sync_at: Date.now()
+        });
+      }
+    } catch (error) {
+      console.error(`Error updating index for content ${contentId}:`, error);
+      throw error;
+    }
+  }
+  /**
+   * Remove a content item from the index using Custom RAG
+   */
+  async removeFromIndex(collectionId, contentId) {
+    try {
+      if (this.customRAG?.isAvailable()) {
+        console.log(`[IndexManager] Removing content ${contentId} from index`);
+        await this.customRAG.removeContentFromIndex(contentId);
+      } else {
+        console.warn(`[IndexManager] Custom RAG not available, skipping removal for ${contentId}`);
+      }
+    } catch (error) {
+      console.error(`[IndexManager] Error removing content ${contentId} from index:`, error);
+      throw error;
+    }
+  }
+  /**
+   * Get indexing status for a collection
+   */
+  async getIndexStatus(collectionId) {
+    try {
+      const stmt = this.db.prepare(
+        "SELECT * FROM ai_search_index_meta WHERE collection_id = ?"
+      );
+      const result = await stmt.bind(collectionId).first();
+      if (!result) {
+        return null;
+      }
+      return {
+        collection_id: String(result.collection_id),
+        collection_name: result.collection_name,
+        total_items: result.total_items,
+        indexed_items: result.indexed_items,
+        last_sync_at: result.last_sync_at,
+        status: result.status,
+        error_message: result.error_message
+      };
+    } catch (error) {
+      console.error(`Error getting index status for collection ${collectionId}:`, error);
+      return null;
+    }
+  }
+  /**
+   * Get indexing status for all collections
+   */
+  async getAllIndexStatus() {
+    try {
+      const stmt = this.db.prepare("SELECT * FROM ai_search_index_meta");
+      const { results } = await stmt.all();
+      const statusMap = {};
+      for (const row of results || []) {
+        const collectionId = String(row.collection_id);
+        statusMap[collectionId] = {
+          collection_id: collectionId,
+          collection_name: row.collection_name,
+          total_items: row.total_items,
+          indexed_items: row.indexed_items,
+          last_sync_at: row.last_sync_at,
+          status: row.status,
+          error_message: row.error_message
+        };
+      }
+      return statusMap;
+    } catch (error) {
+      console.error("Error getting all index status:", error);
+      return {};
+    }
+  }
+  /**
+   * Update index status in database
+   */
+  async updateIndexStatus(collectionId, status) {
+    try {
+      const checkStmt = this.db.prepare(
+        "SELECT id FROM ai_search_index_meta WHERE collection_id = ?"
+      );
+      const existing = await checkStmt.bind(collectionId).first();
+      if (existing) {
+        const stmt = this.db.prepare(`
+              UPDATE ai_search_index_meta 
+              SET collection_name = ?,
+                  total_items = ?,
+                  indexed_items = ?,
+                  last_sync_at = ?,
+                  status = ?,
+                  error_message = ?
+              WHERE collection_id = ?
+            `);
+        await stmt.bind(
+          status.collection_name,
+          status.total_items,
+          status.indexed_items,
+          status.last_sync_at || null,
+          status.status,
+          status.error_message || null,
+          String(collectionId)
+        ).run();
+      } else {
+        const stmt = this.db.prepare(`
+              INSERT INTO ai_search_index_meta (
+                collection_id, collection_name, total_items, indexed_items,
+                last_sync_at, status, error_message
+              ) VALUES (?, ?, ?, ?, ?, ?, ?)
+            `);
+        await stmt.bind(
+          String(status.collection_id),
+          status.collection_name,
+          status.total_items,
+          status.indexed_items,
+          status.last_sync_at || null,
+          status.status,
+          status.error_message || null
+        ).run();
+      }
+    } catch (error) {
+      console.error(`Error updating index status for collection ${collectionId}:`, error);
+      throw error;
+    }
+  }
+  /**
+   * Sync all selected collections
+   */
+  async syncAll(selectedCollections) {
+    for (const collectionId of selectedCollections) {
+      try {
+        await this.indexCollection(collectionId);
+      } catch (error) {
+        console.error(`Error syncing collection ${collectionId}:`, error);
+      }
+    }
+  }
+};
+
+// src/plugins/core-plugins/ai-search-plugin/components/settings-page.ts
+function renderSettingsPage(data) {
+  const settings = data.settings || {
+    enabled: false,
+    ai_mode_enabled: true,
+    selected_collections: [],
+    dismissed_collections: [],
+    autocomplete_enabled: true,
+    cache_duration: 1,
+    results_limit: 20,
+    index_media: false
+  };
+  const selectedCollections = Array.isArray(settings.selected_collections) ? settings.selected_collections : [];
+  const dismissedCollections = Array.isArray(settings.dismissed_collections) ? settings.dismissed_collections : [];
+  const enabled = settings.enabled === true;
+  const aiModeEnabled = settings.ai_mode_enabled !== false;
+  const autocompleteEnabled = settings.autocomplete_enabled !== false;
+  const indexMedia = settings.index_media === true;
+  const selectedCollectionIds = new Set(selectedCollections.map((id) => String(id)));
+  const dismissedCollectionIds = new Set(dismissedCollections.map((id) => String(id)));
+  const collections2 = Array.isArray(data.collections) ? data.collections : [];
+  console.log("[SettingsPage Template] Collections received:", collections2.length);
+  if (collections2.length > 0) {
+    console.log("[SettingsPage Template] First collection:", collections2[0]);
+  }
+  const content2 = `
+    <div class="w-full px-4 sm:px-6 lg:px-8 py-6">
+      <!-- Header with Back Button -->
+      <div class="flex flex-col sm:flex-row sm:items-center sm:justify-between mb-6">
+        <div>
+          <h1 class="text-2xl/8 font-semibold text-zinc-950 dark:text-white sm:text-xl/8">\u{1F50D} AI Search Settings</h1>
+          <p class="mt-2 text-sm/6 text-zinc-500 dark:text-zinc-400">
+            Configure advanced search with Cloudflare AI Search. Select collections to index and manage search preferences.
+          </p>
+        </div>
+        <div class="mt-4 sm:mt-0 sm:ml-16 sm:flex-none">
+          <a href="/admin/plugins" class="inline-flex items-center justify-center rounded-lg bg-white dark:bg-zinc-800 px-3.5 py-2.5 text-sm font-semibold text-zinc-950 dark:text-white ring-1 ring-inset ring-zinc-950/10 dark:ring-white/10 hover:bg-zinc-50 dark:hover:bg-zinc-700 transition-colors shadow-sm">
+            <svg class="-ml-0.5 mr-1.5 h-5 w-5" fill="none" stroke="currentColor" viewBox="0 0 24 24">
+              <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M10 19l-7-7m0 0l7-7m-7 7h18"/>
+            </svg>
+            Back to Plugins
+          </a>
+        </div>
+      </div>
+
+
+          <!-- Main Settings Card -->
+          <div class="rounded-xl bg-white dark:bg-zinc-900 shadow-sm ring-1 ring-zinc-950/5 dark:ring-white/10 p-6 mb-6">
+            <form id="settingsForm" class="space-y-6">
+              <!-- Enable Search Section -->
+              <div>
+                <h2 class="text-xl font-semibold text-zinc-950 dark:text-white mb-4">\u{1F50D} Search Settings</h2>
+                <div class="space-y-3">
+                  <div class="flex items-center gap-3 p-4 border border-indigo-200 bg-indigo-50 dark:bg-indigo-900/20 rounded-lg">
+                    <input type="checkbox" id="enabled" name="enabled" ${enabled ? "checked" : ""} class="w-5 h-5 rounded border-gray-300 text-indigo-600 focus:ring-indigo-500 cursor-pointer">
+                    <div class="flex-1">
+                      <label for="enabled" class="text-base font-semibold text-zinc-900 dark:text-white select-none cursor-pointer block">Enable AI Search</label>
+                      <p class="text-xs text-zinc-600 dark:text-zinc-400 mt-0.5">Turn on advanced search capabilities across your content</p>
+                    </div>
+                  </div>
+
+                  <div class="flex items-center gap-3 p-4 border border-blue-200 bg-blue-50 dark:bg-blue-900/20 rounded-lg">
+                    <input type="checkbox" id="ai_mode_enabled" name="ai_mode_enabled" ${aiModeEnabled ? "checked" : ""} class="w-5 h-5 rounded border-gray-300 text-blue-600 focus:ring-blue-500 cursor-pointer">
+                    <div class="flex-1">
+                      <label for="ai_mode_enabled" class="text-base font-semibold text-zinc-900 dark:text-white select-none cursor-pointer block">\u{1F916} AI/Semantic Search</label>
+                      <p class="text-xs text-zinc-600 dark:text-zinc-400 mt-0.5">
+                        Enable natural language queries (requires Cloudflare Workers AI binding)
+                        <a href="https://developers.cloudflare.com/workers-ai/" target="_blank" class="text-blue-600 dark:text-blue-400 hover:underline ml-1">\u2192 Setup Guide</a>
+                      </p>
+                      <p class="text-xs text-amber-600 dark:text-amber-400 mt-1">
+                        \u26A0\uFE0F If AI binding unavailable, will fallback to keyword search
+                      </p>
+                    </div>
+                  </div>
+                </div>
+              </div>
+
+              <hr class="border-zinc-200 dark:border-zinc-800">
+
+              <!-- Collections Section -->
+              <div>
+                <div class="flex items-start justify-between mb-4">
+                  <div>
+                    <h2 class="text-xl font-semibold text-zinc-950 dark:text-white">\u{1F4DA} Collections to Index</h2>
+                    <p class="text-sm text-zinc-600 dark:text-zinc-400 mt-1">
+                      Select which content collections should be indexed and searchable. Only checked collections will be included in search results.
+                    </p>
+                  </div>
+                </div>
+            <div class="space-y-3 max-h-96 overflow-y-auto border-2 border-zinc-300 dark:border-zinc-700 rounded-lg p-4 bg-white dark:bg-zinc-800" id="collections-list">
+              ${collections2.length === 0 ? '<p class="text-sm text-zinc-500 dark:text-zinc-400 p-4">No collections available. Create collections first.</p>' : collections2.map((collection) => {
+    const collectionId = String(collection.id);
+    const isChecked = selectedCollectionIds.has(collectionId);
+    const isDismissed = dismissedCollectionIds.has(collectionId);
+    const indexStatusMap = data.indexStatus || {};
+    const status = indexStatusMap[collectionId];
+    const isNew = collection.is_new === true && !isDismissed && !status;
+    const statusBadge = status && isChecked ? `<span class="ml-2 px-2 py-1 text-xs rounded-full ${status.status === "completed" ? "bg-green-100 text-green-800 dark:bg-green-900/30 dark:text-green-300" : status.status === "indexing" ? "bg-blue-100 text-blue-800 dark:bg-blue-900/30 dark:text-blue-300" : status.status === "error" ? "bg-red-100 text-red-800 dark:bg-red-900/30 dark:text-red-300" : "bg-gray-100 text-gray-800 dark:bg-gray-800 dark:text-gray-300"}">${status.status}</span>` : "";
+    return `<div class="flex items-start gap-3 p-3 rounded-lg border border-zinc-200 dark:border-zinc-700 ${isNew ? "bg-blue-50 dark:bg-blue-900/10 border-blue-200 dark:border-blue-800" : "hover:bg-zinc-50 dark:hover:bg-zinc-800"}">
+                      <input
+                        type="checkbox"
+                        id="collection_${collectionId}"
+                        name="selected_collections"
+                        value="${collectionId}"
+                        ${isChecked ? "checked" : ""}
+                        class="mt-1 w-5 h-5 text-indigo-600 bg-white border-gray-300 rounded focus:ring-indigo-500 focus:ring-2 cursor-pointer"
+                        style="cursor: pointer; flex-shrink: 0;"
+                      />
+                      <div class="flex-1 min-w-0">
+                        <label for="collection_${collectionId}" class="text-sm font-medium text-zinc-950 dark:text-white select-none cursor-pointer flex items-center">
+                          ${collection.display_name || collection.name || "Unnamed Collection"}
+                          ${isNew ? '<span class="ml-2 px-2 py-0.5 text-xs rounded-full bg-blue-100 text-blue-800 dark:bg-blue-900/30 dark:text-blue-300">NEW</span>' : ""}
+                          ${statusBadge}
+                        </label>
+                        <p class="text-xs text-zinc-500 dark:text-zinc-400 mt-1">
+                          ${collection.description || collection.name || "No description"} \u2022 ${collection.item_count || 0} items
+                          ${status ? ` \u2022 ${status.indexed_items}/${status.total_items} indexed` : ""}
+                        </p>
+                        ${status && status.status === "indexing" ? `<div class="mt-2 w-full bg-gray-200 rounded-full h-2 dark:bg-gray-700">
+                              <div class="bg-blue-600 h-2 rounded-full" style="width: ${status.indexed_items / status.total_items * 100}%"></div>
+                            </div>` : ""}
+                      </div>
+                      ${isChecked ? `
+                        <button
+                          type="button"
+                          onclick="reindexCollection('${collectionId}')"
+                          class="px-3 py-1.5 text-xs font-medium text-white bg-indigo-600 hover:bg-indigo-700 rounded-md transition-colors flex items-center gap-1.5 whitespace-nowrap"
+                          ${status && status.status === "indexing" ? "disabled" : ""}
+                        >
+                          <svg class="w-3.5 h-3.5" fill="none" stroke="currentColor" viewBox="0 0 24 24">
+                            <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M4 4v5h.582m15.356 2A8.001 8.001 0 004.582 9m0 0H9m11 11v-5h-.581m0 0a8.003 8.003 0 01-15.357-2m15.357 2H15" />
+                          </svg>
+                          Re-index
+                        </button>
+                      ` : ""}
+                    </div>`;
+  }).join("")}
+            </div>
+          </div>
+
+              <hr class="border-zinc-200 dark:border-zinc-800">
+
+              <!-- Advanced Options -->
+              <div>
+                <h2 class="text-xl font-semibold text-zinc-950 dark:text-white mb-4">\u2699\uFE0F Advanced Options</h2>
+                <div class="grid grid-cols-1 md:grid-cols-2 gap-4">
+                  <div class="flex items-start gap-3 p-3 border border-zinc-200 dark:border-zinc-700 rounded-lg">
+                    <input type="checkbox" id="autocomplete_enabled" name="autocomplete_enabled" ${autocompleteEnabled ? "checked" : ""} class="mt-0.5 w-5 h-5 rounded border-gray-300 text-indigo-600 focus:ring-indigo-500 cursor-pointer">
+                    <div>
+                      <label for="autocomplete_enabled" class="text-sm font-medium text-zinc-950 dark:text-white select-none cursor-pointer block">Autocomplete Suggestions</label>
+                      <p class="text-xs text-zinc-500 dark:text-zinc-400 mt-0.5">Show search suggestions as users type</p>
+                    </div>
+                  </div>
+
+                  <div class="flex items-start gap-3 p-3 border border-zinc-200 dark:border-zinc-700 rounded-lg">
+                    <input type="checkbox" id="index_media" name="index_media" ${indexMedia ? "checked" : ""} class="mt-0.5 w-5 h-5 rounded border-gray-300 text-indigo-600 focus:ring-indigo-500 cursor-pointer">
+                    <div>
+                      <label for="index_media" class="text-sm font-medium text-zinc-950 dark:text-white select-none cursor-pointer block">Index Media Metadata</label>
+                      <p class="text-xs text-zinc-500 dark:text-zinc-400 mt-0.5">Include media files in search results</p>
+                    </div>
+                  </div>
+
+                  <div>
+                    <label class="block text-sm font-medium text-zinc-950 dark:text-white mb-2">Cache Duration (hours)</label>
+                    <input type="number" id="cache_duration" name="cache_duration" value="${settings.cache_duration || 1}" min="0" max="24" class="w-full rounded-lg bg-white dark:bg-white/5 px-3 py-2 text-sm text-zinc-950 dark:text-white ring-1 ring-inset ring-zinc-950/10 dark:ring-white/10 focus:ring-2 focus:ring-indigo-500">
+                  </div>
+                  <div>
+                    <label class="block text-sm font-medium text-zinc-950 dark:text-white mb-2">Results Per Page</label>
+                    <input type="number" id="results_limit" name="results_limit" value="${settings.results_limit || 20}" min="10" max="100" class="w-full rounded-lg bg-white dark:bg-white/5 px-3 py-2 text-sm text-zinc-950 dark:text-white ring-1 ring-inset ring-zinc-950/10 dark:ring-white/10 focus:ring-2 focus:ring-indigo-500">
+                  </div>
+                </div>
+          </div>
+
+              <!-- Save Button -->
+              <div class="flex items-center justify-between pt-4 border-t border-zinc-200 dark:border-zinc-800">
+                <p class="text-xs text-zinc-500 dark:text-zinc-400">
+                  \u{1F4A1} Collections marked as <span class="px-1.5 py-0.5 text-xs font-medium rounded-full bg-blue-500 text-white">NEW</span> haven't been indexed yet
+                </p>
+                <button type="submit" class="inline-flex items-center justify-center rounded-lg bg-indigo-600 text-white px-6 py-2.5 text-sm font-semibold hover:bg-indigo-500 shadow-sm transition-colors">
+                  \u{1F4BE} Save Settings
+                </button>
+              </div>
+        </form>
+      </div>
+
+
+          <!-- Search Analytics -->
+          <div class="rounded-xl bg-white dark:bg-zinc-900 shadow-sm ring-1 ring-zinc-950/5 dark:ring-white/10 p-6">
+            <h2 class="text-xl font-semibold text-zinc-950 dark:text-white mb-4">\u{1F4CA} Search Analytics</h2>
+        <div class="grid grid-cols-1 md:grid-cols-3 gap-4 mb-6">
+          <div class="p-4 rounded-lg bg-zinc-50 dark:bg-zinc-800">
+            <div class="text-sm text-zinc-500 dark:text-zinc-400">Total Queries</div>
+            <div class="text-2xl font-bold text-zinc-950 dark:text-white mt-1">${data.analytics.total_queries}</div>
+          </div>
+          <div class="p-4 rounded-lg bg-zinc-50 dark:bg-zinc-800">
+            <div class="text-sm text-zinc-500 dark:text-zinc-400">AI Queries</div>
+            <div class="text-2xl font-bold text-blue-600 dark:text-blue-400 mt-1">${data.analytics.ai_queries}</div>
+          </div>
+          <div class="p-4 rounded-lg bg-zinc-50 dark:bg-zinc-800">
+            <div class="text-sm text-zinc-500 dark:text-zinc-400">Keyword Queries</div>
+            <div class="text-2xl font-bold text-indigo-600 dark:text-indigo-400 mt-1">${data.analytics.keyword_queries}</div>
+          </div>
+        </div>
+        ${data.analytics.popular_queries.length > 0 ? `
+              <div>
+                <h3 class="text-sm font-semibold text-zinc-950 dark:text-white mb-2">Popular Searches</h3>
+                <div class="space-y-1">
+                  ${data.analytics.popular_queries.map(
+    (item) => `
+                      <div class="flex items-center justify-between text-sm">
+                        <span class="text-zinc-700 dark:text-zinc-300">"${item.query}"</span>
+                        <span class="text-zinc-500 dark:text-zinc-400">${item.count} times</span>
+                      </div>
+                    `
+  ).join("")}
+                </div>
+              </div>
+            ` : '<p class="text-sm text-zinc-500 dark:text-zinc-400">No search history yet.</p>'}
+      </div>
+
+          <!-- Success Message -->
+          <div id="msg" class="hidden fixed bottom-4 right-4 p-4 rounded-lg bg-green-50 text-green-900 border border-green-200 dark:bg-green-900/20 dark:text-green-100 dark:border-green-800 shadow-lg z-50">
+            <div class="flex items-center gap-2">
+              <span class="text-xl">\u2705</span>
+              <span class="font-semibold">Settings Saved Successfully!</span>
+            </div>
+          </div>
+    </div>
+    <script>
+      // Form submission with error handling
+      document.getElementById('settingsForm').addEventListener('submit', async (e) => {
+        e.preventDefault();
+        console.log('[AI Search Client] Form submitted');
+        
+        try {
+          const btn = e.submitter;
+          btn.innerText = 'Saving...'; 
+          btn.disabled = true;
+          
+          const formData = new FormData(e.target);
+          const selectedCollections = Array.from(formData.getAll('selected_collections')).map(String);
+          
+          const data = {
+            enabled: document.getElementById('enabled').checked,
+            ai_mode_enabled: document.getElementById('ai_mode_enabled').checked,
+            selected_collections: selectedCollections,
+            autocomplete_enabled: document.getElementById('autocomplete_enabled').checked,
+            cache_duration: Number(formData.get('cache_duration')),
+            results_limit: Number(formData.get('results_limit')),
+            index_media: document.getElementById('index_media').checked,
+          };
+          
+          console.log('[AI Search Client] Sending data:', data);
+          console.log('[AI Search Client] Selected collections:', selectedCollections);
+          
+          const res = await fetch('/admin/plugins/ai-search', { 
+            method: 'POST', 
+            headers: {'Content-Type': 'application/json'}, 
+            body: JSON.stringify(data) 
+          });
+          
+          console.log('[AI Search Client] Response status:', res.status);
+          
+          if (res.ok) {
+            const result = await res.json();
+            console.log('[AI Search Client] Save successful:', result);
+            document.getElementById('msg').classList.remove('hidden'); 
+            setTimeout(() => {
+              document.getElementById('msg').classList.add('hidden');
+              location.reload();
+            }, 2000); 
+          } else {
+            const error = await res.text();
+            console.error('[AI Search Client] Save failed:', error);
+            alert('Failed to save settings: ' + error);
+          }
+          
+          btn.innerText = 'Save Settings'; 
+          btn.disabled = false;
+        } catch (error) {
+          console.error('[AI Search Client] Error:', error);
+          alert('Error saving settings: ' + error.message);
+        }
+      });
+
+      // Add collection to index
+      async function addCollectionToIndex(collectionId) {
+        const form = document.getElementById('settingsForm');
+        const checkbox = document.getElementById('collection_' + collectionId);
+        if (checkbox) {
+          checkbox.checked = true;
+          form.dispatchEvent(new Event('submit'));
+        }
+      }
+
+      // Dismiss collection
+      async function dismissCollection(collectionId) {
+        const res = await fetch('/admin/plugins/ai-search', {
+          method: 'POST',
+          headers: {'Content-Type': 'application/json'},
+          body: JSON.stringify({
+            dismissed_collections: [collectionId]
+          })
+        });
+        if (res.ok) {
+          location.reload();
+        }
+      }
+
+      // Re-index collection
+      async function reindexCollection(collectionId) {
+        const res = await fetch('/admin/plugins/ai-search/api/reindex', {
+          method: 'POST',
+          headers: {'Content-Type': 'application/json'},
+          body: JSON.stringify({ collection_id: collectionId })
+        });
+        if (res.ok) {
+          alert('Re-indexing started. Page will refresh in a moment.');
+          setTimeout(() => location.reload(), 2000);
+        } else {
+          alert('Failed to start re-indexing. Please try again.');
+        }
+      }
+
+      // Poll for index status updates
+      setInterval(async () => {
+        const res = await fetch('/admin/plugins/ai-search/api/status');
+        if (res.ok) {
+          const { data } = await res.json();
+          // Update status indicators if needed
+          // For now, just reload every 30 seconds if indexing is in progress
+          const hasIndexing = Object.values(data).some((s) => s.status === 'indexing');
+          if (hasIndexing) {
+            location.reload();
+          }
+        }
+      }, 30000);
+    </script>
+  `;
+  return renderAdminLayout({
+    title: "AI Search Settings",
+    pageTitle: "AI Search Settings",
+    currentPath: "/admin/plugins/ai-search/settings",
+    user: data.user,
+    content: content2
+  });
+}
+
+// src/plugins/core-plugins/ai-search-plugin/routes/admin.ts
+var adminRoutes = new Hono();
+adminRoutes.use("*", requireAuth());
+adminRoutes.get("/", async (c) => {
+  try {
+    const user = c.get("user");
+    const db = c.env.DB;
+    const ai = c.env.AI;
+    const vectorize = c.env.VECTORIZE_INDEX;
+    const service = new AISearchService(db, ai, vectorize);
+    const indexer = new IndexManager(db, ai, vectorize);
+    const settings = await service.getSettings();
+    console.log("[AI Search Settings Route] Settings loaded:", !!settings);
+    const collections2 = await service.getAllCollections();
+    console.log("[AI Search Settings Route] Collections returned:", collections2.length);
+    if (collections2.length === 0) {
+      const directQuery = await db.prepare("SELECT id, name, display_name FROM collections WHERE is_active = 1").all();
+      console.log("[AI Search Settings Route] Direct DB query found:", directQuery.results?.length || 0, "collections");
+      if (directQuery.results && directQuery.results.length > 0) {
+        console.log("[AI Search Settings Route] Sample from DB:", directQuery.results[0]);
+      }
+    } else if (collections2.length > 0 && collections2[0]) {
+      console.log("[AI Search Settings Route] First collection:", {
+        id: collections2[0].id,
+        name: collections2[0].name,
+        display_name: collections2[0].display_name
+      });
+    }
+    const newCollections = await service.detectNewCollections();
+    console.log("AI Search: New collections:", newCollections.length);
+    const indexStatus = await indexer.getAllIndexStatus();
+    console.log("AI Search: Index status:", Object.keys(indexStatus).length);
+    const analytics = await service.getSearchAnalytics();
+    return c.html(
+      renderSettingsPage({
+        settings,
+        collections: collections2 || [],
+        newCollections: newCollections || [],
+        indexStatus: indexStatus || {},
+        analytics,
+        user: {
+          name: user.email,
+          email: user.email,
+          role: user.role
+        }
+      })
+    );
+  } catch (error) {
+    console.error("Error rendering AI Search settings:", error);
+    return c.html(`<p>Error loading settings: ${error instanceof Error ? error.message : String(error)}</p>`, 500);
+  }
+});
+adminRoutes.post("/", async (c) => {
+  try {
+    const db = c.env.DB;
+    const ai = c.env.AI;
+    const vectorize = c.env.VECTORIZE_INDEX;
+    const service = new AISearchService(db, ai, vectorize);
+    const indexer = new IndexManager(db, ai, vectorize);
+    const body = await c.req.json();
+    console.log("[AI Search POST] Received body:", JSON.stringify(body, null, 2));
+    const currentSettings = await service.getSettings();
+    console.log("[AI Search POST] Current settings selected_collections:", currentSettings?.selected_collections);
+    const updatedSettings = {
+      enabled: body.enabled !== void 0 ? Boolean(body.enabled) : currentSettings?.enabled,
+      ai_mode_enabled: body.ai_mode_enabled !== void 0 ? Boolean(body.ai_mode_enabled) : currentSettings?.ai_mode_enabled,
+      selected_collections: Array.isArray(body.selected_collections) ? body.selected_collections.map(String) : currentSettings?.selected_collections || [],
+      dismissed_collections: Array.isArray(body.dismissed_collections) ? body.dismissed_collections.map(String) : currentSettings?.dismissed_collections || [],
+      autocomplete_enabled: body.autocomplete_enabled !== void 0 ? Boolean(body.autocomplete_enabled) : currentSettings?.autocomplete_enabled,
+      cache_duration: body.cache_duration ? Number(body.cache_duration) : currentSettings?.cache_duration,
+      results_limit: body.results_limit ? Number(body.results_limit) : currentSettings?.results_limit,
+      index_media: body.index_media !== void 0 ? Boolean(body.index_media) : currentSettings?.index_media
+    };
+    console.log("[AI Search POST] Updated settings selected_collections:", updatedSettings.selected_collections);
+    const collectionsChanged = JSON.stringify(updatedSettings.selected_collections) !== JSON.stringify(currentSettings?.selected_collections || []);
+    const saved = await service.updateSettings(updatedSettings);
+    console.log("[AI Search POST] Settings saved, selected_collections:", saved.selected_collections);
+    if (collectionsChanged && updatedSettings.selected_collections) {
+      console.log("[AI Search POST] Collections changed, starting background indexing");
+      c.executionCtx.waitUntil(
+        indexer.syncAll(updatedSettings.selected_collections).then(() => console.log("[AI Search POST] Background indexing completed")).catch((error) => console.error("[AI Search POST] Background indexing error:", error))
+      );
+    }
+    return c.json({ success: true, settings: saved });
+  } catch (error) {
+    console.error("Error updating AI Search settings:", error);
+    return c.json({ error: "Failed to update settings" }, 500);
+  }
+});
+adminRoutes.get("/api/settings", async (c) => {
+  try {
+    const db = c.env.DB;
+    const ai = c.env.AI;
+    const vectorize = c.env.VECTORIZE_INDEX;
+    const service = new AISearchService(db, ai, vectorize);
+    const settings = await service.getSettings();
+    return c.json({ success: true, data: settings });
+  } catch (error) {
+    console.error("Error fetching settings:", error);
+    return c.json({ error: "Failed to fetch settings" }, 500);
+  }
+});
+adminRoutes.get("/api/new-collections", async (c) => {
+  try {
+    const db = c.env.DB;
+    const ai = c.env.AI;
+    const vectorize = c.env.VECTORIZE_INDEX;
+    const service = new AISearchService(db, ai, vectorize);
+    const notifications = await service.detectNewCollections();
+    return c.json({ success: true, data: notifications });
+  } catch (error) {
+    console.error("Error detecting new collections:", error);
+    return c.json({ error: "Failed to detect new collections" }, 500);
+  }
+});
+adminRoutes.get("/api/status", async (c) => {
+  try {
+    const db = c.env.DB;
+    const ai = c.env.AI;
+    const vectorize = c.env.VECTORIZE_INDEX;
+    const indexer = new IndexManager(db, ai, vectorize);
+    const status = await indexer.getAllIndexStatus();
+    return c.json({ success: true, data: status });
+  } catch (error) {
+    console.error("Error fetching index status:", error);
+    return c.json({ error: "Failed to fetch status" }, 500);
+  }
+});
+adminRoutes.post("/api/reindex", async (c) => {
+  try {
+    const db = c.env.DB;
+    const ai = c.env.AI;
+    const vectorize = c.env.VECTORIZE_INDEX;
+    const indexer = new IndexManager(db, ai, vectorize);
+    const body = await c.req.json();
+    const collectionIdRaw = body.collection_id;
+    const collectionId = collectionIdRaw ? String(collectionIdRaw) : "";
+    if (!collectionId || collectionId === "undefined" || collectionId === "null") {
+      return c.json({ error: "collection_id is required" }, 400);
+    }
+    c.executionCtx.waitUntil(
+      indexer.indexCollection(collectionId).then(() => console.log(`[AI Search Reindex] Completed for collection ${collectionId}`)).catch((error) => console.error(`[AI Search Reindex] Error for collection ${collectionId}:`, error))
+    );
+    return c.json({ success: true, message: "Re-indexing started" });
+  } catch (error) {
+    console.error("Error starting re-index:", error);
+    return c.json({ error: "Failed to start re-indexing" }, 500);
+  }
+});
+var admin_default = adminRoutes;
+var apiRoutes = new Hono();
+apiRoutes.post("/", async (c) => {
+  try {
+    const db = c.env.DB;
+    const ai = c.env.AI;
+    const vectorize = c.env.VECTORIZE_INDEX;
+    const service = new AISearchService(db, ai, vectorize);
+    const body = await c.req.json();
+    const query = {
+      query: body.query || "",
+      mode: body.mode || "keyword",
+      filters: body.filters || {},
+      limit: body.limit ? Number(body.limit) : void 0,
+      offset: body.offset ? Number(body.offset) : void 0
+    };
+    if (query.filters?.dateRange) {
+      if (typeof query.filters.dateRange.start === "string") {
+        query.filters.dateRange.start = new Date(query.filters.dateRange.start);
+      }
+      if (typeof query.filters.dateRange.end === "string") {
+        query.filters.dateRange.end = new Date(query.filters.dateRange.end);
+      }
+    }
+    const results = await service.search(query);
+    return c.json({
+      success: true,
+      data: results
+    });
+  } catch (error) {
+    console.error("Search error:", error);
+    return c.json(
+      {
+        success: false,
+        error: "Search failed",
+        message: error instanceof Error ? error.message : String(error)
+      },
+      500
+    );
+  }
+});
+apiRoutes.get("/suggest", async (c) => {
+  try {
+    const db = c.env.DB;
+    const ai = c.env.AI;
+    const vectorize = c.env.VECTORIZE_INDEX;
+    const service = new AISearchService(db, ai, vectorize);
+    const query = c.req.query("q") || "";
+    if (!query || query.length < 2) {
+      return c.json({ success: true, data: [] });
+    }
+    const suggestions = await service.getSearchSuggestions(query);
+    return c.json({
+      success: true,
+      data: suggestions
+    });
+  } catch (error) {
+    console.error("Suggestions error:", error);
+    return c.json(
+      {
+        success: false,
+        error: "Failed to get suggestions"
+      },
+      500
+    );
+  }
+});
+apiRoutes.get("/analytics", async (c) => {
+  try {
+    const db = c.env.DB;
+    const ai = c.env.AI;
+    const vectorize = c.env.VECTORIZE_INDEX;
+    const service = new AISearchService(db, ai, vectorize);
+    const analytics = await service.getSearchAnalytics();
+    return c.json({
+      success: true,
+      data: analytics
+    });
+  } catch (error) {
+    console.error("Analytics error:", error);
+    return c.json(
+      {
+        success: false,
+        error: "Failed to get analytics"
+      },
+      500
+    );
+  }
+});
+var api_default2 = apiRoutes;
+
+// src/plugins/core-plugins/ai-search-plugin/manifest.json
+var manifest_default = {
+  name: "AI Search",
+  description: "Advanced search with Cloudflare AI Search. Full-text search, semantic search, and advanced filtering across all content collections.",
+  version: "1.0.0",
+  author: "SonicJS"};
+
+// src/plugins/core-plugins/ai-search-plugin/index.ts
+var aiSearchPlugin = new PluginBuilder({
+  name: manifest_default.name,
+  version: manifest_default.version,
+  description: manifest_default.description,
+  author: { name: manifest_default.author }
+}).metadata({
+  description: manifest_default.description,
+  author: { name: manifest_default.author }
+}).addService("aiSearch", AISearchService).addService("indexManager", IndexManager).addRoute("/admin/plugins/ai-search", admin_default).addRoute("/api/search", api_default2).build();
+var magicLinkRequestSchema = z.object({
+  email: z.string().email("Valid email is required")
+});
+function createMagicLinkAuthPlugin() {
+  const magicLinkRoutes = new Hono();
+  magicLinkRoutes.post("/request", async (c) => {
+    try {
+      const body = await c.req.json();
+      const validation = magicLinkRequestSchema.safeParse(body);
+      if (!validation.success) {
+        return c.json({
+          error: "Validation failed",
+          details: validation.error.issues
+        }, 400);
+      }
+      const { email } = validation.data;
+      const normalizedEmail = email.toLowerCase();
+      const db = c.env.DB;
+      const oneHourAgo = Date.now() - 60 * 60 * 1e3;
+      const recentLinks = await db.prepare(`
+        SELECT COUNT(*) as count
+        FROM magic_links
+        WHERE user_email = ? AND created_at > ?
+      `).bind(normalizedEmail, oneHourAgo).first();
+      const rateLimitPerHour = 5;
+      if (recentLinks && recentLinks.count >= rateLimitPerHour) {
+        return c.json({
+          error: "Too many requests. Please try again later."
+        }, 429);
+      }
+      const user = await db.prepare(`
+        SELECT id, email, role, is_active
+        FROM users
+        WHERE email = ?
+      `).bind(normalizedEmail).first();
+      const allowNewUsers = false;
+      if (!user && !allowNewUsers) {
+        return c.json({
+          message: "If an account exists for this email, you will receive a magic link shortly."
+        });
+      }
+      if (user && !user.is_active) {
+        return c.json({
+          error: "This account has been deactivated."
+        }, 403);
+      }
+      const token = crypto.randomUUID() + "-" + crypto.randomUUID();
+      const tokenId = crypto.randomUUID();
+      const linkExpiryMinutes = 15;
+      const expiresAt = Date.now() + linkExpiryMinutes * 60 * 1e3;
+      await db.prepare(`
+        INSERT INTO magic_links (
+          id, user_email, token, expires_at, used, created_at, ip_address, user_agent
+        ) VALUES (?, ?, ?, ?, 0, ?, ?, ?)
+      `).bind(
+        tokenId,
+        normalizedEmail,
+        token,
+        expiresAt,
+        Date.now(),
+        c.req.header("cf-connecting-ip") || c.req.header("x-forwarded-for") || "unknown",
+        c.req.header("user-agent") || "unknown"
+      ).run();
+      const baseUrl = new URL(c.req.url).origin;
+      const magicLink = `${baseUrl}/auth/magic-link/verify?token=${token}`;
+      try {
+        const emailPlugin2 = c.env.plugins?.get("email");
+        if (emailPlugin2 && emailPlugin2.sendEmail) {
+          await emailPlugin2.sendEmail({
+            to: normalizedEmail,
+            subject: "Your Magic Link to Sign In",
+            html: renderMagicLinkEmail(magicLink, linkExpiryMinutes)
+          });
+        } else {
+          console.error("Email plugin not available");
+          console.log(`Magic link for ${normalizedEmail}: ${magicLink}`);
+        }
+      } catch (error) {
+        console.error("Failed to send magic link email:", error);
+        return c.json({
+          error: "Failed to send email. Please try again later."
+        }, 500);
+      }
+      return c.json({
+        message: "If an account exists for this email, you will receive a magic link shortly.",
+        // For development only - remove in production
+        ...c.env.ENVIRONMENT === "development" && { dev_link: magicLink }
+      });
+    } catch (error) {
+      console.error("Magic link request error:", error);
+      return c.json({ error: "Failed to process request" }, 500);
+    }
+  });
+  magicLinkRoutes.get("/verify", async (c) => {
+    try {
+      const token = c.req.query("token");
+      if (!token) {
+        return c.redirect("/auth/login?error=Invalid magic link");
+      }
+      const db = c.env.DB;
+      const magicLink = await db.prepare(`
+        SELECT * FROM magic_links
+        WHERE token = ? AND used = 0
+      `).bind(token).first();
+      if (!magicLink) {
+        return c.redirect("/auth/login?error=Invalid or expired magic link");
+      }
+      if (magicLink.expires_at < Date.now()) {
+        return c.redirect("/auth/login?error=This magic link has expired");
+      }
+      let user = await db.prepare(`
+        SELECT * FROM users WHERE email = ? AND is_active = 1
+      `).bind(magicLink.user_email).first();
+      const allowNewUsers = false;
+      if (!user && allowNewUsers) {
+        const userId = crypto.randomUUID();
+        const username = magicLink.user_email.split("@")[0];
+        const now = Date.now();
+        await db.prepare(`
+          INSERT INTO users (
+            id, email, username, first_name, last_name,
+            password_hash, role, is_active, created_at, updated_at
+          ) VALUES (?, ?, ?, ?, ?, NULL, 'viewer', 1, ?, ?)
+        `).bind(
+          userId,
+          magicLink.user_email,
+          username,
+          username,
+          "",
+          now,
+          now
+        ).run();
+        user = {
+          id: userId,
+          email: magicLink.user_email,
+          username,
+          role: "viewer"
+        };
+      } else if (!user) {
+        return c.redirect("/auth/login?error=No account found for this email");
+      }
+      await db.prepare(`
+        UPDATE magic_links
+        SET used = 1, used_at = ?
+        WHERE id = ?
+      `).bind(Date.now(), magicLink.id).run();
+      const jwtToken = await AuthManager.generateToken(
+        user.id,
+        user.email,
+        user.role
+      );
+      AuthManager.setAuthCookie(c, jwtToken);
+      await db.prepare(`
+        UPDATE users SET last_login_at = ? WHERE id = ?
+      `).bind(Date.now(), user.id).run();
+      return c.redirect("/admin/dashboard?message=Successfully signed in");
+    } catch (error) {
+      console.error("Magic link verification error:", error);
+      return c.redirect("/auth/login?error=Authentication failed");
+    }
+  });
+  return {
+    name: "magic-link-auth",
+    version: "1.0.0",
+    description: "Passwordless authentication via email magic links",
+    author: {
+      name: "SonicJS Team",
+      email: "team@sonicjs.com"
+    },
+    dependencies: ["email"],
+    routes: [{
+      path: "/auth/magic-link",
+      handler: magicLinkRoutes,
+      description: "Magic link authentication endpoints",
+      requiresAuth: false
+    }],
+    async install(context) {
+      console.log("Installing magic-link-auth plugin...");
+    },
+    async activate(context) {
+      console.log("Magic link authentication activated");
+      console.log("Users can now sign in via /auth/magic-link/request");
+    },
+    async deactivate(context) {
+      console.log("Magic link authentication deactivated");
+    },
+    async uninstall(context) {
+      console.log("Uninstalling magic-link-auth plugin...");
+    }
+  };
+}
+function renderMagicLinkEmail(magicLink, expiryMinutes) {
+  return `
+    <!DOCTYPE html>
+    <html>
+    <head>
+      <meta charset="utf-8">
+      <meta name="viewport" content="width=device-width, initial-scale=1.0">
+      <title>Your Magic Link</title>
+      <style>
+        body {
+          font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, 'Helvetica Neue', Arial, sans-serif;
+          line-height: 1.6;
+          color: #333;
+          max-width: 600px;
+          margin: 0 auto;
+          padding: 20px;
+        }
+        .container {
+          background: #ffffff;
+          border-radius: 8px;
+          padding: 40px;
+          box-shadow: 0 2px 4px rgba(0,0,0,0.1);
+        }
+        .header {
+          text-align: center;
+          margin-bottom: 30px;
+        }
+        .header h1 {
+          color: #0ea5e9;
+          margin: 0;
+          font-size: 24px;
+        }
+        .content {
+          margin-bottom: 30px;
+        }
+        .button {
+          display: inline-block;
+          padding: 14px 32px;
+          background: linear-gradient(135deg, #0ea5e9 0%, #06b6d4 100%);
+          color: #ffffff !important;
+          text-decoration: none;
+          border-radius: 6px;
+          font-weight: 600;
+          text-align: center;
+          margin: 20px 0;
+        }
+        .button:hover {
+          opacity: 0.9;
+        }
+        .expiry {
+          color: #ef4444;
+          font-size: 14px;
+          margin-top: 20px;
+        }
+        .footer {
+          margin-top: 40px;
+          padding-top: 20px;
+          border-top: 1px solid #e5e7eb;
+          font-size: 12px;
+          color: #6b7280;
+          text-align: center;
+        }
+        .security-note {
+          background: #fef3c7;
+          border-left: 4px solid #f59e0b;
+          padding: 12px 16px;
+          margin-top: 20px;
+          border-radius: 4px;
+          font-size: 14px;
+        }
+      </style>
+    </head>
+    <body>
+      <div class="container">
+        <div class="header">
+          <h1>\u{1F517} Your Magic Link</h1>
+        </div>
+
+        <div class="content">
+          <p>Hello!</p>
+          <p>You requested a magic link to sign in to your account. Click the button below to continue:</p>
+
+          <div style="text-align: center;">
+            <a href="${magicLink}" class="button">Sign In</a>
+          </div>
+
+          <p class="expiry">\u23F0 This link expires in ${expiryMinutes} minutes</p>
+
+          <div class="security-note">
+            <strong>Security Notice:</strong> If you didn't request this link, you can safely ignore this email.
+            Someone may have entered your email address by mistake.
+          </div>
+        </div>
+
+        <div class="footer">
+          <p>This is an automated email from SonicJS.</p>
+          <p>For security, this link can only be used once.</p>
+        </div>
+      </div>
+    </body>
+    </html>
+  `;
+}
+createMagicLinkAuthPlugin();
+
+// src/plugins/cache/services/cache-config.ts
+var CACHE_CONFIGS = {
+  // Content (high read, low write)
+  content: {
+    ttl: 3600,
+    // 1 hour
+    kvEnabled: true,
+    memoryEnabled: true,
+    namespace: "content",
+    invalidateOn: ["content.update", "content.delete", "content.publish"],
+    version: "v1"
+  },
+  // User data (medium read, medium write)
+  user: {
+    ttl: 900,
+    // 15 minutes
+    kvEnabled: true,
+    memoryEnabled: true,
+    namespace: "user",
+    invalidateOn: ["user.update", "user.delete", "auth.login"],
+    version: "v1"
+  },
+  // Configuration (high read, very low write)
+  config: {
+    ttl: 7200,
+    // 2 hours
+    kvEnabled: true,
+    memoryEnabled: true,
+    namespace: "config",
+    invalidateOn: ["config.update", "plugin.activate", "plugin.deactivate"],
+    version: "v1"
+  },
+  // Media metadata (high read, low write)
+  media: {
+    ttl: 3600,
+    // 1 hour
+    kvEnabled: true,
+    memoryEnabled: true,
+    namespace: "media",
+    invalidateOn: ["media.upload", "media.delete", "media.update"],
+    version: "v1"
+  },
+  // API responses (very high read, low write)
+  api: {
+    ttl: 300,
+    // 5 minutes
+    kvEnabled: true,
+    memoryEnabled: true,
+    namespace: "api",
+    invalidateOn: ["content.update", "content.publish"],
+    version: "v1"
+  },
+  // Session data (very high read, medium write)
+  session: {
+    ttl: 1800,
+    // 30 minutes
+    kvEnabled: false,
+    // Only in-memory for sessions
+    memoryEnabled: true,
+    namespace: "session",
+    invalidateOn: ["auth.logout"],
+    version: "v1"
+  },
+  // Plugin data
+  plugin: {
+    ttl: 3600,
+    // 1 hour
+    kvEnabled: true,
+    memoryEnabled: true,
+    namespace: "plugin",
+    invalidateOn: ["plugin.activate", "plugin.deactivate", "plugin.update"],
+    version: "v1"
+  },
+  // Collections/schema
+  collection: {
+    ttl: 7200,
+    // 2 hours
+    kvEnabled: true,
+    memoryEnabled: true,
+    namespace: "collection",
+    invalidateOn: ["collection.update", "collection.delete"],
+    version: "v1"
+  }
+};
+function getCacheConfig(namespace) {
+  return CACHE_CONFIGS[namespace] || {
+    ttl: 3600,
+    kvEnabled: true,
+    memoryEnabled: true,
+    namespace,
+    invalidateOn: [],
+    version: "v1"
+  };
+}
+function generateCacheKey(namespace, type, identifier, version) {
+  const v = version || getCacheConfig(namespace).version || "v1";
+  return `${namespace}:${type}:${identifier}:${v}`;
+}
+function parseCacheKey(key) {
+  const parts = key.split(":");
+  if (parts.length !== 4) {
+    return null;
+  }
+  return {
+    namespace: parts[0] || "",
+    type: parts[1] || "",
+    identifier: parts[2] || "",
+    version: parts[3] || ""
+  };
+}
+
+// src/plugins/cache/services/cache.ts
+var MemoryCache = class {
+  cache = /* @__PURE__ */ new Map();
+  maxSize = 50 * 1024 * 1024;
+  // 50MB
+  currentSize = 0;
+  /**
+   * Get item from memory cache
+   */
+  get(key) {
+    const entry = this.cache.get(key);
+    if (!entry) {
+      return null;
+    }
+    if (Date.now() > entry.expiresAt) {
+      this.delete(key);
+      return null;
+    }
+    return entry.data;
+  }
+  /**
+   * Set item in memory cache
+   */
+  set(key, value, ttl, version = "v1") {
+    const now = Date.now();
+    const entry = {
+      data: value,
+      timestamp: now,
+      expiresAt: now + ttl * 1e3,
+      version
+    };
+    const entrySize = JSON.stringify(entry).length * 2;
+    if (this.currentSize + entrySize > this.maxSize) {
+      this.evictLRU(entrySize);
+    }
+    if (this.cache.has(key)) {
+      this.delete(key);
+    }
+    this.cache.set(key, entry);
+    this.currentSize += entrySize;
+  }
+  /**
+   * Delete item from memory cache
+   */
+  delete(key) {
+    const entry = this.cache.get(key);
+    if (entry) {
+      const entrySize = JSON.stringify(entry).length * 2;
+      this.currentSize -= entrySize;
+      return this.cache.delete(key);
+    }
+    return false;
+  }
+  /**
+   * Clear all items from memory cache
+   */
+  clear() {
+    this.cache.clear();
+    this.currentSize = 0;
+  }
+  /**
+   * Get cache statistics
+   */
+  getStats() {
+    return {
+      size: this.currentSize,
+      count: this.cache.size
+    };
+  }
+  /**
+   * Evict least recently used items to make space
+   */
+  evictLRU(neededSpace) {
+    const entries = Array.from(this.cache.entries()).sort(
+      (a, b) => a[1].timestamp - b[1].timestamp
+    );
+    let freedSpace = 0;
+    for (const [key, entry] of entries) {
+      if (freedSpace >= neededSpace) break;
+      const entrySize = JSON.stringify(entry).length * 2;
+      this.delete(key);
+      freedSpace += entrySize;
+    }
+  }
+  /**
+   * Delete items matching a pattern
+   */
+  invalidatePattern(pattern) {
+    const regex = new RegExp(
+      "^" + pattern.replace(/\*/g, ".*").replace(/\?/g, ".") + "$"
+    );
+    let count = 0;
+    for (const key of this.cache.keys()) {
+      if (regex.test(key)) {
+        this.delete(key);
+        count++;
+      }
+    }
+    return count;
+  }
+};
+var CacheService = class {
+  memoryCache;
+  config;
+  stats;
+  kvNamespace;
+  constructor(config, kvNamespace) {
+    this.memoryCache = new MemoryCache();
+    this.config = config;
+    this.kvNamespace = kvNamespace;
+    this.stats = {
+      memoryHits: 0,
+      memoryMisses: 0,
+      kvHits: 0,
+      kvMisses: 0,
+      dbHits: 0,
+      totalRequests: 0,
+      hitRate: 0,
+      memorySize: 0,
+      entryCount: 0
+    };
+  }
+  /**
+   * Get value from cache (tries memory first, then KV)
+   */
+  async get(key) {
+    this.stats.totalRequests++;
+    if (this.config.memoryEnabled) {
+      const memoryValue = this.memoryCache.get(key);
+      if (memoryValue !== null) {
+        this.stats.memoryHits++;
+        this.updateHitRate();
+        return memoryValue;
+      }
+      this.stats.memoryMisses++;
+    }
+    if (this.config.kvEnabled && this.kvNamespace) {
+      try {
+        const kvValue = await this.kvNamespace.get(key, "json");
+        if (kvValue !== null) {
+          this.stats.kvHits++;
+          if (this.config.memoryEnabled) {
+            this.memoryCache.set(key, kvValue, this.config.ttl, this.config.version);
+          }
+          this.updateHitRate();
+          return kvValue;
+        }
+        this.stats.kvMisses++;
+      } catch (error) {
+        console.error("KV cache read error:", error);
+        this.stats.kvMisses++;
+      }
+    }
+    this.updateHitRate();
+    return null;
+  }
+  /**
+   * Get value from cache with source information
+   */
+  async getWithSource(key) {
+    this.stats.totalRequests++;
+    if (this.config.memoryEnabled) {
+      const memoryValue = this.memoryCache.get(key);
+      if (memoryValue !== null) {
+        this.stats.memoryHits++;
+        this.updateHitRate();
+        const entry = await this.getEntry(key);
+        return {
+          data: memoryValue,
+          source: "memory",
+          hit: true,
+          timestamp: entry?.timestamp,
+          ttl: entry?.ttl
+        };
+      }
+      this.stats.memoryMisses++;
+    }
+    if (this.config.kvEnabled && this.kvNamespace) {
+      try {
+        const kvValue = await this.kvNamespace.get(key, "json");
+        if (kvValue !== null) {
+          this.stats.kvHits++;
+          if (this.config.memoryEnabled) {
+            this.memoryCache.set(key, kvValue, this.config.ttl, this.config.version);
+          }
+          this.updateHitRate();
+          return {
+            data: kvValue,
+            source: "kv",
+            hit: true
+          };
+        }
+        this.stats.kvMisses++;
+      } catch (error) {
+        console.error("KV cache read error:", error);
+        this.stats.kvMisses++;
+      }
+    }
+    this.updateHitRate();
+    return {
+      data: null,
+      source: "miss",
+      hit: false
+    };
+  }
+  /**
+   * Set value in cache (stores in both memory and KV)
+   */
+  async set(key, value, customConfig) {
+    const config = { ...this.config, ...customConfig };
+    if (config.memoryEnabled) {
+      this.memoryCache.set(key, value, config.ttl, config.version);
+    }
+    if (config.kvEnabled && this.kvNamespace) {
+      try {
+        await this.kvNamespace.put(key, JSON.stringify(value), {
+          expirationTtl: config.ttl
+        });
+      } catch (error) {
+        console.error("KV cache write error:", error);
+      }
+    }
+  }
+  /**
+   * Delete value from cache (removes from both memory and KV)
+   */
+  async delete(key) {
+    if (this.config.memoryEnabled) {
+      this.memoryCache.delete(key);
+    }
+    if (this.config.kvEnabled && this.kvNamespace) {
+      try {
+        await this.kvNamespace.delete(key);
+      } catch (error) {
+        console.error("KV cache delete error:", error);
+      }
+    }
+  }
+  /**
+   * Clear all cache entries for this namespace
+   */
+  async clear() {
+    if (this.config.memoryEnabled) {
+      this.memoryCache.clear();
+    }
+    this.stats = {
+      memoryHits: 0,
+      memoryMisses: 0,
+      kvHits: 0,
+      kvMisses: 0,
+      dbHits: 0,
+      totalRequests: 0,
+      hitRate: 0,
+      memorySize: 0,
+      entryCount: 0
+    };
+  }
+  /**
+   * Invalidate cache entries matching a pattern
+   */
+  async invalidate(pattern) {
+    let count = 0;
+    if (this.config.memoryEnabled) {
+      count += this.memoryCache.invalidatePattern(pattern);
+    }
+    if (this.config.kvEnabled && this.kvNamespace) {
+      try {
+        const regex = new RegExp(
+          "^" + pattern.replace(/\*/g, ".*").replace(/\?/g, ".") + "$"
+        );
+        const prefix = this.config.namespace + ":";
+        const list = await this.kvNamespace.list({ prefix });
+        for (const key of list.keys) {
+          if (regex.test(key.name)) {
+            await this.kvNamespace.delete(key.name);
+            count++;
+          }
+        }
+      } catch (error) {
+        console.error("KV cache invalidation error:", error);
+      }
+    }
+    return count;
+  }
+  /**
+   * Invalidate cache entries matching a pattern (alias for invalidate)
+   */
+  async invalidatePattern(pattern) {
+    return this.invalidate(pattern);
+  }
+  /**
+   * Get cache statistics
+   */
+  getStats() {
+    const memStats = this.memoryCache.getStats();
+    return {
+      ...this.stats,
+      memorySize: memStats.size,
+      entryCount: memStats.count
+    };
+  }
+  /**
+   * Update hit rate calculation
+   */
+  updateHitRate() {
+    const totalHits = this.stats.memoryHits + this.stats.kvHits + this.stats.dbHits;
+    this.stats.hitRate = this.stats.totalRequests > 0 ? totalHits / this.stats.totalRequests * 100 : 0;
+  }
+  /**
+   * Generate a cache key using the configured namespace
+   */
+  generateKey(type, identifier) {
+    return generateCacheKey(
+      this.config.namespace,
+      type,
+      identifier,
+      this.config.version
+    );
+  }
+  /**
+   * Warm cache with multiple entries
+   */
+  async warmCache(entries) {
+    for (const entry of entries) {
+      await this.set(entry.key, entry.value);
+    }
+  }
+  /**
+   * Check if a key exists in cache
+   */
+  async has(key) {
+    const value = await this.get(key);
+    return value !== null;
+  }
+  /**
+   * Get multiple values at once
+   */
+  async getMany(keys) {
+    const results = /* @__PURE__ */ new Map();
+    for (const key of keys) {
+      const value = await this.get(key);
+      if (value !== null) {
+        results.set(key, value);
+      }
+    }
+    return results;
+  }
+  /**
+   * Set multiple values at once
+   */
+  async setMany(entries, customConfig) {
+    for (const entry of entries) {
+      await this.set(entry.key, entry.value, customConfig);
+    }
+  }
+  /**
+   * Delete multiple keys at once
+   */
+  async deleteMany(keys) {
+    for (const key of keys) {
+      await this.delete(key);
+    }
+  }
+  /**
+   * Get or set pattern - fetch from cache or compute if not found
+   */
+  async getOrSet(key, fetcher, customConfig) {
+    const cached = await this.get(key);
+    if (cached !== null) {
+      return cached;
+    }
+    const value = await fetcher();
+    await this.set(key, value, customConfig);
+    return value;
+  }
+  /**
+   * List all cache keys with metadata
+   */
+  async listKeys() {
+    const keys = [];
+    if (this.config.memoryEnabled) {
+      const cache = this.memoryCache.cache;
+      for (const [key, entry] of cache.entries()) {
+        const size = JSON.stringify(entry).length * 2;
+        const age = Date.now() - entry.timestamp;
+        keys.push({
+          key,
+          size,
+          expiresAt: entry.expiresAt,
+          age
+        });
+      }
+    }
+    return keys.sort((a, b) => a.age - b.age);
+  }
+  /**
+   * Get cache entry with full metadata
+   */
+  async getEntry(key) {
+    if (!this.config.memoryEnabled) {
+      return null;
+    }
+    const cache = this.memoryCache.cache;
+    const entry = cache.get(key);
+    if (!entry) {
+      return null;
+    }
+    if (Date.now() > entry.expiresAt) {
+      await this.delete(key);
+      return null;
+    }
+    const size = JSON.stringify(entry).length * 2;
+    const ttl = Math.max(0, entry.expiresAt - Date.now()) / 1e3;
+    return {
+      data: entry.data,
+      timestamp: entry.timestamp,
+      expiresAt: entry.expiresAt,
+      ttl,
+      size
+    };
+  }
+};
+var cacheInstances = /* @__PURE__ */ new Map();
+var globalKVNamespace;
+function getCacheService(config, kvNamespace) {
+  const key = config.namespace;
+  if (!cacheInstances.has(key)) {
+    const kv = globalKVNamespace;
+    cacheInstances.set(key, new CacheService(config, kv));
+  }
+  return cacheInstances.get(key);
+}
+async function clearAllCaches() {
+  for (const cache of cacheInstances.values()) {
+    await cache.clear();
+  }
+}
+function getAllCacheStats() {
+  const stats = {};
+  for (const [namespace, cache] of cacheInstances.entries()) {
+    stats[namespace] = cache.getStats();
+  }
+  return stats;
+}
+
+// src/plugins/cache/services/event-bus.ts
+var EventBus = class {
+  subscriptions = /* @__PURE__ */ new Map();
+  eventLog = [];
+  maxLogSize = 100;
+  /**
+   * Subscribe to an event
+   */
+  on(event, handler) {
+    if (!this.subscriptions.has(event)) {
+      this.subscriptions.set(event, []);
+    }
+    this.subscriptions.get(event).push(handler);
+    return () => {
+      const handlers = this.subscriptions.get(event);
+      if (handlers) {
+        const index = handlers.indexOf(handler);
+        if (index > -1) {
+          handlers.splice(index, 1);
+        }
+      }
+    };
+  }
+  /**
+   * Emit an event to all subscribers
+   */
+  async emit(event, data) {
+    this.logEvent(event, data);
+    const handlers = this.subscriptions.get(event) || [];
+    await Promise.all(
+      handlers.map(async (handler) => {
+        try {
+          await handler(data);
+        } catch (error) {
+          console.error(`Error in event handler for ${event}:`, error);
+        }
+      })
+    );
+    const wildcardHandlers = this.subscriptions.get("*") || [];
+    await Promise.all(
+      wildcardHandlers.map(async (handler) => {
+        try {
+          await handler({ event, data });
+        } catch (error) {
+          console.error(`Error in wildcard event handler for ${event}:`, error);
+        }
+      })
+    );
+  }
+  /**
+   * Remove all subscribers for an event
+   */
+  off(event) {
+    this.subscriptions.delete(event);
+  }
+  /**
+   * Get all registered events
+   */
+  getEvents() {
+    return Array.from(this.subscriptions.keys());
+  }
+  /**
+   * Get subscriber count for an event
+   */
+  getSubscriberCount(event) {
+    return this.subscriptions.get(event)?.length || 0;
+  }
+  /**
+   * Log an event for debugging
+   */
+  logEvent(event, data) {
+    this.eventLog.push({
+      event,
+      timestamp: Date.now(),
+      data
+    });
+    if (this.eventLog.length > this.maxLogSize) {
+      this.eventLog.shift();
+    }
+  }
+  /**
+   * Get recent event log
+   */
+  getEventLog(limit = 50) {
+    return this.eventLog.slice(-limit);
+  }
+  /**
+   * Clear event log
+   */
+  clearEventLog() {
+    this.eventLog = [];
+  }
+  /**
+   * Get statistics
+   */
+  getStats() {
+    const eventCounts = {};
+    for (const log of this.eventLog) {
+      eventCounts[log.event] = (eventCounts[log.event] || 0) + 1;
+    }
+    return {
+      totalEvents: this.eventLog.length,
+      totalSubscriptions: this.subscriptions.size,
+      eventCounts
+    };
+  }
+};
+var globalEventBus = null;
+function getEventBus() {
+  if (!globalEventBus) {
+    globalEventBus = new EventBus();
+  }
+  return globalEventBus;
+}
+function onEvent(event, handler) {
+  const bus = getEventBus();
+  return bus.on(event, handler);
+}
+
+// src/plugins/cache/services/cache-invalidation.ts
+function setupCacheInvalidation() {
+  getEventBus();
+  setupContentInvalidation();
+  setupUserInvalidation();
+  setupConfigInvalidation();
+  setupMediaInvalidation();
+  setupAPIInvalidation();
+  setupCollectionInvalidation();
+  console.log("Cache invalidation listeners registered");
+}
+function setupContentInvalidation() {
+  const config = CACHE_CONFIGS.content;
+  if (!config) return;
+  const contentCache = getCacheService(config);
+  onEvent("content.create", async (_data) => {
+    await contentCache.invalidate("content:*");
+    console.log("Cache invalidated: content.create");
+  });
+  onEvent("content.update", async (data) => {
+    if (data?.id) {
+      await contentCache.delete(contentCache.generateKey("item", data.id));
+    }
+    await contentCache.invalidate("content:list:*");
+    console.log("Cache invalidated: content.update", data?.id);
+  });
+  onEvent("content.delete", async (data) => {
+    if (data?.id) {
+      await contentCache.delete(contentCache.generateKey("item", data.id));
+    }
+    await contentCache.invalidate("content:*");
+    console.log("Cache invalidated: content.delete", data?.id);
+  });
+  onEvent("content.publish", async (_data) => {
+    await contentCache.invalidate("content:*");
+    console.log("Cache invalidated: content.publish");
+  });
+}
+function setupUserInvalidation() {
+  const config = CACHE_CONFIGS.user;
+  if (!config) return;
+  const userCache = getCacheService(config);
+  onEvent("user.update", async (data) => {
+    if (data?.id) {
+      await userCache.delete(userCache.generateKey("id", data.id));
+    }
+    if (data?.email) {
+      await userCache.delete(userCache.generateKey("email", data.email));
+    }
+    console.log("Cache invalidated: user.update", data?.id);
+  });
+  onEvent("user.delete", async (data) => {
+    if (data?.id) {
+      await userCache.delete(userCache.generateKey("id", data.id));
+    }
+    if (data?.email) {
+      await userCache.delete(userCache.generateKey("email", data.email));
+    }
+    console.log("Cache invalidated: user.delete", data?.id);
+  });
+  onEvent("auth.login", async (data) => {
+    if (data?.userId) {
+      await userCache.delete(userCache.generateKey("id", data.userId));
+    }
+    console.log("Cache invalidated: auth.login", data?.userId);
+  });
+  onEvent("auth.logout", async (data) => {
+    const sessionConfig = CACHE_CONFIGS.session;
+    if (sessionConfig) {
+      const sessionCache = getCacheService(sessionConfig);
+      if (data?.sessionId) {
+        await sessionCache.delete(sessionCache.generateKey("session", data.sessionId));
+      }
+    }
+    console.log("Cache invalidated: auth.logout");
+  });
+}
+function setupConfigInvalidation() {
+  const configConfig = CACHE_CONFIGS.config;
+  if (!configConfig) return;
+  const configCache = getCacheService(configConfig);
+  onEvent("config.update", async (_data) => {
+    await configCache.invalidate("config:*");
+    console.log("Cache invalidated: config.update");
+  });
+  onEvent("plugin.activate", async (data) => {
+    await configCache.invalidate("config:*");
+    const pluginConfig = CACHE_CONFIGS.plugin;
+    if (pluginConfig) {
+      const pluginCache = getCacheService(pluginConfig);
+      await pluginCache.invalidate("plugin:*");
+    }
+    console.log("Cache invalidated: plugin.activate", data?.pluginId);
+  });
+  onEvent("plugin.deactivate", async (data) => {
+    await configCache.invalidate("config:*");
+    const pluginConfig = CACHE_CONFIGS.plugin;
+    if (pluginConfig) {
+      const pluginCache = getCacheService(pluginConfig);
+      await pluginCache.invalidate("plugin:*");
+    }
+    console.log("Cache invalidated: plugin.deactivate", data?.pluginId);
+  });
+  onEvent("plugin.update", async (data) => {
+    const pluginConfig = CACHE_CONFIGS.plugin;
+    if (!pluginConfig) return;
+    const pluginCache = getCacheService(pluginConfig);
+    await pluginCache.invalidate("plugin:*");
+    console.log("Cache invalidated: plugin.update", data?.pluginId);
+  });
+}
+function setupMediaInvalidation() {
+  const config = CACHE_CONFIGS.media;
+  if (!config) return;
+  const mediaCache = getCacheService(config);
+  onEvent("media.upload", async (_data) => {
+    await mediaCache.invalidate("media:*");
+    console.log("Cache invalidated: media.upload");
+  });
+  onEvent("media.delete", async (data) => {
+    if (data?.id) {
+      await mediaCache.delete(mediaCache.generateKey("item", data.id));
+    }
+    await mediaCache.invalidate("media:list:*");
+    console.log("Cache invalidated: media.delete", data?.id);
+  });
+  onEvent("media.update", async (data) => {
+    if (data?.id) {
+      await mediaCache.delete(mediaCache.generateKey("item", data.id));
+    }
+    await mediaCache.invalidate("media:list:*");
+    console.log("Cache invalidated: media.update", data?.id);
+  });
+}
+function setupAPIInvalidation() {
+  const config = CACHE_CONFIGS.api;
+  if (!config) return;
+  const apiCache = getCacheService(config);
+  onEvent("content.update", async (_data) => {
+    await apiCache.invalidate("api:*");
+    console.log("Cache invalidated: api (content.update)");
+  });
+  onEvent("content.publish", async (_data) => {
+    await apiCache.invalidate("api:*");
+    console.log("Cache invalidated: api (content.publish)");
+  });
+  onEvent("content.create", async (_data) => {
+    await apiCache.invalidate("api:*");
+    console.log("Cache invalidated: api (content.create)");
+  });
+  onEvent("content.delete", async (_data) => {
+    await apiCache.invalidate("api:*");
+    console.log("Cache invalidated: api (content.delete)");
+  });
+  onEvent("collection.update", async (_data) => {
+    await apiCache.invalidate("api:*");
+    console.log("Cache invalidated: api (collection.update)");
+  });
+}
+function setupCollectionInvalidation() {
+  const config = CACHE_CONFIGS.collection;
+  if (!config) return;
+  const collectionCache = getCacheService(config);
+  onEvent("collection.create", async (_data) => {
+    await collectionCache.invalidate("collection:*");
+    console.log("Cache invalidated: collection.create");
+  });
+  onEvent("collection.update", async (data) => {
+    if (data?.id) {
+      await collectionCache.delete(collectionCache.generateKey("item", data.id));
+    }
+    await collectionCache.invalidate("collection:*");
+    console.log("Cache invalidated: collection.update", data?.id);
+  });
+  onEvent("collection.delete", async (data) => {
+    await collectionCache.invalidate("collection:*");
+    console.log("Cache invalidated: collection.delete", data?.id);
+  });
+}
+function getCacheInvalidationStats() {
+  const eventBus = getEventBus();
+  return eventBus.getStats();
+}
+function getRecentInvalidations(limit = 50) {
+  const eventBus = getEventBus();
+  return eventBus.getEventLog(limit);
+}
+
+// src/plugins/cache/services/cache-warming.ts
+async function warmCommonCaches(db) {
+  let totalWarmed = 0;
+  let totalErrors = 0;
+  const details = [];
+  try {
+    const collectionCount = await warmCollections(db);
+    totalWarmed += collectionCount;
+    details.push({ namespace: "collection", count: collectionCount });
+    const contentCount = await warmRecentContent(db);
+    totalWarmed += contentCount;
+    details.push({ namespace: "content", count: contentCount });
+    const mediaCount = await warmRecentMedia(db);
+    totalWarmed += mediaCount;
+    details.push({ namespace: "media", count: mediaCount });
+  } catch (error) {
+    console.error("Error warming caches:", error);
+    totalErrors++;
+  }
+  return {
+    warmed: totalWarmed,
+    errors: totalErrors,
+    details
+  };
+}
+async function warmCollections(db) {
+  const config = CACHE_CONFIGS.collection;
+  if (!config) return 0;
+  const collectionCache = getCacheService(config);
+  let count = 0;
+  try {
+    const stmt = db.prepare("SELECT * FROM collections WHERE is_active = 1");
+    const { results } = await stmt.all();
+    for (const collection of results) {
+      const key = collectionCache.generateKey("item", collection.id);
+      await collectionCache.set(key, collection);
+      count++;
+    }
+    const listKey = collectionCache.generateKey("list", "all");
+    await collectionCache.set(listKey, results);
+    count++;
+  } catch (error) {
+    console.error("Error warming collections cache:", error);
+  }
+  return count;
+}
+async function warmRecentContent(db, limit = 50) {
+  const config = CACHE_CONFIGS.content;
+  if (!config) return 0;
+  const contentCache = getCacheService(config);
+  let count = 0;
+  try {
+    const stmt = db.prepare(`SELECT * FROM content ORDER BY created_at DESC LIMIT ${limit}`);
+    const { results } = await stmt.all();
+    for (const content2 of results) {
+      const key = contentCache.generateKey("item", content2.id);
+      await contentCache.set(key, content2);
+      count++;
+    }
+    const listKey = contentCache.generateKey("list", "recent");
+    await contentCache.set(listKey, results);
+    count++;
+  } catch (error) {
+    console.error("Error warming content cache:", error);
+  }
+  return count;
+}
+async function warmRecentMedia(db, limit = 50) {
+  const config = CACHE_CONFIGS.media;
+  if (!config) return 0;
+  const mediaCache = getCacheService(config);
+  let count = 0;
+  try {
+    const stmt = db.prepare(`SELECT * FROM media WHERE deleted_at IS NULL ORDER BY uploaded_at DESC LIMIT ${limit}`);
+    const { results } = await stmt.all();
+    for (const media2 of results) {
+      const key = mediaCache.generateKey("item", media2.id);
+      await mediaCache.set(key, media2);
+      count++;
+    }
+    const listKey = mediaCache.generateKey("list", "recent");
+    await mediaCache.set(listKey, results);
+    count++;
+  } catch (error) {
+    console.error("Error warming media cache:", error);
+  }
+  return count;
+}
+async function warmNamespace(namespace, entries) {
+  const config = CACHE_CONFIGS[namespace];
+  if (!config) {
+    throw new Error(`Unknown namespace: ${namespace}`);
+  }
+  const cache = getCacheService(config);
+  await cache.setMany(entries);
+  return entries.length;
+}
+
+// src/templates/pages/admin-cache.template.ts
+init_admin_layout_catalyst_template();
+function renderCacheDashboard(data) {
+  const pageContent = `
+    <div class="space-y-6">
+      <!-- Header -->
+      <div class="flex items-center justify-between">
+        <div>
+          <h1 class="text-2xl font-semibold text-zinc-950 dark:text-white">Cache System</h1>
+          <p class="mt-1 text-sm text-zinc-600 dark:text-zinc-400">
+            Monitor and manage cache performance across all namespaces
+          </p>
+        </div>
+        <div class="flex gap-3">
+          <button
+            onclick="refreshStats()"
+            class="inline-flex items-center gap-2 rounded-lg bg-white dark:bg-zinc-900 px-4 py-2 text-sm font-medium text-zinc-950 dark:text-white ring-1 ring-inset ring-zinc-950/10 dark:ring-white/10 hover:bg-zinc-50 dark:hover:bg-zinc-800"
+          >
+            <svg class="h-4 w-4" fill="none" stroke="currentColor" viewBox="0 0 24 24">
+              <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M4 4v5h.582m15.356 2A8.001 8.001 0 004.582 9m0 0H9m11 11v-5h-.581m0 0a8.003 8.003 0 01-15.357-2m15.357 2H15"/>
+            </svg>
+            Refresh
+          </button>
+          <button
+            onclick="clearAllCaches()"
+            class="inline-flex items-center gap-2 rounded-lg bg-red-600 dark:bg-red-500 px-4 py-2 text-sm font-medium text-white hover:bg-red-700 dark:hover:bg-red-600"
+          >
+            <svg class="h-4 w-4" fill="none" stroke="currentColor" viewBox="0 0 24 24">
+              <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M19 7l-.867 12.142A2 2 0 0116.138 21H7.862a2 2 0 01-1.995-1.858L5 7m5 4v6m4-6v6m1-10V4a1 1 0 00-1-1h-4a1 1 0 00-1 1v3M4 7h16"/>
+            </svg>
+            Clear All
+          </button>
         </div>
+      </div>
 
-        <div class="content">
-          <p>Hello!</p>
-          <p>You requested a magic link to sign in to your account. Click the button below to continue:</p>
+      <!-- Overall Stats Cards -->
+      <div class="grid grid-cols-1 gap-4 sm:grid-cols-2 lg:grid-cols-4">
+        ${renderStatCard("Total Requests", data.totals.requests.toLocaleString(), "lime", `
+          <svg class="h-5 w-5" fill="none" stroke="currentColor" viewBox="0 0 24 24">
+            <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M13 7h8m0 0v8m0-8l-8 8-4-4-6 6"/>
+          </svg>
+        `)}
 
-          <div style="text-align: center;">
-            <a href="${magicLink}" class="button">Sign In</a>
-          </div>
+        ${renderStatCard("Hit Rate", data.totals.hitRate + "%", "blue", `
+          <svg class="h-5 w-5" fill="none" stroke="currentColor" viewBox="0 0 24 24">
+            <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M9 12l2 2 4-4m6 2a9 9 0 11-18 0 9 9 0 0118 0z"/>
+          </svg>
+        `, parseFloat(data.totals.hitRate) > 70 ? "lime" : parseFloat(data.totals.hitRate) > 40 ? "amber" : "red")}
 
-          <p class="expiry">\u23F0 This link expires in ${expiryMinutes} minutes</p>
+        ${renderStatCard("Memory Usage", formatBytes(data.totals.memorySize), "purple", `
+          <svg class="h-5 w-5" fill="none" stroke="currentColor" viewBox="0 0 24 24">
+            <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M9 3v2m6-2v2M9 19v2m6-2v2M5 9H3m2 6H3m18-6h-2m2 6h-2M7 19h10a2 2 0 002-2V7a2 2 0 00-2-2H7a2 2 0 00-2 2v10a2 2 0 002 2zM9 9h6v6H9V9z"/>
+          </svg>
+        `)}
 
-          <div class="security-note">
-            <strong>Security Notice:</strong> If you didn't request this link, you can safely ignore this email.
-            Someone may have entered your email address by mistake.
+        ${renderStatCard("Cached Entries", data.totals.entryCount.toLocaleString(), "sky", `
+          <svg class="h-5 w-5" fill="none" stroke="currentColor" viewBox="0 0 24 24">
+            <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M7 21a4 4 0 01-4-4V5a2 2 0 012-2h4a2 2 0 012 2v12a4 4 0 01-4 4zm0 0h12a2 2 0 002-2v-4a2 2 0 00-2-2h-2.343M11 7.343l1.657-1.657a2 2 0 012.828 0l2.829 2.829a2 2 0 010 2.828l-8.486 8.485M7 17h.01"/>
+          </svg>
+        `)}
+      </div>
+
+      <!-- Namespace Statistics -->
+      <div class="overflow-hidden rounded-xl bg-white dark:bg-zinc-900 ring-1 ring-zinc-950/5 dark:ring-white/10">
+        <div class="px-6 py-4 border-b border-zinc-950/5 dark:border-white/10">
+          <h2 class="text-lg font-semibold text-zinc-950 dark:text-white">Cache Namespaces</h2>
+        </div>
+        <div class="overflow-x-auto">
+          <table class="min-w-full divide-y divide-zinc-950/5 dark:divide-white/10">
+            <thead class="bg-zinc-50 dark:bg-zinc-800/50">
+              <tr>
+                <th class="px-6 py-3 text-left text-xs font-medium text-zinc-500 dark:text-zinc-400 uppercase tracking-wider">
+                  Namespace
+                </th>
+                <th class="px-6 py-3 text-left text-xs font-medium text-zinc-500 dark:text-zinc-400 uppercase tracking-wider">
+                  Requests
+                </th>
+                <th class="px-6 py-3 text-left text-xs font-medium text-zinc-500 dark:text-zinc-400 uppercase tracking-wider">
+                  Hit Rate
+                </th>
+                <th class="px-6 py-3 text-left text-xs font-medium text-zinc-500 dark:text-zinc-400 uppercase tracking-wider">
+                  Memory Hits
+                </th>
+                <th class="px-6 py-3 text-left text-xs font-medium text-zinc-500 dark:text-zinc-400 uppercase tracking-wider">
+                  KV Hits
+                </th>
+                <th class="px-6 py-3 text-left text-xs font-medium text-zinc-500 dark:text-zinc-400 uppercase tracking-wider">
+                  Entries
+                </th>
+                <th class="px-6 py-3 text-left text-xs font-medium text-zinc-500 dark:text-zinc-400 uppercase tracking-wider">
+                  Size
+                </th>
+                <th class="px-6 py-3 text-right text-xs font-medium text-zinc-500 dark:text-zinc-400 uppercase tracking-wider">
+                  Actions
+                </th>
+              </tr>
+            </thead>
+            <tbody class="divide-y divide-zinc-950/5 dark:divide-white/10">
+              ${data.namespaces.map((namespace) => {
+    const stat = data.stats[namespace];
+    if (!stat) return "";
+    return renderNamespaceRow(namespace, stat);
+  }).join("")}
+            </tbody>
+          </table>
+        </div>
+      </div>
+
+      <!-- Performance Chart Placeholder -->
+      <div class="overflow-hidden rounded-xl bg-white dark:bg-zinc-900 ring-1 ring-zinc-950/5 dark:ring-white/10">
+        <div class="px-6 py-4 border-b border-zinc-950/5 dark:border-white/10">
+          <h2 class="text-lg font-semibold text-zinc-950 dark:text-white">Performance Overview</h2>
+        </div>
+        <div class="p-6">
+          <div class="grid grid-cols-1 md:grid-cols-2 gap-6">
+            ${renderPerformanceMetric("Memory Cache", data.totals.hits, data.totals.misses)}
+            ${renderHealthStatus(parseFloat(data.totals.hitRate))}
           </div>
         </div>
+      </div>
+    </div>
 
-        <div class="footer">
-          <p>This is an automated email from SonicJS.</p>
-          <p>For security, this link can only be used once.</p>
+    <script>
+      async function refreshStats() {
+        window.location.reload()
+      }
+
+      async function clearAllCaches() {
+        showConfirmDialog('clear-all-cache-confirm')
+      }
+
+      async function performClearAllCaches() {
+        try {
+          const response = await fetch('/admin/cache/clear', {
+            method: 'POST'
+          })
+
+          const result = await response.json()
+          if (result.success) {
+            alert('All caches cleared successfully')
+            window.location.reload()
+          } else {
+            alert('Error clearing caches: ' + result.error)
+          }
+        } catch (error) {
+          alert('Error clearing caches: ' + error.message)
+        }
+      }
+
+      let namespaceToDelete = null
+
+      async function clearNamespaceCache(namespace) {
+        namespaceToDelete = namespace
+        showConfirmDialog('clear-namespace-cache-confirm')
+      }
+
+      async function performClearNamespaceCache() {
+        if (!namespaceToDelete) return
+
+        try {
+          const response = await fetch(\`/admin/cache/clear/\${namespaceToDelete}\`, {
+            method: 'POST'
+          })
+
+          const result = await response.json()
+          if (result.success) {
+            alert('Cache cleared successfully')
+            window.location.reload()
+          } else {
+            alert('Error clearing cache: ' + result.error)
+          }
+        } catch (error) {
+          alert('Error clearing cache: ' + error.message)
+        } finally {
+          namespaceToDelete = null
+        }
+      }
+    </script>
+
+    <!-- Confirmation Dialogs -->
+    ${renderConfirmationDialog({
+    id: "clear-all-cache-confirm",
+    title: "Clear All Cache",
+    message: "Are you sure you want to clear all cache entries? This cannot be undone.",
+    confirmText: "Clear All",
+    cancelText: "Cancel",
+    iconColor: "yellow",
+    confirmClass: "bg-yellow-500 hover:bg-yellow-400",
+    onConfirm: "performClearAllCaches()"
+  })}
+
+    ${renderConfirmationDialog({
+    id: "clear-namespace-cache-confirm",
+    title: "Clear Namespace Cache",
+    message: "Clear cache for this namespace?",
+    confirmText: "Clear",
+    cancelText: "Cancel",
+    iconColor: "yellow",
+    confirmClass: "bg-yellow-500 hover:bg-yellow-400",
+    onConfirm: "performClearNamespaceCache()"
+  })}
+
+    ${getConfirmationDialogScript()}
+  `;
+  const layoutData = {
+    title: "Cache System",
+    pageTitle: "Cache System",
+    currentPath: "/admin/cache",
+    user: data.user,
+    version: data.version,
+    content: pageContent
+  };
+  return renderAdminLayoutCatalyst(layoutData);
+}
+function renderStatCard(label, value, color, icon, colorOverride) {
+  const finalColor = colorOverride || color;
+  const colorClasses = {
+    lime: "bg-lime-50 dark:bg-lime-500/10 text-lime-600 dark:text-lime-400 ring-lime-600/20 dark:ring-lime-500/20",
+    blue: "bg-blue-50 dark:bg-blue-500/10 text-blue-600 dark:text-blue-400 ring-blue-600/20 dark:ring-blue-500/20",
+    purple: "bg-purple-50 dark:bg-purple-500/10 text-purple-600 dark:text-purple-400 ring-purple-600/20 dark:ring-purple-500/20",
+    sky: "bg-sky-50 dark:bg-sky-500/10 text-sky-600 dark:text-sky-400 ring-sky-600/20 dark:ring-sky-500/20",
+    amber: "bg-amber-50 dark:bg-amber-500/10 text-amber-600 dark:text-amber-400 ring-amber-600/20 dark:ring-amber-500/20",
+    red: "bg-red-50 dark:bg-red-500/10 text-red-600 dark:text-red-400 ring-red-600/20 dark:ring-red-500/20"
+  };
+  return `
+    <div class="overflow-hidden rounded-xl bg-white dark:bg-zinc-900 ring-1 ring-zinc-950/5 dark:ring-white/10">
+      <div class="p-6">
+        <div class="flex items-center justify-between">
+          <div class="flex items-center gap-3">
+            <div class="rounded-lg p-2 ring-1 ring-inset ${colorClasses[finalColor]}">
+              ${icon}
+            </div>
+            <div>
+              <p class="text-sm text-zinc-600 dark:text-zinc-400">${label}</p>
+              <p class="mt-1 text-2xl font-semibold text-zinc-950 dark:text-white">${value}</p>
+            </div>
+          </div>
         </div>
       </div>
-    </body>
-    </html>
+    </div>
   `;
 }
-createMagicLinkAuthPlugin();
+function renderNamespaceRow(namespace, stat) {
+  const hitRate = stat.hitRate.toFixed(1);
+  const hitRateColor = stat.hitRate > 70 ? "text-lime-600 dark:text-lime-400" : stat.hitRate > 40 ? "text-amber-600 dark:text-amber-400" : "text-red-600 dark:text-red-400";
+  return `
+    <tr class="hover:bg-zinc-50 dark:hover:bg-zinc-800/50">
+      <td class="px-6 py-4 whitespace-nowrap">
+        <span class="inline-flex items-center rounded-md px-2 py-1 text-xs font-medium bg-zinc-100 dark:bg-zinc-800 text-zinc-900 dark:text-zinc-100 ring-1 ring-inset ring-zinc-200 dark:ring-zinc-700">
+          ${namespace}
+        </span>
+      </td>
+      <td class="px-6 py-4 whitespace-nowrap text-sm text-zinc-900 dark:text-zinc-100">
+        ${stat.totalRequests.toLocaleString()}
+      </td>
+      <td class="px-6 py-4 whitespace-nowrap">
+        <span class="text-sm font-medium ${hitRateColor}">
+          ${hitRate}%
+        </span>
+      </td>
+      <td class="px-6 py-4 whitespace-nowrap text-sm text-zinc-600 dark:text-zinc-400">
+        ${stat.memoryHits.toLocaleString()}
+      </td>
+      <td class="px-6 py-4 whitespace-nowrap text-sm text-zinc-600 dark:text-zinc-400">
+        ${stat.kvHits.toLocaleString()}
+      </td>
+      <td class="px-6 py-4 whitespace-nowrap text-sm text-zinc-600 dark:text-zinc-400">
+        ${stat.entryCount.toLocaleString()}
+      </td>
+      <td class="px-6 py-4 whitespace-nowrap text-sm text-zinc-600 dark:text-zinc-400">
+        ${formatBytes(stat.memorySize)}
+      </td>
+      <td class="px-6 py-4 whitespace-nowrap text-right text-sm">
+        <button
+          onclick="clearNamespaceCache('${namespace}')"
+          class="text-red-600 dark:text-red-400 hover:text-red-700 dark:hover:text-red-300"
+        >
+          Clear
+        </button>
+      </td>
+    </tr>
+  `;
+}
+function renderPerformanceMetric(label, hits, misses) {
+  const total = hits + misses;
+  const hitPercentage = total > 0 ? hits / total * 100 : 0;
+  return `
+    <div>
+      <h3 class="text-sm font-medium text-zinc-900 dark:text-zinc-100 mb-3">${label}</h3>
+      <div class="space-y-2">
+        <div class="flex items-center justify-between text-sm">
+          <span class="text-zinc-600 dark:text-zinc-400">Hits</span>
+          <span class="font-medium text-zinc-900 dark:text-zinc-100">${hits.toLocaleString()}</span>
+        </div>
+        <div class="flex items-center justify-between text-sm">
+          <span class="text-zinc-600 dark:text-zinc-400">Misses</span>
+          <span class="font-medium text-zinc-900 dark:text-zinc-100">${misses.toLocaleString()}</span>
+        </div>
+        <div class="mt-3">
+          <div class="flex items-center justify-between text-sm mb-1">
+            <span class="text-zinc-600 dark:text-zinc-400">Hit Rate</span>
+            <span class="font-medium text-zinc-900 dark:text-zinc-100">${hitPercentage.toFixed(1)}%</span>
+          </div>
+          <div class="h-2 bg-zinc-200 dark:bg-zinc-700 rounded-full overflow-hidden">
+            <div class="h-full bg-lime-500 dark:bg-lime-400" style="width: ${hitPercentage}%"></div>
+          </div>
+        </div>
+      </div>
+    </div>
+  `;
+}
+function renderHealthStatus(hitRate) {
+  const status = hitRate > 70 ? "healthy" : hitRate > 40 ? "warning" : "critical";
+  const statusConfig = {
+    healthy: {
+      label: "Healthy",
+      color: "lime",
+      icon: `<svg class="h-6 w-6" fill="none" stroke="currentColor" viewBox="0 0 24 24">
+        <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M9 12l2 2 4-4m6 2a9 9 0 11-18 0 9 9 0 0118 0z"/>
+      </svg>`
+    },
+    warning: {
+      label: "Needs Attention",
+      color: "amber",
+      icon: `<svg class="h-6 w-6" fill="none" stroke="currentColor" viewBox="0 0 24 24">
+        <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M12 9v2m0 4h.01m-6.938 4h13.856c1.54 0 2.502-1.667 1.732-3L13.732 4c-.77-1.333-2.694-1.333-3.464 0L3.34 16c-.77 1.333.192 3 1.732 3z"/>
+      </svg>`
+    },
+    critical: {
+      label: "Critical",
+      color: "red",
+      icon: `<svg class="h-6 w-6" fill="none" stroke="currentColor" viewBox="0 0 24 24">
+        <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M12 8v4m0 4h.01M21 12a9 9 0 11-18 0 9 9 0 0118 0z"/>
+      </svg>`
+    }
+  };
+  const config = statusConfig[status];
+  const colorClasses = {
+    lime: "bg-lime-50 dark:bg-lime-500/10 text-lime-600 dark:text-lime-400 ring-lime-600/20 dark:ring-lime-500/20",
+    amber: "bg-amber-50 dark:bg-amber-500/10 text-amber-600 dark:text-amber-400 ring-amber-600/20 dark:ring-amber-500/20",
+    red: "bg-red-50 dark:bg-red-500/10 text-red-600 dark:text-red-400 ring-red-600/20 dark:ring-red-500/20"
+  };
+  return `
+    <div>
+      <h3 class="text-sm font-medium text-zinc-900 dark:text-zinc-100 mb-3">System Health</h3>
+      <div class="flex items-center gap-3 p-4 rounded-lg ring-1 ring-inset ${colorClasses[config.color]}">
+        ${config.icon}
+        <div>
+          <p class="text-sm font-medium">${config.label}</p>
+          <p class="text-xs mt-0.5 opacity-80">
+            ${status === "healthy" ? "Cache is performing well" : status === "warning" ? "Consider increasing cache TTL or capacity" : "Cache hit rate is too low"}
+          </p>
+        </div>
+      </div>
+    </div>
+  `;
+}
+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 `${(bytes / Math.pow(k, i)).toFixed(1)} ${sizes[i]}`;
+}
+
+// src/plugins/cache/routes.ts
+var app = new Hono();
+app.get("/", async (c) => {
+  const stats = getAllCacheStats();
+  const user = c.get("user");
+  let totalHits = 0;
+  let totalMisses = 0;
+  let totalSize = 0;
+  let totalEntries = 0;
+  Object.values(stats).forEach((stat) => {
+    totalHits += stat.memoryHits + stat.kvHits;
+    totalMisses += stat.memoryMisses + stat.kvMisses;
+    totalSize += stat.memorySize;
+    totalEntries += stat.entryCount;
+  });
+  const totalRequests = totalHits + totalMisses;
+  const overallHitRate = totalRequests > 0 ? totalHits / totalRequests * 100 : 0;
+  const dashboardData = {
+    stats,
+    totals: {
+      hits: totalHits,
+      misses: totalMisses,
+      requests: totalRequests,
+      hitRate: overallHitRate.toFixed(2),
+      memorySize: totalSize,
+      entryCount: totalEntries
+    },
+    namespaces: Object.keys(stats),
+    user: user ? {
+      name: user.email,
+      email: user.email,
+      role: user.role
+    } : void 0,
+    version: c.get("appVersion")
+  };
+  return c.html(renderCacheDashboard(dashboardData));
+});
+app.get("/stats", async (c) => {
+  const stats = getAllCacheStats();
+  return c.json({
+    success: true,
+    data: stats,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+  });
+});
+app.get("/stats/:namespace", async (c) => {
+  const namespace = c.req.param("namespace");
+  const config = CACHE_CONFIGS[namespace];
+  if (!config) {
+    return c.json({
+      success: false,
+      error: `Unknown namespace: ${namespace}`
+    }, 404);
+  }
+  const cache = getCacheService(config);
+  const stats = cache.getStats();
+  return c.json({
+    success: true,
+    data: {
+      namespace,
+      config,
+      stats
+    },
+    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+  });
+});
+app.post("/clear", async (c) => {
+  await clearAllCaches();
+  return c.json({
+    success: true,
+    message: "All cache entries cleared",
+    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+  });
+});
+app.post("/clear/:namespace", async (c) => {
+  const namespace = c.req.param("namespace");
+  const config = CACHE_CONFIGS[namespace];
+  if (!config) {
+    return c.json({
+      success: false,
+      error: `Unknown namespace: ${namespace}`
+    }, 404);
+  }
+  const cache = getCacheService(config);
+  await cache.clear();
+  return c.json({
+    success: true,
+    message: `Cache cleared for namespace: ${namespace}`,
+    namespace,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+  });
+});
+app.post("/invalidate", async (c) => {
+  const body = await c.req.json();
+  const { pattern, namespace } = body;
+  if (!pattern) {
+    return c.json({
+      success: false,
+      error: "Pattern is required"
+    }, 400);
+  }
+  let totalInvalidated = 0;
+  if (namespace) {
+    const config = CACHE_CONFIGS[namespace];
+    if (!config) {
+      return c.json({
+        success: false,
+        error: `Unknown namespace: ${namespace}`
+      }, 404);
+    }
+    const cache = getCacheService(config);
+    totalInvalidated = await cache.invalidate(pattern);
+  } else {
+    for (const config of Object.values(CACHE_CONFIGS)) {
+      const cache = getCacheService(config);
+      totalInvalidated += await cache.invalidate(pattern);
+    }
+  }
+  return c.json({
+    success: true,
+    invalidated: totalInvalidated,
+    pattern,
+    namespace: namespace || "all",
+    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+  });
+});
+app.get("/health", async (c) => {
+  const stats = getAllCacheStats();
+  const namespaces = Object.entries(stats);
+  const healthChecks = namespaces.map(([name, stat]) => {
+    const hitRate = stat.hitRate;
+    const memoryUsage = stat.memorySize / (50 * 1024 * 1024);
+    return {
+      namespace: name,
+      status: hitRate > 70 ? "healthy" : hitRate > 40 ? "warning" : "unhealthy",
+      hitRate,
+      memoryUsage: (memoryUsage * 100).toFixed(2) + "%",
+      entryCount: stat.entryCount
+    };
+  });
+  const overallStatus = healthChecks.every((h) => h.status === "healthy") ? "healthy" : healthChecks.some((h) => h.status === "unhealthy") ? "unhealthy" : "warning";
+  return c.json({
+    success: true,
+    data: {
+      status: overallStatus,
+      namespaces: healthChecks,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    }
+  });
+});
+app.get("/browser", async (c) => {
+  const namespace = c.req.query("namespace") || "all";
+  const search = c.req.query("search") || "";
+  const sortBy = c.req.query("sort") || "age";
+  const limit = parseInt(c.req.query("limit") || "100");
+  const entries = [];
+  const namespaces = namespace === "all" ? Object.keys(CACHE_CONFIGS) : [namespace];
+  for (const ns of namespaces) {
+    const config = CACHE_CONFIGS[ns];
+    if (!config) continue;
+    const cache = getCacheService(config);
+    const keys = await cache.listKeys();
+    for (const keyInfo of keys) {
+      if (search && !keyInfo.key.toLowerCase().includes(search.toLowerCase())) {
+        continue;
+      }
+      const parsed = parseCacheKey(keyInfo.key);
+      const ttl = Math.max(0, keyInfo.expiresAt - Date.now()) / 1e3;
+      entries.push({
+        namespace: ns,
+        key: keyInfo.key,
+        size: keyInfo.size,
+        age: keyInfo.age,
+        ttl,
+        expiresAt: keyInfo.expiresAt,
+        parsed
+      });
+    }
+  }
+  if (sortBy === "size") {
+    entries.sort((a, b) => b.size - a.size);
+  } else if (sortBy === "age") {
+    entries.sort((a, b) => a.age - b.age);
+  } else if (sortBy === "key") {
+    entries.sort((a, b) => a.key.localeCompare(b.key));
+  }
+  const limitedEntries = entries.slice(0, limit);
+  return c.json({
+    success: true,
+    data: {
+      entries: limitedEntries,
+      total: entries.length,
+      showing: limitedEntries.length,
+      namespace,
+      search,
+      sortBy
+    },
+    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+  });
+});
+app.get("/browser/:namespace/:key", async (c) => {
+  const namespace = c.req.param("namespace");
+  const key = decodeURIComponent(c.req.param("key"));
+  const config = CACHE_CONFIGS[namespace];
+  if (!config) {
+    return c.json({
+      success: false,
+      error: `Unknown namespace: ${namespace}`
+    }, 404);
+  }
+  const cache = getCacheService(config);
+  const entry = await cache.getEntry(key);
+  if (!entry) {
+    return c.json({
+      success: false,
+      error: "Cache entry not found or expired"
+    }, 404);
+  }
+  const parsed = parseCacheKey(key);
+  return c.json({
+    success: true,
+    data: {
+      key,
+      namespace,
+      parsed,
+      ...entry,
+      createdAt: new Date(entry.timestamp).toISOString(),
+      expiresAt: new Date(entry.expiresAt).toISOString()
+    },
+    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+  });
+});
+app.get("/analytics", async (c) => {
+  const stats = getAllCacheStats();
+  const invalidationStats = getCacheInvalidationStats();
+  const recentInvalidations = getRecentInvalidations(20);
+  let totalHits = 0;
+  let totalMisses = 0;
+  let totalSize = 0;
+  let totalEntries = 0;
+  const namespacesAnalytics = [];
+  for (const [namespace, stat] of Object.entries(stats)) {
+    totalHits += stat.memoryHits + stat.kvHits;
+    totalMisses += stat.memoryMisses + stat.kvMisses;
+    totalSize += stat.memorySize;
+    totalEntries += stat.entryCount;
+    const totalRequests2 = stat.memoryHits + stat.kvHits + stat.memoryMisses + stat.kvMisses;
+    const hitRate = totalRequests2 > 0 ? (stat.memoryHits + stat.kvHits) / totalRequests2 * 100 : 0;
+    const avgEntrySize = stat.entryCount > 0 ? stat.memorySize / stat.entryCount : 0;
+    namespacesAnalytics.push({
+      namespace,
+      hitRate: hitRate.toFixed(2),
+      totalRequests: totalRequests2,
+      memoryHitRate: totalRequests2 > 0 ? (stat.memoryHits / totalRequests2 * 100).toFixed(2) : "0",
+      kvHitRate: totalRequests2 > 0 ? (stat.kvHits / totalRequests2 * 100).toFixed(2) : "0",
+      avgEntrySize: Math.round(avgEntrySize),
+      totalSize: stat.memorySize,
+      entryCount: stat.entryCount,
+      efficiency: totalRequests2 > 0 ? ((stat.memoryHits + stat.kvHits) / (stat.memoryHits + stat.kvHits + stat.dbHits + 1)).toFixed(2) : "0"
+    });
+  }
+  namespacesAnalytics.sort((a, b) => parseFloat(b.hitRate) - parseFloat(a.hitRate));
+  const totalRequests = totalHits + totalMisses;
+  const overallHitRate = totalRequests > 0 ? totalHits / totalRequests * 100 : 0;
+  const dbQueriesAvoided = totalHits;
+  const timeSaved = dbQueriesAvoided * 48;
+  const estimatedCostSavings = dbQueriesAvoided / 1e6 * 0.5;
+  return c.json({
+    success: true,
+    data: {
+      overview: {
+        totalHits,
+        totalMisses,
+        totalRequests,
+        overallHitRate: overallHitRate.toFixed(2),
+        totalSize,
+        totalEntries,
+        avgEntrySize: totalEntries > 0 ? Math.round(totalSize / totalEntries) : 0
+      },
+      performance: {
+        dbQueriesAvoided,
+        timeSavedMs: timeSaved,
+        timeSavedMinutes: (timeSaved / 1e3 / 60).toFixed(2),
+        estimatedCostSavings: estimatedCostSavings.toFixed(4)
+      },
+      namespaces: namespacesAnalytics,
+      invalidation: {
+        ...invalidationStats,
+        recent: recentInvalidations
+      }
+    },
+    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+  });
+});
+app.get("/analytics/trends", async (c) => {
+  const stats = getAllCacheStats();
+  const dataPoint = {
+    timestamp: Date.now(),
+    stats: Object.entries(stats).map(([namespace, stat]) => ({
+      namespace,
+      hitRate: stat.hitRate,
+      entryCount: stat.entryCount,
+      memorySize: stat.memorySize,
+      totalRequests: stat.totalRequests
+    }))
+  };
+  return c.json({
+    success: true,
+    data: {
+      trends: [dataPoint],
+      note: "Historical trends require persistent storage. This returns current snapshot only."
+    },
+    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+  });
+});
+app.get("/analytics/top-keys", async (c) => {
+  c.req.query("namespace") || "all";
+  parseInt(c.req.query("limit") || "10");
+  return c.json({
+    success: true,
+    data: {
+      topKeys: [],
+      note: "Top keys tracking requires per-key hit counting. Feature not yet implemented."
+    },
+    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+  });
+});
+app.post("/warm", async (c) => {
+  try {
+    const db = c.env.DB;
+    const result = await warmCommonCaches(db);
+    return c.json({
+      success: true,
+      message: "Cache warming completed",
+      ...result,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    });
+  } catch (error) {
+    console.error("Cache warming error:", error);
+    return c.json({
+      success: false,
+      error: "Cache warming failed",
+      details: error instanceof Error ? error.message : "Unknown error"
+    }, 500);
+  }
+});
+app.post("/warm/:namespace", async (c) => {
+  try {
+    const namespace = c.req.param("namespace");
+    const body = await c.req.json();
+    const { entries } = body;
+    if (!entries || !Array.isArray(entries)) {
+      return c.json({
+        success: false,
+        error: "Entries array is required"
+      }, 400);
+    }
+    const count = await warmNamespace(namespace, entries);
+    return c.json({
+      success: true,
+      message: `Warmed ${count} entries in namespace: ${namespace}`,
+      namespace,
+      count,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    });
+  } catch (error) {
+    console.error("Namespace warming error:", error);
+    return c.json({
+      success: false,
+      error: "Namespace warming failed",
+      details: error instanceof Error ? error.message : "Unknown error"
+    }, 500);
+  }
+});
+var routes_default = app;
+
+// src/plugins/cache/index.ts
+var CachePlugin = class {
+  _context = null;
+  /**
+   * Get plugin routes
+   */
+  getRoutes() {
+    return routes_default;
+  }
+  /**
+   * Activate the cache plugin
+   */
+  async activate(context) {
+    this._context = context;
+    const settings = context.config || {};
+    console.log("\u2705 Cache plugin activated", {
+      memoryEnabled: settings.memoryEnabled ?? true,
+      kvEnabled: settings.kvEnabled ?? false,
+      defaultTTL: settings.defaultTTL ?? 3600
+    });
+    for (const [_namespace, config] of Object.entries(CACHE_CONFIGS)) {
+      getCacheService({
+        ...config,
+        memoryEnabled: settings.memoryEnabled ?? config.memoryEnabled,
+        kvEnabled: settings.kvEnabled ?? config.kvEnabled,
+        ttl: settings.defaultTTL ?? config.ttl
+      });
+    }
+    setupCacheInvalidation();
+  }
+  /**
+   * Deactivate the cache plugin
+   */
+  async deactivate() {
+    console.log("\u274C Cache plugin deactivated - clearing all caches");
+    await clearAllCaches();
+    this._context = null;
+  }
+  /**
+   * Configure the cache plugin
+   */
+  async configure(settings) {
+    console.log("\u2699\uFE0F Cache plugin configured", settings);
+    for (const [_namespace, config] of Object.entries(CACHE_CONFIGS)) {
+      getCacheService({
+        ...config,
+        memoryEnabled: settings.memoryEnabled ?? config.memoryEnabled,
+        kvEnabled: settings.kvEnabled ?? config.kvEnabled,
+        ttl: settings.defaultTTL ?? config.ttl
+      });
+    }
+  }
+  /**
+   * Get cache statistics
+   */
+  async getStats(c) {
+    const stats = getAllCacheStats();
+    return c.json({
+      success: true,
+      data: stats,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    });
+  }
+  /**
+   * Clear all cache entries
+   */
+  async clearCache(c) {
+    await clearAllCaches();
+    return c.json({
+      success: true,
+      message: "All cache entries cleared",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    });
+  }
+  /**
+   * Invalidate cache entries matching pattern
+   */
+  async invalidatePattern(c) {
+    const body = await c.req.json();
+    const { pattern, namespace: _namespace } = body;
+    if (!pattern) {
+      return c.json({
+        success: false,
+        error: "Pattern is required"
+      }, 400);
+    }
+    let totalInvalidated = 0;
+    if (_namespace) {
+      const cache = getCacheService(CACHE_CONFIGS[_namespace] || {
+        ttl: 3600,
+        kvEnabled: false,
+        memoryEnabled: true,
+        namespace: _namespace,
+        invalidateOn: [],
+        version: "v1"
+      });
+      totalInvalidated = await cache.invalidate(pattern);
+    } else {
+      for (const config of Object.values(CACHE_CONFIGS)) {
+        const cache = getCacheService(config);
+        totalInvalidated += await cache.invalidate(pattern);
+      }
+    }
+    return c.json({
+      success: true,
+      invalidated: totalInvalidated,
+      pattern,
+      namespace: _namespace || "all",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    });
+  }
+};
+var plugin = new CachePlugin();
+var cache_default = plugin;
+
+// src/assets/favicon.ts
+var faviconSvg = `<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<svg
+   version="1.1"
+   id="Layer_1"
+   x="0px"
+   y="0px"
+   viewBox="380 1300 257.89001 278.8855"
+   xml:space="preserve"
+   width="257.89001"
+   height="278.8855"
+   xmlns="http://www.w3.org/2000/svg">
+<g
+   id="g10"
+   transform="translate(-383.935,-60.555509)">
+	<g
+   id="g9">
+		<path
+   fill="#f1f2f2"
+   d="m 974.78,1398.211 c -5.016,6.574 -10.034,13.146 -15.048,19.721 -1.828,2.398 -3.657,4.796 -5.487,7.194 1.994,1.719 3.958,3.51 5.873,5.424 18.724,18.731 28.089,41.216 28.089,67.459 0,26.251 -9.366,48.658 -28.089,67.237 -18.731,18.579 -41.215,27.868 -67.459,27.868 -9.848,0 -19.156,-1.308 -27.923,-3.923 l -4.185,3.354 c -8.587,6.885 -17.154,13.796 -25.725,20.702 17.52,8.967 36.86,13.487 58.054,13.487 35.533,0 65.91,-12.608 91.124,-37.821 25.214,-25.215 37.821,-55.584 37.821,-91.125 0,-35.534 -12.607,-65.911 -37.821,-91.126 -3,-2.999 -6.078,-5.808 -9.224,-8.451 z"
+   id="path2" />
+		<path
+   fill="#34d399"
+   d="m 854.024,1585.195 20.001,-16.028 c 16.616,-13.507 33.04,-27.265 50.086,-40.251 1.13,-0.861 2.9,-1.686 2.003,-3.516 -0.843,-1.716 -2.481,-2.302 -4.484,-2.123 -8.514,0.765 -17.016,-0.538 -25.537,-0.353 -1.124,0.024 -2.768,0.221 -3.163,-1.25 -0.371,-1.369 1.088,-2.063 1.919,-2.894 6.26,-6.242 12.574,-12.43 18.816,-18.691 9.303,-9.327 18.565,-18.714 27.851,-28.066 1.848,-1.859 3.701,-3.713 5.549,-5.572 2.655,-2.661 5.309,-5.315 7.958,-7.982 0.574,-0.579 1.259,-1.141 1.246,-1.94 -0.004,-0.257 -0.078,-0.538 -0.254,-0.853 -0.556,-0.981 -1.441,-1.1 -2.469,-0.957 -0.658,0.096 -1.315,0.185 -1.973,0.275 -3.844,0.538 -7.689,1.076 -11.533,1.608 -3.641,0.505 -7.281,1.02 -10.922,1.529 -4.162,0.582 -8.324,1.158 -12.486,1.748 -1.142,0.161 -2.409,1.662 -3.354,0.508 -0.419,-0.508 -0.431,-1.028 -0.251,-1.531 0.269,-0.741 0.957,-1.441 1.387,-2.021 3.414,-4.58 6.882,-9.124 10.356,-13.662 1.74,-2.272 3.48,-4.544 5.214,-6.822 4.682,-6.141 9.369,-12.281 14.051,-18.422 0.09,-0.119 0.181,-0.237 0.271,-0.355 6.848,-8.98 13.7,-17.958 20.553,-26.936 0.488,-0.64 0.977,-1.28 1.465,-1.92 2.159,-2.828 4.315,-5.658 6.476,-8.486 4.197,-5.501 8.454,-10.954 12.67,-16.442 0.263,-0.347 0.538,-0.718 0.717,-1.106 0.269,-0.586 0.299,-1.196 -0.335,-1.776 -0.825,-0.753 -1.8,-0.15 -2.595,0.419 -0.67,0.472 -1.333,0.957 -1.955,1.489 -2.206,1.889 -4.401,3.797 -6.595,5.698 -3.958,3.438 -7.922,6.876 -11.976,10.194 -2.443,2.003 -4.865,4.028 -7.301,6.038 -18.689,-10.581 -39.53,-15.906 -62.549,-15.906 -35.54,0 -65.911,12.607 -91.125,37.82 -25.214,25.215 -37.821,55.592 -37.821,91.126 0,35.54 12.607,65.91 37.821,91.125 4.146,4.146 8.445,7.916 12.87,11.381 -9.015,11.14 -18.036,22.277 -27.034,33.429 -1.208,1.489 -3.755,3.151 -2.745,4.891 0.078,0.144 0.173,0.281 0.305,0.425 1.321,1.429 3.492,-1.303 4.933,-2.457 6.673,-5.333 13.333,-10.685 19.982,-16.042 3.707,-2.984 7.417,-5.965 11.124,-8.952 1.474,-1.188 2.951,-2.373 4.425,-3.561 6.41,-5.164 12.816,-10.333 19.238,-15.481 z m -56.472,-87.186 c 0,-26.243 9.29,-48.728 27.868,-67.459 18.579,-18.723 40.987,-28.089 67.238,-28.089 12.273,0 23.712,2.075 34.34,6.171 -3.37,2.905 -6.734,5.816 -10.069,8.762 -6.075,5.351 -12.365,10.469 -18.667,15.564 -4.179,3.378 -8.371,6.744 -12.514,10.164 -7.54,6.23 -15.037,12.52 -22.529,18.804 -7.091,5.955 -14.182,11.904 -21.19,17.949 -1.136,0.974 -3.055,1.907 -2.135,3.94 0.831,1.836 2.774,1.417 4.341,1.578 l 12.145,-0.599 14.151,-0.698 c 1.031,-0.102 2.192,-0.257 2.89,0.632 0.034,0.044 0.073,0.078 0.106,0.127 1.017,1.561 -0.67,2.105 -1.387,2.942 -6.308,7.318 -12.616,14.637 -18.978,21.907 -8.161,9.339 -16.353,18.649 -24.544,27.958 -2.146,2.433 -4.275,4.879 -6.422,7.312 -1.034,1.172 -2.129,2.272 -1.238,3.922 0.933,1.728 2.685,1.752 4.323,1.602 4.134,-0.367 8.263,-0.489 12.396,-0.492 0.242,0 0.485,-0.01 0.728,0 2.711,0.01 5.422,0.068 8.134,0.145 2.582,0.074 5.166,0.165 7.752,0.249 0.275,1.62 -0.879,2.356 -1.62,3.259 -1.333,1.626 -2.667,3.247 -4,4.867 -4.315,5.252 -8.62,10.514 -12.928,15.772 -3.562,-2.725 -7.007,-5.733 -10.324,-9.051 -18.577,-18.576 -27.867,-40.983 -27.867,-67.234 z"
+   id="path9" />
+	</g>
+</g>
+</svg>`;
 
 // src/app.ts
 function createSonicJSApp(config = {}) {
-  const app = new Hono();
+  const app2 = new Hono();
   const appVersion = config.version || getCoreVersion();
   const appName = config.name || "SonicJS AI";
-  app.use("*", async (c, next) => {
+  app2.use("*", async (c, next) => {
     c.set("appVersion", appVersion);
     await next();
   });
-  app.use("*", metricsMiddleware());
-  app.use("*", bootstrapMiddleware(config));
-  app.use("*", adminSetupMiddleware());
+  app2.use("*", metricsMiddleware());
+  app2.use("*", bootstrapMiddleware(config));
   if (config.middleware?.beforeAuth) {
     for (const middleware of config.middleware.beforeAuth) {
-      app.use("*", middleware);
+      app2.use("*", middleware);
     }
   }
-  app.use("*", async (_c, next) => {
+  app2.use("*", async (_c, next) => {
     await next();
   });
-  app.use("*", async (_c, next) => {
+  app2.use("*", async (_c, next) => {
     await next();
   });
   if (config.middleware?.afterAuth) {
     for (const middleware of config.middleware.afterAuth) {
-      app.use("*", middleware);
-    }
-  }
-  app.route("/api", api_default);
-  app.route("/api/media", api_media_default);
-  app.route("/api/system", api_system_default);
-  app.route("/admin/api", admin_api_default);
-  app.route("/admin/dashboard", router);
-  app.route("/admin/collections", adminCollectionsRoutes);
-  app.route("/admin/settings", adminSettingsRoutes);
-  app.route("/admin/database-tools", createDatabaseToolsAdminRoutes());
-  app.route("/admin/seed-data", createSeedDataAdminRoutes());
-  app.route("/admin/content", admin_content_default);
-  app.route("/admin/media", adminMediaRoutes);
-  app.route("/admin/plugins", adminPluginRoutes);
-  app.route("/admin/logs", adminLogsRoutes);
-  app.route("/admin", userRoutes);
-  app.route("/auth", auth_default);
-  app.route("/", test_cleanup_default);
+      app2.use("*", middleware);
+    }
+  }
+  app2.route("/api", api_default);
+  app2.route("/api/media", api_media_default);
+  app2.route("/api/system", api_system_default);
+  app2.route("/admin/api", admin_api_default);
+  app2.route("/admin/dashboard", router);
+  app2.route("/admin/collections", adminCollectionsRoutes);
+  app2.route("/admin/settings", adminSettingsRoutes);
+  app2.route("/admin/database-tools", createDatabaseToolsAdminRoutes());
+  app2.route("/admin/seed-data", createSeedDataAdminRoutes());
+  app2.route("/admin/content", admin_content_default);
+  app2.route("/admin/media", adminMediaRoutes);
+  if (aiSearchPlugin.routes && aiSearchPlugin.routes.length > 0) {
+    for (const route of aiSearchPlugin.routes) {
+      app2.route(route.path, route.handler);
+    }
+  }
+  app2.route("/admin/cache", cache_default.getRoutes());
+  app2.route("/admin/plugins", adminPluginRoutes);
+  app2.route("/admin/logs", adminLogsRoutes);
+  app2.route("/admin", userRoutes);
+  app2.route("/auth", auth_default);
+  app2.route("/", test_cleanup_default);
   if (emailPlugin.routes && emailPlugin.routes.length > 0) {
     for (const route of emailPlugin.routes) {
-      app.route(route.path, route.handler);
+      app2.route(route.path, route.handler);
     }
   }
   if (otpLoginPlugin.routes && otpLoginPlugin.routes.length > 0) {
     for (const route of otpLoginPlugin.routes) {
-      app.route(route.path, route.handler);
+      app2.route(route.path, route.handler);
     }
   }
   const magicLinkPlugin = createMagicLinkAuthPlugin();
   if (magicLinkPlugin.routes && magicLinkPlugin.routes.length > 0) {
     for (const route of magicLinkPlugin.routes) {
-      app.route(route.path, route.handler);
+      app2.route(route.path, route.handler);
     }
   }
-  app.get("/files/*", async (c) => {
+  app2.get("/favicon.svg", (c) => {
+    return new Response(faviconSvg, {
+      headers: {
+        "Content-Type": "image/svg+xml",
+        "Cache-Control": "public, max-age=31536000"
+      }
+    });
+  });
+  app2.get("/files/*", async (c) => {
     try {
       const url = new URL(c.req.url);
       const pathname = url.pathname;
@@ -2820,13 +6487,13 @@ function createSonicJSApp(config = {}) {
   });
   if (config.routes) {
     for (const route of config.routes) {
-      app.route(route.path, route.handler);
+      app2.route(route.path, route.handler);
     }
   }
-  app.get("/", (c) => {
+  app2.get("/", (c) => {
     return c.redirect("/auth/login");
   });
-  app.get("/health", (c) => {
+  app2.get("/health", (c) => {
     return c.json({
       name: appName,
       version: appVersion,
@@ -2834,14 +6501,14 @@ function createSonicJSApp(config = {}) {
       timestamp: (/* @__PURE__ */ new Date()).toISOString()
     });
   });
-  app.notFound((c) => {
+  app2.notFound((c) => {
     return c.json({ error: "Not Found", status: 404 }, 404);
   });
-  app.onError((err, c) => {
+  app2.onError((err, c) => {
     console.error(err);
     return c.json({ error: "Internal Server Error", status: 500 }, 500);
   });
-  return app;
+  return app2;
 }
 function setupCoreMiddleware(_app) {
   console.warn("setupCoreMiddleware is deprecated. Use createSonicJSApp() instead.");