@stacksjs/bun-router 0.0.2 → 0.0.4

package/dist/{chunk-r15a48wc.js → chunk-cjdekj87.js}

@@ -1,12 +1,16 @@
 // @bun
 var __defProp = Object.defineProperty;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, {
       get: all[name],
       enumerable: true,
       configurable: true,
-      set: (newValue) => all[name] = () => newValue
+      set: __exportSetter.bind(all, name)
     });
 };
 var __require = import.meta.require;
@@ -21918,23 +21922,468 @@ async function verifySignature(stringToSign, signature, secret, algorithm = "sha
   return result === 0;
 }
 
+// src/session/memory-store.ts
+class MemorySessionStore {
+  defaultTtl;
+  sessions = new Map;
+  cleanupInterval = null;
+  constructor(defaultTtl = 86400) {
+    this.defaultTtl = defaultTtl;
+    this.cleanupInterval = setInterval(() => this.cleanup(), 5 * 60 * 1000);
+  }
+  async get(sid) {
+    const stored = this.sessions.get(sid);
+    if (!stored)
+      return null;
+    if (Date.now() > stored.expiresAt) {
+      this.sessions.delete(sid);
+      return null;
+    }
+    return stored.data;
+  }
+  async set(sid, session, ttl) {
+    const expiresAt = Date.now() + (ttl ?? this.defaultTtl) * 1000;
+    this.sessions.set(sid, { data: session, expiresAt });
+  }
+  async destroy(sid) {
+    this.sessions.delete(sid);
+  }
+  async touch(sid, session, ttl) {
+    const stored = this.sessions.get(sid);
+    if (stored) {
+      stored.expiresAt = Date.now() + (ttl ?? this.defaultTtl) * 1000;
+      stored.data = session;
+    }
+  }
+  async all() {
+    const result = {};
+    const now = Date.now();
+    for (const [sid, stored] of this.sessions) {
+      if (now <= stored.expiresAt) {
+        result[sid] = stored.data;
+      }
+    }
+    return result;
+  }
+  async length() {
+    return this.sessions.size;
+  }
+  async clear() {
+    this.sessions.clear();
+  }
+  cleanup() {
+    const now = Date.now();
+    for (const [sid, stored] of this.sessions) {
+      if (now > stored.expiresAt) {
+        this.sessions.delete(sid);
+      }
+    }
+  }
+  dispose() {
+    if (this.cleanupInterval) {
+      clearInterval(this.cleanupInterval);
+      this.cleanupInterval = null;
+    }
+    this.sessions.clear();
+  }
+}
+
+// src/session/file-store.ts
+import { existsSync as existsSync9, mkdirSync as mkdirSync6, readdirSync as readdirSync6, unlinkSync, writeFileSync as writeFileSync8, readFileSync } from "fs";
+import { join as join4 } from "path";
+import { tmpdir } from "os";
+
+class FileSessionStore {
+  defaultTtl;
+  dir;
+  cleanupInterval = null;
+  constructor(defaultTtl = 86400, dir) {
+    this.defaultTtl = defaultTtl;
+    this.dir = dir || join4(tmpdir(), "bun-router-sessions");
+    if (!existsSync9(this.dir)) {
+      mkdirSync6(this.dir, { recursive: true });
+    }
+    this.cleanupInterval = setInterval(() => this.cleanup(), 10 * 60 * 1000);
+  }
+  filePath(sid) {
+    const safeSid = sid.replace(/[^a-zA-Z0-9_-]/g, "");
+    return join4(this.dir, `${safeSid}.json`);
+  }
+  async get(sid) {
+    const path = this.filePath(sid);
+    if (!existsSync9(path))
+      return null;
+    try {
+      const content = readFileSync(path, "utf-8");
+      const stored = JSON.parse(content);
+      if (Date.now() > stored.expiresAt) {
+        unlinkSync(path);
+        return null;
+      }
+      return stored.data;
+    } catch {
+      return null;
+    }
+  }
+  async set(sid, session, ttl) {
+    const stored = {
+      data: session,
+      expiresAt: Date.now() + (ttl ?? this.defaultTtl) * 1000
+    };
+    writeFileSync8(this.filePath(sid), JSON.stringify(stored), "utf-8");
+  }
+  async destroy(sid) {
+    const path = this.filePath(sid);
+    if (existsSync9(path)) {
+      unlinkSync(path);
+    }
+  }
+  async touch(sid, session, ttl) {
+    const path = this.filePath(sid);
+    if (!existsSync9(path))
+      return;
+    const stored = {
+      data: session,
+      expiresAt: Date.now() + (ttl ?? this.defaultTtl) * 1000
+    };
+    writeFileSync8(path, JSON.stringify(stored), "utf-8");
+  }
+  async all() {
+    const result = {};
+    const now = Date.now();
+    try {
+      const files = readdirSync6(this.dir).filter((f) => f.endsWith(".json"));
+      for (const file of files) {
+        const content = readFileSync(join4(this.dir, file), "utf-8");
+        const stored = JSON.parse(content);
+        if (now <= stored.expiresAt) {
+          const sid = file.replace(".json", "");
+          result[sid] = stored.data;
+        }
+      }
+    } catch {}
+    return result;
+  }
+  async length() {
+    try {
+      return readdirSync6(this.dir).filter((f) => f.endsWith(".json")).length;
+    } catch {
+      return 0;
+    }
+  }
+  async clear() {
+    try {
+      const files = readdirSync6(this.dir).filter((f) => f.endsWith(".json"));
+      for (const file of files) {
+        unlinkSync(join4(this.dir, file));
+      }
+    } catch {}
+  }
+  cleanup() {
+    const now = Date.now();
+    try {
+      const files = readdirSync6(this.dir).filter((f) => f.endsWith(".json"));
+      for (const file of files) {
+        const path = join4(this.dir, file);
+        const content = readFileSync(path, "utf-8");
+        const stored = JSON.parse(content);
+        if (now > stored.expiresAt) {
+          unlinkSync(path);
+        }
+      }
+    } catch {}
+  }
+  dispose() {
+    if (this.cleanupInterval) {
+      clearInterval(this.cleanupInterval);
+      this.cleanupInterval = null;
+    }
+  }
+}
+
+// src/session/redis-store.ts
+class RedisSessionStore {
+  client;
+  defaultTtl;
+  prefix;
+  constructor(client, defaultTtl = 86400, prefix = "sess:") {
+    this.client = client;
+    this.defaultTtl = defaultTtl;
+    this.prefix = prefix;
+  }
+  key(sid) {
+    return `${this.prefix}${sid}`;
+  }
+  async get(sid) {
+    const data = await this.client.get(this.key(sid));
+    if (!data)
+      return null;
+    try {
+      return JSON.parse(data);
+    } catch {
+      return null;
+    }
+  }
+  async set(sid, session, ttl) {
+    const key = this.key(sid);
+    const seconds = ttl ?? this.defaultTtl;
+    await this.client.set(key, JSON.stringify(session), "EX", seconds);
+  }
+  async destroy(sid) {
+    await this.client.del(this.key(sid));
+  }
+  async touch(sid, session, ttl) {
+    const key = this.key(sid);
+    const seconds = ttl ?? this.defaultTtl;
+    await this.client.set(key, JSON.stringify(session), "EX", seconds);
+  }
+  async all() {
+    const keys = await this.client.keys(`${this.prefix}*`);
+    const result = {};
+    for (const key of keys) {
+      const data = await this.client.get(key);
+      if (data) {
+        try {
+          const sid = key.slice(this.prefix.length);
+          result[sid] = JSON.parse(data);
+        } catch {}
+      }
+    }
+    return result;
+  }
+  async length() {
+    const keys = await this.client.keys(`${this.prefix}*`);
+    return keys.length;
+  }
+  async clear() {
+    const keys = await this.client.keys(`${this.prefix}*`);
+    if (keys.length > 0) {
+      await this.client.del(keys);
+    }
+  }
+}
+
+// src/session/database-store.ts
+class DatabaseSessionStore {
+  adapter;
+  defaultTtl;
+  cleanupInterval = null;
+  constructor(adapter, defaultTtl = 86400) {
+    this.adapter = adapter;
+    this.defaultTtl = defaultTtl;
+    this.cleanupInterval = setInterval(() => {
+      const maxAge = Date.now() - this.defaultTtl * 1000;
+      this.adapter.deleteExpiredSessions(maxAge);
+    }, 30 * 60 * 1000);
+  }
+  async get(sid) {
+    const record = await this.adapter.findSession(sid);
+    if (!record)
+      return null;
+    const maxAge = Date.now() - this.defaultTtl * 1000;
+    if (record.last_activity < maxAge) {
+      await this.adapter.deleteSession(sid);
+      return null;
+    }
+    try {
+      return JSON.parse(record.payload);
+    } catch {
+      return null;
+    }
+  }
+  async set(sid, session, _ttl) {
+    await this.adapter.upsertSession(sid, JSON.stringify(session), Date.now());
+  }
+  async destroy(sid) {
+    await this.adapter.deleteSession(sid);
+  }
+  async touch(sid, session, _ttl) {
+    await this.adapter.upsertSession(sid, JSON.stringify(session), Date.now());
+  }
+  async all() {
+    const records = await this.adapter.getAllSessions();
+    const result = {};
+    const maxAge = Date.now() - this.defaultTtl * 1000;
+    for (const record of records) {
+      if (record.last_activity >= maxAge) {
+        try {
+          result[record.id] = JSON.parse(record.payload);
+        } catch {}
+      }
+    }
+    return result;
+  }
+  async length() {
+    return this.adapter.countSessions();
+  }
+  async clear() {
+    await this.adapter.clearAllSessions();
+  }
+  dispose() {
+    if (this.cleanupInterval) {
+      clearInterval(this.cleanupInterval);
+      this.cleanupInterval = null;
+    }
+  }
+}
+
+// src/session/index.ts
+function createSessionStore(config4) {
+  const ttl = config4.ttl ?? 86400;
+  switch (config4.driver) {
+    case "memory":
+      return new MemorySessionStore(ttl);
+    case "file":
+      return new FileSessionStore(ttl, config4.file?.dir);
+    case "redis": {
+      if (!config4.redis?.client) {
+        throw new Error("Redis client is required for redis session driver");
+      }
+      return new RedisSessionStore(config4.redis.client, ttl, config4.redis.prefix);
+    }
+    case "database": {
+      if (!config4.database?.adapter) {
+        throw new Error("Database adapter is required for database session driver");
+      }
+      return new DatabaseSessionStore(config4.database.adapter, ttl);
+    }
+    default:
+      return new MemorySessionStore(ttl);
+  }
+}
+
+class SessionManager {
+  sessionId;
+  data;
+  store;
+  flashedKeys = [];
+  previousFlash = {};
+  dirty = false;
+  constructor(sessionId, data, store) {
+    this.sessionId = sessionId;
+    this.data = data;
+    this.store = store;
+    this.previousFlash = { ...data.flash || {} };
+  }
+  get id() {
+    return this.sessionId;
+  }
+  get(key) {
+    if (this.data.flash && key in this.data.flash) {
+      return this.data.flash[key];
+    }
+    if (this.data.data && key in this.data.data) {
+      return this.data.data[key];
+    }
+    return;
+  }
+  set(key, value) {
+    if (!this.data.data)
+      this.data.data = {};
+    this.data.data[key] = value;
+    this.dirty = true;
+  }
+  has(key) {
+    return this.data.data && key in this.data.data || this.data.flash && key in this.data.flash || false;
+  }
+  forget(key) {
+    if (this.data.data) {
+      delete this.data.data[key];
+      this.dirty = true;
+    }
+  }
+  all() {
+    return { ...this.data.data || {}, ...this.data.flash || {} };
+  }
+  flash(key, value) {
+    if (!this.data.flash)
+      this.data.flash = {};
+    this.data.flash[key] = value;
+    this.flashedKeys.push(key);
+    this.dirty = true;
+  }
+  getFlash(key) {
+    return this.previousFlash[key];
+  }
+  keep(keys) {
+    for (const key of keys) {
+      if (key in this.previousFlash) {
+        this.flash(key, this.previousFlash[key]);
+      }
+    }
+  }
+  reflash() {
+    for (const [key, value] of Object.entries(this.previousFlash)) {
+      this.flash(key, value);
+    }
+  }
+  async regenerate() {
+    const oldId = this.sessionId;
+    this.sessionId = generateSessionId();
+    await this.store.set(this.sessionId, this.data);
+    await this.store.destroy(oldId);
+    return this.sessionId;
+  }
+  async invalidate() {
+    const oldId = this.sessionId;
+    this.sessionId = generateSessionId();
+    this.data = { id: this.sessionId };
+    await this.store.destroy(oldId);
+    await this.store.set(this.sessionId, this.data);
+    return this.sessionId;
+  }
+  async save() {
+    if (this.data.flash) {
+      const newFlash = {};
+      for (const key of this.flashedKeys) {
+        if (this.data.flash[key] !== undefined) {
+          newFlash[key] = this.data.flash[key];
+        }
+      }
+      this.data.flash = Object.keys(newFlash).length > 0 ? newFlash : undefined;
+    }
+    await this.store.set(this.sessionId, this.data);
+  }
+  async destroy() {
+    await this.store.destroy(this.sessionId);
+    this.data = {};
+  }
+}
+function generateSessionId() {
+  const bytes = new Uint8Array(32);
+  crypto.getRandomValues(bytes);
+  return Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("");
+}
+
 // src/middleware/session.ts
 class Session {
-  static sessions = new Map;
+  store;
+  constructor(options) {
+    this.store = options?.store || new MemorySessionStore;
+  }
   async handle(req, next) {
     const sessionConfig = config3.server?.security?.auth?.session;
-    req.session = {};
-    const sessionId = req.cookies?.get(sessionConfig?.name || "session") || this.generateSessionId();
-    if (sessionId && Session.sessions.has(sessionId)) {
-      req.session = Session.sessions.get(sessionId);
-    }
+    const cookieName = sessionConfig?.name || "session";
+    let sessionId = req.cookies?.get(cookieName) || "";
+    let isNewSession = false;
+    if (!sessionId) {
+      sessionId = generateSessionId();
+      isNewSession = true;
+    }
+    let sessionData = isNewSession ? null : await this.store.get(sessionId);
+    if (!sessionData) {
+      sessionData = { id: sessionId };
+      isNewSession = true;
+    }
+    const manager = new SessionManager(sessionId, sessionData, this.store);
+    req.session = manager;
     const response = await next();
-    Session.sessions.set(sessionId, req.session);
+    await manager.save();
     const cookieOptions = {
       maxAge: sessionConfig?.cookie?.maxAge || 86400000,
       path: sessionConfig?.cookie?.path || "/"
     };
-    if (sessionConfig?.cookie?.httpOnly) {
+    if (sessionConfig?.cookie?.httpOnly !== false) {
       cookieOptions.httpOnly = true;
     }
     if (sessionConfig?.cookie?.secure) {
@@ -21947,25 +22396,12 @@ class Session {
       req._cookiesToSet = [];
     }
     req._cookiesToSet.push({
-      name: sessionConfig?.name || "session",
-      value: sessionId,
+      name: cookieName,
+      value: manager.id,
       options: cookieOptions
     });
     return response || new Response("Not Found", { status: 404 });
   }
-  parseCookies(req) {
-    const cookieHeader = req.headers.get("cookie");
-    if (!cookieHeader)
-      return {};
-    return cookieHeader.split(";").reduce((cookies, cookie) => {
-      const [name, value] = cookie.trim().split("=");
-      cookies[name] = value;
-      return cookies;
-    }, {});
-  }
-  generateSessionId() {
-    return Array.from({ length: 32 }, () => Math.floor(Math.random() * 16).toString(16)).join("");
-  }
 }
 
 // src/middleware/content_security_policy.ts
@@ -22407,8 +22843,8 @@ class FileSecurity {
 
 // src/middleware/file_upload.ts
 import { randomUUID as randomUUID2 } from "crypto";
-import { existsSync as existsSync9, mkdirSync as mkdirSync6, writeFileSync as writeFileSync8 } from "fs";
-import { basename, extname, join as join4 } from "path";
+import { existsSync as existsSync11, mkdirSync as mkdirSync7, writeFileSync as writeFileSync9 } from "fs";
+import { basename, extname, join as join6 } from "path";
 class FileUpload {
   config;
   fileSecurity;
@@ -22429,8 +22865,8 @@ class FileUpload {
       maxFilenameLength: config4.maxFilenameLength ?? 255
     };
     this.fileSecurity = new FileSecurity(config4);
-    if (this.config.createDestination && !existsSync9(this.config.destination)) {
-      mkdirSync6(this.config.destination, { recursive: true });
+    if (this.config.createDestination && !existsSync11(this.config.destination)) {
+      mkdirSync7(this.config.destination, { recursive: true });
     }
   }
   async handle(req, next) {
@@ -22462,7 +22898,7 @@ class FileUpload {
             return this.createErrorResponse(`File extension ${fileExtension} not allowed. Allowed extensions: ${this.config.allowedExtensions.join(", ")}`, 415);
           }
           const filename = this.generateFilename(value.name);
-          const filePath = join4(this.config.destination, filename);
+          const filePath = join6(this.config.destination, filename);
           const buffer = await value.arrayBuffer();
           const uploadedFile = {
             fieldName: key,
@@ -22477,7 +22913,7 @@ class FileUpload {
           if (!securityCheck.isValid) {
             return this.createErrorResponse(`Security validation failed: ${securityCheck.errors.join(", ")}`, 400);
           }
-          writeFileSync8(filePath, new Uint8Array(buffer));
+          writeFileSync9(filePath, new Uint8Array(buffer));
           uploadedFiles.push(uploadedFile);
         } else {
           if (fields[key]) {
@@ -22540,7 +22976,7 @@ class FileUpload {
 function fileUpload(config4 = {}) {
   return new FileUpload(config4);
 }
-function singleFileUpload(fieldName, config4 = {}) {
+function singleFileUpload(_fieldName, config4 = {}) {
   return new FileUpload({ ...config4, maxFiles: 1 });
 }
 function multipleFileUpload(maxFiles = 10, config4 = {}) {
@@ -23540,7 +23976,7 @@ class PerformanceDashboard {
 <html lang="en">
 <head>
     <meta charset="UTF-8">
-    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <meta name='viewport' content='width=device-width, initial-scale=1.0'>
     <title>${this.options.title}</title>
     <style>
         * { margin: 0; padding: 0; box-sizing: border-box; }
@@ -23707,92 +24143,92 @@ class PerformanceDashboard {
     </style>
 </head>
 <body>
-    <div class="header">
+    <div class='header'>
         <h1>${this.options.title}</h1>
-        <div class="status">
-            <div class="status-item">
-                <div class="status-value">${data.metrics.current.totalRequests}</div>
+        <div class='status'>
+            <div class='status-item'>
+                <div class='status-value'>${data.metrics.current.totalRequests}</div>
                 <div>Total Requests</div>
             </div>
-            <div class="status-item">
-                <div class="status-value">${Math.round(data.metrics.current.averageResponseTime)}ms</div>
+            <div class='status-item'>
+                <div class='status-value'>${Math.round(data.metrics.current.averageResponseTime)}ms</div>
                 <div>Avg Response</div>
             </div>
-            <div class="status-item">
-                <div class="status-value">${Math.round(data.metrics.current.errorRate * 100)}%</div>
+            <div class='status-item'>
+                <div class='status-value'>${Math.round(data.metrics.current.errorRate * 100)}%</div>
                 <div>Error Rate</div>
             </div>
-            <div class="status-item">
-                <div class="status-value">${Math.round(data.metrics.current.requestsPerSecond)}/s</div>
+            <div class='status-item'>
+                <div class='status-value'>${Math.round(data.metrics.current.requestsPerSecond)}/s</div>
                 <div>Requests/sec</div>
             </div>
         </div>
     </div>
 
-    <div class="container">
+    <div class='container'>
         ${this.options.features?.realTimeMetrics ? `
-        <div class="card">
+        <div class='card'>
             <h2>Real-time Metrics</h2>
-            <div class="metric">
-                <span class="metric-label">Response Time</span>
-                <span class="metric-value">${Math.round(data.metrics.current.averageResponseTime)}ms</span>
+            <div class='metric'>
+                <span class='metric-label'>Response Time</span>
+                <span class='metric-value'>${Math.round(data.metrics.current.averageResponseTime)}ms</span>
             </div>
-            <div class="metric">
-                <span class="metric-label">Memory Usage</span>
-                <span class="metric-value">${Math.round(data.metrics.current.memoryUsage / 1024 / 1024)}MB</span>
+            <div class='metric'>
+                <span class='metric-label'>Memory Usage</span>
+                <span class='metric-value'>${Math.round(data.metrics.current.memoryUsage / 1024 / 1024)}MB</span>
             </div>
-            <div class="metric">
-                <span class="metric-label">CPU Usage</span>
-                <span class="metric-value">${Math.round(data.metrics.current.cpuUsage)}%</span>
+            <div class='metric'>
+                <span class='metric-label'>CPU Usage</span>
+                <span class='metric-value'>${Math.round(data.metrics.current.cpuUsage)}%</span>
             </div>
-            <div class="metric">
-                <span class="metric-label">Requests/sec</span>
-                <span class="metric-value">${Math.round(data.metrics.current.requestsPerSecond)}</span>
+            <div class='metric'>
+                <span class='metric-label'>Requests/sec</span>
+                <span class='metric-value'>${Math.round(data.metrics.current.requestsPerSecond)}</span>
             </div>
-            <div class="metric">
-                <span class="metric-label">Error Rate</span>
-                <span class="metric-value ${data.metrics.current.errorRate > 0.1 ? "critical" : data.metrics.current.errorRate > 0.05 ? "warning" : ""}">${Math.round(data.metrics.current.errorRate * 100)}%</span>
+            <div class='metric'>
+                <span class='metric-label'>Error Rate</span>
+                <span class='metric-value ${data.metrics.current.errorRate > 0.1 ? "critical" : data.metrics.current.errorRate > 0.05 ? "warning" : ""}'>${Math.round(data.metrics.current.errorRate * 100)}%</span>
             </div>
         </div>
         ` : ""}
 
         ${this.options.features?.historicalCharts ? `
-        <div class="card">
+        <div class='card'>
             <h2>Historical Performance</h2>
-            <div class="chart-container">
+            <div class='chart-container'>
                 Response Time Chart (${data.metrics.historical.length} data points)
             </div>
         </div>
         ` : ""}
 
-        <div class="card">
+        <div class='card'>
             <h2>Request Distribution</h2>
-            <div class="distribution">
+            <div class='distribution'>
                 ${Object.entries(data.metrics.distribution.statusCodes).map(([code, count]) => `
-                    <div class="distribution-item">
-                        <div class="distribution-value">${count}</div>
-                        <div class="distribution-label">HTTP ${code}</div>
+                    <div class='distribution-item'>
+                        <div class='distribution-value'>${count}</div>
+                        <div class='distribution-label'>HTTP ${code}</div>
                     </div>
                 `).join("")}
             </div>
         </div>
 
-        <div class="card">
+        <div class='card'>
             <h2>Top Endpoints</h2>
             ${Object.entries(data.metrics.distribution.paths).sort(([, a], [, b]) => b - a).slice(0, 10).map(([path, count]) => `
-                    <div class="metric">
-                        <span class="metric-label">${path}</span>
-                        <span class="metric-value">${count}</span>
+                    <div class='metric'>
+                        <span class='metric-label'>${path}</span>
+                        <span class='metric-value'>${count}</span>
                     </div>
                 `).join("")}
         </div>
 
         ${this.options.features?.alertsPanel ? `
-        <div class="card">
+        <div class='card'>
             <h2>Active Alerts</h2>
             ${data.alerts.length === 0 ? "<p>No active alerts</p>" : ""}
             ${data.alerts.filter((alert) => !alert.resolved).map((alert) => `
-                <div class="alert ${alert.type}">
+                <div class='alert ${alert.type}'>
                     <strong>${alert.type.toUpperCase()}:</strong> ${alert.message}
                     <br><small>${new Date(alert.timestamp).toLocaleString()}</small>
                 </div>
@@ -23801,15 +24237,15 @@ class PerformanceDashboard {
         ` : ""}
 
         ${this.options.features?.tracingView ? `
-        <div class="card">
+        <div class='card'>
             <h2>Recent Traces</h2>
             ${data.traces.slice(0, 10).map((trace) => `
-                <div class="trace">
-                    <div class="trace-header">
-                        <span class="trace-operation">${trace.operationName}</span>
-                        <span class="trace-duration">${Math.round((trace.duration || 0) * 100) / 100}ms</span>
+                <div class='trace'>
+                    <div class='trace-header'>
+                        <span class='trace-operation'>${trace.operationName}</span>
+                        <span class='trace-duration'>${Math.round((trace.duration || 0) * 100) / 100}ms</span>
                     </div>
-                    <div class="trace-details">
+                    <div class='trace-details'>
                         Trace ID: ${trace.traceId} | Status: ${trace.status}
                         ${trace.error ? ` | Error: ${trace.error}` : ""}
                     </div>
@@ -23819,33 +24255,33 @@ class PerformanceDashboard {
         ` : ""}
 
         ${this.options.features?.systemMetrics ? `
-        <div class="card">
+        <div class='card'>
             <h2>System Information</h2>
-            <div class="metric">
-                <span class="metric-label">Uptime</span>
-                <span class="metric-value">${Math.round(data.system.uptime / 1000 / 60)} minutes</span>
+            <div class='metric'>
+                <span class='metric-label'>Uptime</span>
+                <span class='metric-value'>${Math.round(data.system.uptime / 1000 / 60)} minutes</span>
             </div>
-            <div class="metric">
-                <span class="metric-label">Node.js</span>
-                <span class="metric-value">${data.system.nodeVersion}</span>
+            <div class='metric'>
+                <span class='metric-label'>Node.js</span>
+                <span class='metric-value'>${data.system.nodeVersion}</span>
             </div>
-            <div class="metric">
-                <span class="metric-label">Platform</span>
-                <span class="metric-value">${data.system.platform} ${data.system.arch}</span>
+            <div class='metric'>
+                <span class='metric-label'>Platform</span>
+                <span class='metric-value'>${data.system.platform} ${data.system.arch}</span>
             </div>
-            <div class="metric">
-                <span class="metric-label">Heap Used</span>
-                <span class="metric-value">${Math.round(data.system.memory.heapUsed / 1024 / 1024)}MB</span>
+            <div class='metric'>
+                <span class='metric-label'>Heap Used</span>
+                <span class='metric-value'>${Math.round(data.system.memory.heapUsed / 1024 / 1024)}MB</span>
             </div>
-            <div class="metric">
-                <span class="metric-label">RSS</span>
-                <span class="metric-value">${Math.round(data.system.memory.rss / 1024 / 1024)}MB</span>
+            <div class='metric'>
+                <span class='metric-label'>RSS</span>
+                <span class='metric-value'>${Math.round(data.system.memory.rss / 1024 / 1024)}MB</span>
             </div>
         </div>
         ` : ""}
     </div>
 
-    <div class="refresh-indicator" id="refreshIndicator">Updated</div>
+    <div class='refresh-indicator' id='refreshIndicator'>Updated</div>
 
     <script>
         let refreshInterval;
@@ -23863,7 +24299,8 @@ class PerformanceDashboard {
                         // For now, we'll just refresh the page
                         setTimeout(() => window.location.reload(), ${this.options.refreshInterval});
                     }
-                } catch (error) {
+                }
+catch (error) {
                     console.error('Failed to refresh data:', error);
                 }
             }, ${this.options.refreshInterval});
@@ -23876,7 +24313,8 @@ class PerformanceDashboard {
         document.addEventListener('visibilitychange', () => {
             if (document.hidden) {
                 clearInterval(refreshInterval);
-            } else {
+            }
+else {
                 startAutoRefresh();
             }
         });
@@ -25445,4 +25883,4 @@ var middleware = new Proxy({}, {
   }
 });
 
-export { __export, __require, defaultConfig3 as defaultConfig, getConfig, config3 as config, extractBasicAuth, extractBearerToken, extractApiKey, basicAuth, bearerAuth, jwtAuth, apiKeyAuth, oauth2Auth, Cors, Csrf, JsonBody, RateLimit, rateLimit, RequestId, SignatureError, InMemoryNonceStore, RequestSigning, requestSigning, signRequest, verifySignature, Session, ContentSecurityPolicy, contentSecurityPolicy, DDoSProtection, ddosProtection, FileSecurity, FileUpload, fileUpload, singleFileUpload, multipleFileUpload, imageUpload, documentUpload, Helmet, InputValidation, inputValidation, PerformanceAlerting, performanceAlerting, PerformanceDashboard, performanceDashboard, PerformanceMonitor2 as PerformanceMonitor, performanceMonitor, RequestTracer, requestTracer, Security, security, SecuritySuite, securitySuite, cors, jsonBody, requestId, session, csrf, auth, middleware };
+export { __export, __require, defaultConfig3 as defaultConfig, getConfig, config3 as config, extractBasicAuth, extractBearerToken, extractApiKey, basicAuth, bearerAuth, jwtAuth, apiKeyAuth, oauth2Auth, Cors, Csrf, JsonBody, RateLimit, rateLimit, RequestId, SignatureError, InMemoryNonceStore, RequestSigning, requestSigning, signRequest, verifySignature, MemorySessionStore, FileSessionStore, RedisSessionStore, DatabaseSessionStore, createSessionStore, SessionManager, generateSessionId, Session, ContentSecurityPolicy, contentSecurityPolicy, DDoSProtection, ddosProtection, FileSecurity, FileUpload, fileUpload, singleFileUpload, multipleFileUpload, imageUpload, documentUpload, Helmet, InputValidation, inputValidation, PerformanceAlerting, performanceAlerting, PerformanceDashboard, performanceDashboard, PerformanceMonitor2 as PerformanceMonitor, performanceMonitor, RequestTracer, requestTracer, Security, security, SecuritySuite, securitySuite, cors, jsonBody, requestId, session, csrf, auth, middleware };