opticore-profiler 1.0.0

package/dist/index.cjs

@@ -0,0 +1,1942 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  CollectorRegistry: () => CollectorRegistry,
+  DEFAULT_EXCLUDE_PATHS: () => DEFAULT_EXCLUDE_PATHS,
+  DEFAULT_SENSITIVE_KEYS: () => DEFAULT_SENSITIVE_KEYS,
+  DatabaseCollector: () => DatabaseCollector,
+  ExceptionCollector: () => ExceptionCollector,
+  FileStorage: () => FileStorage,
+  LoggerCollector: () => LoggerCollector,
+  MemoryCollector: () => MemoryCollector,
+  MemoryStorage: () => MemoryStorage,
+  RequestCollector: () => RequestCollector,
+  TimeCollector: () => TimeCollector,
+  createProfilerRouter: () => createProfilerRouter,
+  generateToken: () => generateToken,
+  getActiveCollector: () => getActiveCollector,
+  instrumentLogger: () => instrumentLogger,
+  instrumentMySQL: () => instrumentMySQL,
+  isValidToken: () => isValidToken,
+  opticoreProfiler: () => opticoreProfiler,
+  profilerErrorHandler: () => profilerErrorHandler,
+  registerProfilerViews: () => registerProfilerViews
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/middleware/profiler.middleware.ts
+var import_events = require("events");
+
+// src/token.ts
+var import_crypto = require("crypto");
+var ALPHABET = "abcdefghijklmnopqrstuvwxyz0123456789";
+function generateToken(length = 8) {
+  if (length < 6 || length > 8) {
+    throw new Error("Profiler token length must be between 6 and 8 characters");
+  }
+  let out = "";
+  while (out.length < length) {
+    const bytes = (0, import_crypto.randomBytes)(length);
+    for (let i = 0; i < bytes.length && out.length < length; i++) {
+      const byte = bytes[i];
+      if (byte < 252) {
+        out += ALPHABET[byte % 36];
+      }
+    }
+  }
+  return out;
+}
+function isValidToken(token) {
+  return typeof token === "string" && /^[a-z0-9]{6,8}$/.test(token);
+}
+
+// src/context.ts
+var import_async_hooks = require("async_hooks");
+var profilerContext = new import_async_hooks.AsyncLocalStorage();
+function runWithProfilerContext(state, fn) {
+  return profilerContext.run(state, fn);
+}
+function getActiveProfilingState() {
+  return profilerContext.getStore();
+}
+function getActiveCollector(name) {
+  return profilerContext.getStore()?.collectors.get(name);
+}
+
+// src/registry.ts
+var CollectorRegistry = class {
+  factories = /* @__PURE__ */ new Map();
+  register(factory) {
+    const probe = factory();
+    const name = probe.getName();
+    if (!name) {
+      throw new Error("DataCollector.getName() must return a non-empty string");
+    }
+    this.factories.set(name, factory);
+  }
+  unregister(name) {
+    this.factories.delete(name);
+  }
+  has(name) {
+    return this.factories.has(name);
+  }
+  names() {
+    return [...this.factories.keys()];
+  }
+  /** Builds one fresh instance per registered factory, keyed by collector name. */
+  createAll() {
+    const instances = /* @__PURE__ */ new Map();
+    for (const [name, factory] of this.factories) {
+      instances.set(name, factory());
+    }
+    return instances;
+  }
+};
+
+// src/types.ts
+var DEFAULT_EXCLUDE_PATHS = ["/favicon.ico", "/.well-known/*"];
+var DEFAULT_SENSITIVE_KEYS = [
+  "authorization",
+  "cookie",
+  "set-cookie",
+  "x-api-key",
+  "session",
+  "password",
+  "passwd",
+  "secret",
+  "token",
+  "access_token",
+  "refresh_token",
+  "api_key",
+  "apikey",
+  "private_key"
+];
+
+// src/security/masker.ts
+var REDACTED = "\u2022\u2022\u2022\u2022\u2022\u2022\u2022\u2022";
+var Masker = class {
+  keys;
+  constructor(sensitiveKeys = DEFAULT_SENSITIVE_KEYS) {
+    this.keys = new Set(sensitiveKeys.map((k) => k.toLowerCase()));
+  }
+  isSensitive(key) {
+    const k = key.toLowerCase();
+    for (const sensitive of this.keys) {
+      if (k === sensitive || k.includes(sensitive)) return true;
+    }
+    return false;
+  }
+  /** Shallow-masks a flat object (headers, query, cookies, single-level body). */
+  maskShallow(obj) {
+    const result = {};
+    for (const [key, value] of Object.entries(obj ?? {})) {
+      result[key] = this.isSensitive(key) ? REDACTED : value;
+    }
+    return result;
+  }
+  /** Recursively masks nested objects/arrays (request/response bodies). */
+  maskDeep(value, depth = 0) {
+    if (depth > 8 || value === null || typeof value !== "object") return value;
+    if (Array.isArray(value)) {
+      return value.map((v) => this.maskDeep(v, depth + 1));
+    }
+    const out = {};
+    for (const [key, v] of Object.entries(value)) {
+      out[key] = this.isSensitive(key) ? REDACTED : this.maskDeep(v, depth + 1);
+    }
+    return out;
+  }
+};
+
+// src/collectors/request.collector.ts
+var HTTP_STATUS_MESSAGES = {
+  100: "Continue",
+  101: "Switching Protocols",
+  200: "OK",
+  201: "Created",
+  202: "Accepted",
+  204: "No Content",
+  301: "Moved Permanently",
+  302: "Found",
+  304: "Not Modified",
+  400: "Bad Request",
+  401: "Unauthorized",
+  403: "Forbidden",
+  404: "Not Found",
+  405: "Method Not Allowed",
+  409: "Conflict",
+  422: "Unprocessable Entity",
+  429: "Too Many Requests",
+  500: "Internal Server Error",
+  502: "Bad Gateway",
+  503: "Service Unavailable"
+};
+function statusMessage(code) {
+  return HTTP_STATUS_MESSAGES[code] ?? "Unknown";
+}
+var RequestCollector = class {
+  constructor(masker = new Masker()) {
+    this.masker = masker;
+  }
+  masker;
+  data = null;
+  getName() {
+    return "request";
+  }
+  /** Parses the buffered response body as JSON when the response declared a JSON content-type — undefined otherwise (HTML pages, empty bodies, non-JSON payloads), so the detail view falls back to its "no body captured" state instead of dumping raw bytes. */
+  parseResponseBody(ctx) {
+    if (!ctx.responseBody || !ctx.responseBody.contentType.includes("application/json")) return void 0;
+    const text = ctx.responseBody.buffer.toString("utf8").trim();
+    if (!text) return void 0;
+    try {
+      return this.masker.maskDeep(JSON.parse(text));
+    } catch {
+      return void 0;
+    }
+  }
+  /** Parses Set-Cookie response header(s) into name -> value, mirroring how request cookies are captured — masked per cookie name (Masker), not blanket-redacted like the raw "set-cookie" header. */
+  parseResponseCookies(res) {
+    const raw = res.getHeader("set-cookie");
+    const setCookies = Array.isArray(raw) ? raw.map(String) : raw ? [String(raw)] : [];
+    const cookies = {};
+    for (const setCookie of setCookies) {
+      const pair = setCookie.split(";")[0];
+      const eq = pair.indexOf("=");
+      if (eq === -1) continue;
+      const name = pair.slice(0, eq).trim();
+      if (!name) continue;
+      try {
+        cookies[name] = decodeURIComponent(pair.slice(eq + 1).trim());
+      } catch {
+        cookies[name] = pair.slice(eq + 1).trim();
+      }
+    }
+    return this.masker.maskShallow(cookies);
+  }
+  /**
+   * Reads `req.session` (express-session or any middleware that assigns a
+   * plain, JSON-serializable object there) — own data properties only,
+   * methods (save/destroy/reload/...) live on the prototype so a plain
+   * Object.entries() already excludes them. Returns undefined (not `{}`)
+   * when there's no session object at all, so the Session tab can tell
+   * "this app doesn't use sessions" apart from "session exists but empty".
+   */
+  parseSession(req) {
+    const session = req.session;
+    if (!session || typeof session !== "object") return void 0;
+    const data = {};
+    for (const [key, value] of Object.entries(session)) {
+      if (typeof value === "function") continue;
+      data[key] = value;
+    }
+    return this.masker.maskDeep(data);
+  }
+  collect(ctx) {
+    const { req, res } = ctx;
+    const statusCode = res.statusCode;
+    this.data = {
+      method: req.method,
+      url: req.originalUrl || req.url,
+      statusCode,
+      statusMessage: statusMessage(statusCode),
+      request: {
+        method: req.method,
+        url: req.originalUrl || req.url,
+        headers: this.masker.maskShallow(req.headers),
+        query: this.masker.maskDeep(req.query ?? {}),
+        body: this.masker.maskDeep(req.body ?? {}),
+        params: req.params ?? {},
+        ip: req.ip ?? req.socket?.remoteAddress ?? "unknown",
+        cookies: this.masker.maskShallow(req.cookies ?? {}),
+        protocol: req.protocol,
+        hostname: req.hostname,
+        session: this.parseSession(req)
+      },
+      response: {
+        statusCode,
+        statusMessage: statusMessage(statusCode),
+        headers: this.masker.maskShallow(res.getHeaders()),
+        contentType: res.getHeader("content-type"),
+        cookies: this.parseResponseCookies(res),
+        body: this.parseResponseBody(ctx)
+      },
+      route: {
+        path: req.route?.path ?? req.url,
+        method: req.method,
+        params: req.params ?? {},
+        controller: req.route?.stack?.[0]?.name
+      }
+    };
+  }
+  getData() {
+    if (!this.data) {
+      throw new Error("RequestCollector.getData() called before collect()");
+    }
+    return this.data;
+  }
+  reset() {
+    this.data = null;
+  }
+};
+
+// src/collectors/time.collector.ts
+var TimeCollector = class {
+  data = null;
+  phases = [];
+  getName() {
+    return "time";
+  }
+  /** Records a named checkpoint at the current elapsed time, relative to the active request's start. */
+  mark(name) {
+    const startHr = getActiveProfilingState()?.startHrTime;
+    if (!startHr) return;
+    const elapsedNs = process.hrtime.bigint() - startHr;
+    this.phases.push({ name, offset: Number(elapsedNs / 1000000n) });
+  }
+  collect(ctx) {
+    const durationNs = process.hrtime.bigint() - ctx.startHrTime;
+    this.data = {
+      startedAt: ctx.startTime,
+      duration: Number(durationNs / 1000000n),
+      phases: [...this.phases]
+    };
+  }
+  getData() {
+    if (!this.data) {
+      throw new Error("TimeCollector.getData() called before collect()");
+    }
+    return this.data;
+  }
+  reset() {
+    this.data = null;
+    this.phases.length = 0;
+  }
+};
+
+// src/collectors/memory.collector.ts
+var MemoryCollector = class {
+  data = null;
+  getName() {
+    return "memory";
+  }
+  collect(ctx) {
+    const heapUsedAfter = process.memoryUsage().heapUsed;
+    this.data = {
+      heapUsedBefore: ctx.heapUsedBefore,
+      heapUsedAfter,
+      delta: heapUsedAfter - ctx.heapUsedBefore
+    };
+  }
+  getData() {
+    if (!this.data) {
+      throw new Error("MemoryCollector.getData() called before collect()");
+    }
+    return this.data;
+  }
+  reset() {
+    this.data = null;
+  }
+};
+
+// src/collectors/database.collector.ts
+var DatabaseCollector = class {
+  queries = [];
+  getName() {
+    return "database";
+  }
+  record(query) {
+    this.queries.push({ ...query, timestamp: Date.now() });
+  }
+  collect(_ctx) {
+  }
+  getData() {
+    return [...this.queries];
+  }
+  reset() {
+    this.queries.length = 0;
+  }
+};
+
+// src/collectors/logger.collector.ts
+var LoggerCollector = class {
+  logs = [];
+  getName() {
+    return "logger";
+  }
+  record(entry) {
+    this.logs.push({ ...entry, timestamp: Date.now() });
+  }
+  collect(_ctx) {
+  }
+  getData() {
+    return [...this.logs];
+  }
+  byLevel(level) {
+    return this.logs.filter((l) => l.level === level);
+  }
+  reset() {
+    this.logs.length = 0;
+  }
+};
+
+// src/collectors/exception.collector.ts
+var ExceptionCollector = class {
+  error = null;
+  getName() {
+    return "exception";
+  }
+  setError(err) {
+    if (this.error) return;
+    this.error = {
+      name: err.name || "Error",
+      message: err.message,
+      stack: err.stack ?? ""
+    };
+  }
+  collect(_ctx, error) {
+    if (error) this.setError(error);
+  }
+  getData() {
+    return { error: this.error };
+  }
+  reset() {
+    this.error = null;
+  }
+};
+
+// src/collectors/index.ts
+function createBuiltinCollectorFactories(security) {
+  const masker = new Masker(security.sensitiveKeys);
+  return [
+    () => new RequestCollector(masker),
+    () => new TimeCollector(),
+    () => new MemoryCollector(),
+    () => new DatabaseCollector(),
+    () => new LoggerCollector(),
+    () => new ExceptionCollector()
+  ];
+}
+
+// src/middleware/htmlInjector.ts
+function installHtmlInjection(res, buildSnippet, onCapture) {
+  const chunks = [];
+  let intercepting = true;
+  const originalWrite = res.write.bind(res);
+  const originalEnd = res.end.bind(res);
+  function toBuffer(chunk, encoding) {
+    if (chunk === void 0 || chunk === null) return null;
+    if (Buffer.isBuffer(chunk)) return chunk;
+    const enc = typeof encoding === "string" ? encoding : "utf8";
+    return Buffer.from(chunk, enc);
+  }
+  res.write = function(chunk, ...rest) {
+    if (!intercepting) return originalWrite(chunk, ...rest);
+    const buf = toBuffer(chunk, rest[0]);
+    if (buf) chunks.push(buf);
+    return true;
+  };
+  res.end = function(chunk, ...rest) {
+    if (!intercepting) return originalEnd(chunk, ...rest);
+    intercepting = false;
+    const buf = toBuffer(chunk, rest[0]);
+    if (buf) chunks.push(buf);
+    const contentType = String(res.getHeader("content-type") ?? "");
+    const isHtml = contentType.includes("text/html");
+    let body = Buffer.concat(chunks);
+    if (isHtml && !res.headersSent) {
+      const text = body.toString("utf8");
+      if (/<\/body>/i.test(text)) {
+        const injected = text.replace(/<\/body>/i, `${buildSnippet()}
+</body>`);
+        body = Buffer.from(injected, "utf8");
+        res.setHeader("Content-Length", Buffer.byteLength(body));
+      }
+    }
+    onCapture?.(body, contentType);
+    return originalEnd(body);
+  };
+}
+
+// src/utils/i18n.ts
+var import_fs = require("fs");
+var import_path = require("path");
+
+// src/security/escape.ts
+function escapeHtml(value) {
+  return String(value ?? "").replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
+}
+
+// src/utils/i18n.ts
+var SUPPORTED_LANGUAGES = ["en", "fr"];
+var DEFAULT_LANGUAGE = "en";
+var LANG_COOKIE = "opticore_profiler_lang";
+var LANG_LABELS = { en: "English", fr: "Fran\xE7ais" };
+function isSupportedLanguage(value) {
+  return typeof value === "string" && SUPPORTED_LANGUAGES.includes(value);
+}
+var dictionaryCache = /* @__PURE__ */ new Map();
+function loadDictionary(lang) {
+  const cached = dictionaryCache.get(lang);
+  if (cached) return cached;
+  const path = (0, import_path.join)(__dirname, "utils", "translations", `message.translation.${lang}.json`);
+  let dict = {};
+  try {
+    dict = JSON.parse((0, import_fs.readFileSync)(path, "utf8"));
+  } catch {
+    dict = {};
+  }
+  dictionaryCache.set(lang, dict);
+  return dict;
+}
+var SafeHtml = class {
+  constructor(value) {
+    this.value = value;
+  }
+  value;
+};
+function safeHtml(value) {
+  return new SafeHtml(value);
+}
+function createTranslator(lang) {
+  const dict = loadDictionary(lang);
+  const fallback = lang === DEFAULT_LANGUAGE ? dict : loadDictionary(DEFAULT_LANGUAGE);
+  return function t(key, vars) {
+    let str = dict[key] ?? fallback[key] ?? key;
+    if (vars) {
+      for (const [name, value] of Object.entries(vars)) {
+        const rendered = value instanceof SafeHtml ? value.value : escapeHtml(value);
+        str = str.split(`{${name}}`).join(rendered);
+      }
+    }
+    return str;
+  };
+}
+function parseCookie(header, name) {
+  if (!header) return void 0;
+  for (const part of header.split(";")) {
+    const eq = part.indexOf("=");
+    if (eq === -1) continue;
+    if (part.slice(0, eq).trim() === name) {
+      try {
+        return decodeURIComponent(part.slice(eq + 1).trim());
+      } catch {
+        return part.slice(eq + 1).trim();
+      }
+    }
+  }
+  return void 0;
+}
+function resolveLanguage(req, res) {
+  const queryLang = req.query?.lang;
+  if (isSupportedLanguage(queryLang)) {
+    res.setHeader("Set-Cookie", `${LANG_COOKIE}=${queryLang}; Path=/; Max-Age=31536000; SameSite=Lax`);
+    return queryLang;
+  }
+  const cookieLang = parseCookie(req.headers?.cookie, LANG_COOKIE);
+  if (isSupportedLanguage(cookieLang)) return cookieLang;
+  return DEFAULT_LANGUAGE;
+}
+function languageOptions(current) {
+  return SUPPORTED_LANGUAGES.map((code) => ({
+    code,
+    label: LANG_LABELS[code],
+    active: code === current
+  }));
+}
+
+// src/middleware/snippet.ts
+function buildToolbarSnippet(token, routePrefix, lang) {
+  const t = createTranslator(lang);
+  const i18n = {
+    lastNRequests: t("toolbar.last_n_requests"),
+    viewAll: t("toolbar.view_all")
+  };
+  return `<link rel="stylesheet" href="${routePrefix}/assets/css/toolbar-standalone.css">
+<div id="opticore-wdt-mount"></div>
+<script>
+(function () {
+  window.__opticoreProfilerToken = "${token}";
+  window.__opticoreProfilerRoutePrefix = "${routePrefix}";
+  window.__opticoreProfilerI18n = ${JSON.stringify(i18n)};
+  fetch("${routePrefix}/wdt/${token}", { credentials: "same-origin" })
+    .then(function (r) { return r.text(); })
+    .then(function (html) {
+      document.getElementById("opticore-wdt-mount").outerHTML = html;
+      let s = document.createElement("script");
+      s.src = "${routePrefix}/assets/js/toolbar.js";
+      document.body.appendChild(s);
+    })
+    .catch(function () {});
+})();
+</script>`;
+}
+
+// src/middleware/errorHandler.middleware.ts
+function profilerErrorHandler() {
+  return function(err, _req, _res, next) {
+    getActiveCollector("exception")?.setError(err);
+    next(err);
+  };
+}
+var processHandlersRegistered = false;
+function registerProcessErrorCapture() {
+  if (processHandlersRegistered) return;
+  processHandlersRegistered = true;
+  process.on("uncaughtExceptionMonitor", (err) => {
+    try {
+      getActiveCollector("exception")?.setError(err);
+    } catch {
+    }
+  });
+  process.on("unhandledRejection", (reason) => {
+    try {
+      const err = reason instanceof Error ? reason : new Error(String(reason));
+      getActiveCollector("exception")?.setError(err);
+    } catch {
+    }
+  });
+}
+
+// src/middleware/profiler.middleware.ts
+var DEFAULT_ROUTE_PREFIX = "/_profiler";
+var DEFAULT_MAX_REQUESTS = 10;
+var DEFAULT_RETENTION_MS = 24 * 60 * 60 * 1e3;
+function isUnderPrefix(path, prefix) {
+  return path === prefix || path.startsWith(`${prefix}/`);
+}
+function isExcludedPath(path, excludePaths) {
+  return excludePaths.some(
+    (pattern) => pattern.endsWith("/*") ? path.startsWith(pattern.slice(0, -1)) : path === pattern
+  );
+}
+function opticoreProfiler(options) {
+  const enabled = options.enabled ?? false;
+  const routePrefix = options.routePrefix ?? DEFAULT_ROUTE_PREFIX;
+  const storage = options.storage;
+  const retentionMs = options.retentionMs ?? DEFAULT_RETENTION_MS;
+  const maxRequests = options.maxRequests ?? DEFAULT_MAX_REQUESTS;
+  const excludePaths = options.excludePaths ?? [...DEFAULT_EXCLUDE_PATHS];
+  const security = {
+    sensitiveKeys: options.security?.sensitiveKeys ?? [...DEFAULT_SENSITIVE_KEYS],
+    maxUrlLength: options.security?.maxUrlLength ?? 100
+  };
+  const events = new import_events.EventEmitter();
+  events.setMaxListeners(0);
+  const registry = new CollectorRegistry();
+  if (options.collectors) {
+    for (const factory of options.collectors) registry.register(factory);
+  } else {
+    for (const factory of createBuiltinCollectorFactories(security)) registry.register(factory);
+  }
+  if (enabled) registerProcessErrorCapture();
+  const middleware = function opticoreProfilerMiddleware(req, res, next) {
+    if (!enabled || isUnderPrefix(req.path, routePrefix) || isExcludedPath(req.path, excludePaths)) {
+      next();
+      return;
+    }
+    const token = generateToken(8);
+    const startTime = Date.now();
+    const startHrTime = process.hrtime.bigint();
+    const heapUsedBefore = process.memoryUsage().heapUsed;
+    const collectors = registry.createAll();
+    res.setHeader("X-Debug-Token", token);
+    res.setHeader("X-Debug-Token-Link", `${routePrefix}/${token}`);
+    let responseBody;
+    const lang = resolveLanguage(req, res);
+    installHtmlInjection(res, () => buildToolbarSnippet(token, routePrefix, lang), (buffer, contentType) => {
+      responseBody = { buffer, contentType };
+    });
+    res.on("finish", () => {
+      void (async () => {
+        for (const collector of collectors.values()) {
+          try {
+            await collector.collect({ token, req, res, startTime, startHrTime, heapUsedBefore, responseBody });
+          } catch {
+          }
+        }
+        const requestData = collectors.get("request")?.getData();
+        const timeData = collectors.get("time")?.getData();
+        const profile = {
+          token,
+          ip: requestData?.request.ip ?? req.ip ?? "unknown",
+          method: requestData?.method ?? req.method,
+          url: requestData?.url ?? req.originalUrl ?? req.url,
+          statusCode: res.statusCode,
+          time: startTime,
+          duration: timeData?.duration ?? Date.now() - startTime,
+          contentType: res.getHeader("content-type"),
+          collectors: Object.fromEntries([...collectors].map(([name, c]) => [name, c.getData()]))
+        };
+        try {
+          await storage.write(profile);
+          events.emit("profile", profile);
+          if (retentionMs > 0) await storage.purge(retentionMs);
+        } catch {
+        }
+      })();
+    });
+    runWithProfilerContext({ token, collectors, startTime, startHrTime }, () => next());
+  };
+  middleware.registry = registry;
+  middleware.options = Object.freeze({ enabled, routePrefix, storage, retentionMs, maxRequests, excludePaths, security });
+  middleware.clear = () => storage.clear();
+  middleware.events = events;
+  return middleware;
+}
+
+// src/module.ts
+var import_path3 = require("path");
+var import_opticore_express = require("opticore-express");
+var import_opticore_router = require("opticore-router");
+
+// src/core/viewEngine.config.ts
+var import_path2 = require("path");
+var import_nunjucks = __toESM(require("nunjucks"), 1);
+var configured = false;
+function configureProfilerViewEngine(app) {
+  if (configured) return;
+  configured = true;
+  const viewsDir = (0, import_path2.join)(__dirname, "views", "templates");
+  import_nunjucks.default.configure(viewsDir, {
+    autoescape: true,
+    express: app,
+    noCache: process.env.NODE_ENV !== "production"
+  });
+  app.set("views", viewsDir);
+}
+
+// src/core/routeIntrospection.ts
+var _expressApp = null;
+function setIntrospectedApp(app) {
+  _expressApp = app;
+}
+function getLayerPrefix(layer) {
+  try {
+    const src = layer.regexp?.source ?? "";
+    if (!src) return "";
+    if (src === "^\\/?(?=\\/|$)" || src === "^\\/(?=\\/|$)" || src === "^\\/?$" || src === "^\\/$") return "";
+    let s = src.startsWith("^") ? src.slice(1) : src;
+    const markers = ["\\/?(?=", "(?=\\/", "\\/?$", "(?=$)"];
+    let endIdx = s.length;
+    for (const m of markers) {
+      const i = s.indexOf(m);
+      if (i !== -1 && i < endIdx) endIdx = i;
+    }
+    s = s.slice(0, endIdx);
+    s = s.replace(/\\\//g, "/").replace(/\\\./g, ".");
+    if (s.endsWith("/?")) s = s.slice(0, -2);
+    return s && s !== "/" ? s : "";
+  } catch {
+    return "";
+  }
+}
+function extractRoutesFromApp(app) {
+  const result = [];
+  function traverse(stack, prefix) {
+    for (const layer of stack ?? []) {
+      if (!layer) continue;
+      if (layer.route) {
+        const methods = Object.keys(layer.route.methods ?? {}).filter((m) => layer.route.methods[m]).map((m) => m.toUpperCase());
+        const routePath = String(layer.route.path ?? "");
+        const fullPath = (prefix + routePath).replace(/\/+/g, "/") || "/";
+        for (const method of methods) {
+          result.push({
+            method,
+            path: fullPath,
+            middlewareCount: layer.route.stack?.length ?? 1
+          });
+        }
+      } else if (layer.handle && typeof layer.handle === "function" && layer.handle.stack) {
+        const seg = getLayerPrefix(layer);
+        traverse(layer.handle.stack, prefix + seg);
+      }
+    }
+  }
+  const router = app._router ?? app.router;
+  traverse(router?.stack ?? [], "");
+  return result;
+}
+function getExpressRoutes() {
+  if (!_expressApp) return [];
+  return extractRoutesFromApp(_expressApp);
+}
+
+// src/controllers/profiler.controller.ts
+var import_child_process = require("child_process");
+
+// src/view/legacyAdapter.ts
+function toLegacyProfile(profile) {
+  const requestData = profile.collectors.request;
+  const timeData = profile.collectors.time;
+  const memoryData = profile.collectors.memory;
+  const queries = profile.collectors.database ?? [];
+  const logs = [...profile.collectors.logger ?? []];
+  const exceptionData = profile.collectors.exception;
+  if (exceptionData?.error) {
+    logs.push({
+      level: "critical",
+      message: `${exceptionData.error.name}: ${exceptionData.error.message}`,
+      timestamp: profile.time,
+      context: { stack: exceptionData.error.stack }
+    });
+  }
+  return {
+    token: profile.token,
+    timestamp: profile.time,
+    method: requestData?.method ?? profile.method,
+    url: requestData?.url ?? profile.url,
+    statusCode: requestData?.statusCode ?? profile.statusCode,
+    statusMessage: requestData?.statusMessage ?? "",
+    duration: timeData?.duration ?? profile.duration,
+    memoryUsage: memoryData?.heapUsedAfter ?? 0,
+    queries,
+    logs,
+    route: requestData?.route ?? { path: profile.url, method: profile.method, params: {} },
+    request: requestData?.request ?? {
+      method: profile.method,
+      url: profile.url,
+      headers: {},
+      query: {},
+      body: {},
+      params: {},
+      ip: profile.ip
+    },
+    response: requestData?.response ?? { statusCode: profile.statusCode, statusMessage: "", headers: {}, contentType: profile.contentType },
+    performance: [],
+    nodeVersion: process.version,
+    appVersion: process.env.npm_package_version ?? "1.0.0",
+    environment: process.env.NODE_ENV ?? "development"
+  };
+}
+
+// src/core/render.util.ts
+function renderView(req, res, view, data = {}) {
+  const lang = resolveLanguage(req, res);
+  const t = createTranslator(lang);
+  const fullData = { ...data, t, lang, languages: languageOptions(lang), safeHtml };
+  return new Promise((resolve, reject) => {
+    res.render(view, fullData, (err, html) => {
+      if (err) {
+        reject(err);
+        return;
+      }
+      res.setHeader("Cache-Control", "no-store");
+      res.send(html);
+      resolve();
+    });
+  });
+}
+
+// src/view/helpers.view.ts
+function statusClass(code) {
+  if (code >= 500) return "s-error";
+  if (code >= 400) return "s-warn";
+  if (code >= 300) return "s-redirect";
+  return "s-ok";
+}
+function formatDuration(ms) {
+  return ms < 1e3 ? `${ms} ms` : `${(ms / 1e3).toFixed(2)} s`;
+}
+function formatMemory(bytes) {
+  return `${(Math.max(0, bytes) / 1024 / 1024).toFixed(1)} MiB`;
+}
+function sqlTotalTime(profile) {
+  return profile.queries.reduce((sum, q) => sum + q.duration, 0);
+}
+function highlightJson(value) {
+  const pretty = JSON.stringify(value, null, 2);
+  return pretty.split("\n").map((line) => {
+    const m = line.match(/^(\s*)"((?:[^"\\]|\\.)*)":\s*(.*)$/);
+    if (!m) return escapeHtml(line);
+    const [, indent, key, rest] = m;
+    return `${indent}<span class="json-key">"${escapeHtml(key)}"</span>: <span class="json-val">${escapeHtml(rest)}</span>`;
+  }).join("\n");
+}
+
+// src/view/toolbar.view.ts
+function computeMetrics(profile, httpCount) {
+  return {
+    sqlTotalTime: sqlTotalTime(profile),
+    sqlCount: profile.queries.length,
+    logCount: profile.logs.length,
+    logErrors: profile.logs.filter((l) => l.level === "error" || l.level === "critical").length,
+    logWarnings: profile.logs.filter((l) => l.level === "warning").length,
+    logDeprecations: profile.logs.filter((l) => l.level === "deprecation").length,
+    httpCount,
+    memoryFormatted: formatMemory(profile.memoryUsage),
+    durationFormatted: formatDuration(profile.duration),
+    statusClass: statusClass(profile.statusCode)
+  };
+}
+function truncateUrl(url, maxLen) {
+  if (url.length <= maxLen) return url;
+  return url.slice(0, maxLen - 1) + "\u2026";
+}
+function isApiRequest(profile) {
+  return !(profile.response.contentType ?? "").toLowerCase().startsWith("text/html");
+}
+function buildToolbarBarViewModel(profile, recentProfiles, security, routePrefix, maxRequests) {
+  const apiProfiles = recentProfiles.filter(isApiRequest);
+  const metrics = computeMetrics(profile, apiProfiles.length);
+  const base = `${routePrefix}/${profile.token}`;
+  const httpRows = apiProfiles.slice(0, maxRequests).map((p) => ({
+    isCurrent: p.token === profile.token,
+    method: p.method,
+    url: truncateUrl(p.url, security.maxUrlLength),
+    fullUrl: p.url,
+    token: p.token,
+    statusCode: p.statusCode,
+    statusClass: p.statusCode >= 400 ? "tip-s-err" : p.statusCode >= 300 ? "tip-s-redir" : "tip-s-ok",
+    duration: formatDuration(p.duration)
+  }));
+  return {
+    statusCode: profile.statusCode,
+    statusMessage: profile.statusMessage,
+    profilerUrl: base,
+    statusCls: metrics.statusClass,
+    appVersion: profile.appVersion,
+    nodeVersion: profile.nodeVersion,
+    environment: profile.environment,
+    method: profile.method,
+    url: profile.url,
+    token: profile.token,
+    base,
+    duration: {
+      formatted: metrics.durationFormatted,
+      barWidth: Math.min(metrics.sqlTotalTime / 2, 100),
+      appFormatted: metrics.durationFormatted,
+      dbFormatted: metrics.sqlCount > 0 ? formatDuration(metrics.sqlTotalTime) : "0 ms"
+    },
+    memory: { formatted: metrics.memoryFormatted },
+    logs: { count: metrics.logCount, errors: metrics.logErrors, warnings: metrics.logWarnings, deprecations: metrics.logDeprecations },
+    route: { label: profile.route.path || profile.url, method: profile.route.method || profile.method },
+    http: { count: metrics.httpCount, rows: httpRows }
+  };
+}
+
+// src/view/profilerList.view.ts
+function statusClassOf(code) {
+  if (code >= 400) return "error";
+  if (code >= 300) return "redirect";
+  return "ok";
+}
+function fmtDate(ts) {
+  return new Date(ts).toLocaleDateString("en-US", { month: "long", day: "numeric", year: "numeric" });
+}
+function fmtClock(ts) {
+  return new Date(ts).toLocaleTimeString("en-US", { hour: "2-digit", minute: "2-digit", second: "2-digit" });
+}
+function toProfilerListRow(p) {
+  return {
+    token: p.token,
+    tokenShort: p.token.slice(0, 6),
+    statusCode: p.statusCode,
+    statusClass: statusClassOf(p.statusCode),
+    method: p.method,
+    url: p.url,
+    dateStr: fmtDate(p.timestamp),
+    timeStr: fmtClock(p.timestamp),
+    duration: p.duration,
+    contentType: p.response.contentType
+  };
+}
+function tabHref(tab, search, method, status, ip, token, from, until, limit) {
+  const params = new URLSearchParams();
+  if (search) params.set("search", search);
+  if (method) params.set("method", method);
+  if (status) params.set("status", status);
+  if (ip) params.set("ip", ip);
+  if (token) params.set("token", token);
+  if (from) params.set("from", from);
+  if (until) params.set("until", until);
+  if (limit !== 10) params.set("limit", String(limit));
+  if (tab !== "requests") params.set("tab", tab);
+  const qs = params.toString();
+  return `/_profiler${qs ? "?" + qs : ""}`;
+}
+function buildProfilerListViewModel(profiles, search = "", method = "", status = "", limit = 10, ip = "", token = "", from = "", until = "", tab = "requests") {
+  let filtered = [...profiles];
+  if (ip) {
+    filtered = filtered.filter((p) => (p.request?.ip ?? "").toLowerCase().includes(ip.toLowerCase()));
+  }
+  if (token) {
+    filtered = filtered.filter((p) => p.token.toLowerCase().startsWith(token.toLowerCase()));
+  }
+  if (search) {
+    const q = search.toLowerCase();
+    filtered = filtered.filter(
+      (p) => p.url.toLowerCase().includes(q) || p.method.toLowerCase().includes(q) || p.token.toLowerCase().includes(q) || (p.request?.ip ?? "").toLowerCase().includes(q) || String(p.statusCode).includes(q)
+    );
+  }
+  if (method) {
+    filtered = filtered.filter((p) => p.method === method.toUpperCase());
+  }
+  if (status) {
+    const code = parseInt(status, 10);
+    if (code >= 100) {
+      filtered = filtered.filter((p) => p.statusCode === code);
+    } else if (code >= 1 && code <= 9) {
+      const prefix = code * 100;
+      filtered = filtered.filter((p) => p.statusCode >= prefix && p.statusCode < prefix + 100);
+    }
+  }
+  if (from) {
+    const ts = new Date(from).getTime();
+    if (!isNaN(ts)) filtered = filtered.filter((p) => p.timestamp >= ts);
+  }
+  if (until) {
+    const ts = new Date(until).getTime() + 86399999;
+    if (!isNaN(ts)) filtered = filtered.filter((p) => p.timestamp <= ts);
+  }
+  filtered = filtered.slice(0, limit);
+  const isFiltered = !!(search || method || status || ip || token || from || until);
+  const rows = filtered.map(toProfilerListRow);
+  return {
+    tab,
+    resultCount: filtered.length,
+    rows,
+    autoReload: !isFiltered && tab === "requests",
+    filters: {
+      ip,
+      status,
+      search,
+      token,
+      from,
+      until,
+      hasProfiles: profiles.length > 0,
+      methodOptions: ["Any", "GET", "POST", "PUT", "DELETE", "PATCH", "OPTIONS"].map((m) => {
+        const value = m === "Any" ? "" : m;
+        return { value, label: m, selected: method === value };
+      }),
+      limitOptions: [10, 25, 50, 100].map((n) => ({ value: n, selected: limit === n }))
+    },
+    tabs: {
+      requests: { href: tabHref("requests", search, method, status, ip, token, from, until, limit), active: tab === "requests" },
+      commands: { href: tabHref("commands", search, method, status, ip, token, from, until, limit), active: tab === "commands" }
+    }
+  };
+}
+
+// src/view/profilerDetail.view.ts
+function toKvRows(obj) {
+  return Object.entries(obj).map(([key, v]) => ({
+    key,
+    value: typeof v === "object" && v !== null ? JSON.stringify(v, null, 2) : String(v)
+  }));
+}
+function headersToRows(headers) {
+  return Object.entries(headers ?? {}).map(([key, value]) => ({ key, value }));
+}
+function buildCurlCommand(profile) {
+  const headers = profile.request.headers ?? {};
+  const host = headers.host ?? profile.request.hostname ?? "localhost";
+  const protocol = profile.request.protocol ?? "http";
+  const url = `${protocol}://${host}${profile.url}`;
+  const lines = ["curl \\", "  --compressed \\", `  --url '${url}' \\`];
+  for (const [name, value] of Object.entries(headers)) {
+    const k = name.toLowerCase();
+    if (k === "host" || k === "content-length" || k === "cookie") continue;
+    lines.push(`  --header '${name}: ${value}' \\`);
+  }
+  if (headers.cookie) lines.push(`  --cookie '${headers.cookie}' \\`);
+  const body = profile.request.body ?? {};
+  if (Object.keys(body).length > 0) {
+    lines.push(`  --data '${JSON.stringify(body)}' \\`);
+  }
+  const last = lines.pop();
+  lines.push(last.replace(/ \\$/, ""));
+  return lines.join("\n");
+}
+function buildRequestPanel(profile) {
+  const cookies = profile.request.cookies ?? {};
+  const responseCookies = profile.response.cookies ?? {};
+  const body = profile.request.body ?? {};
+  const hasBody = Object.keys(body).length > 0;
+  const headers = profile.request.headers ?? {};
+  return {
+    statusOk: profile.statusCode < 400,
+    statusCode: profile.statusCode,
+    durationFormatted: formatDuration(profile.duration),
+    memoryFormatted: formatMemory(profile.memoryUsage),
+    sqlQueryCount: profile.queries.length,
+    getParams: toKvRows(profile.request.query ?? {}),
+    postParamsJson: hasBody ? highlightJson(body) : null,
+    uploadedFiles: [],
+    routeParams: toKvRows(profile.request.params ?? {}),
+    attributes: [
+      { key: "_method", value: profile.method },
+      { key: "_route", value: profile.route.path },
+      { key: "_controller", value: profile.route.controller ?? "unknown" },
+      { key: "_ip", value: profile.request.ip },
+      { key: "_hostname", value: profile.request.hostname ?? "localhost" },
+      { key: "_protocol", value: profile.request.protocol ?? "http" }
+    ],
+    requestHeaders: headersToRows(headers),
+    responseHeaders: headersToRows(profile.response.headers),
+    hasCookies: Object.keys(cookies).length > 0,
+    cookies: toKvRows(cookies),
+    hasResponseCookies: Object.keys(responseCookies).length > 0,
+    responseCookies: toKvRows(responseCookies),
+    requestContentJson: hasBody ? highlightJson(body) : null,
+    responseBodyJson: profile.response.body ? highlightJson(profile.response.body) : null,
+    retryCommandCurl: buildCurlCommand(profile),
+    serverParams: [
+      { key: "HTTP_HOST", value: headers.host ?? profile.request.hostname ?? "localhost" },
+      { key: "HTTP_USER_AGENT", value: headers["user-agent"] ?? "" },
+      { key: "REQUEST_METHOD", value: profile.method },
+      { key: "REQUEST_URI", value: profile.url },
+      { key: "SERVER_PROTOCOL", value: (profile.request.protocol ?? "http").toUpperCase() },
+      { key: "REMOTE_ADDR", value: profile.request.ip },
+      { key: "NODE_ENV", value: profile.environment },
+      { key: "NODE_VERSION", value: profile.nodeVersion },
+      { key: "APP_VERSION", value: profile.appVersion }
+    ],
+    hasSession: profile.request.session !== void 0,
+    session: toKvRows(profile.request.session ?? {})
+  };
+}
+function buildPerformancePanel(profile) {
+  const total = profile.duration;
+  const sqlTime = sqlTotalTime(profile);
+  const appTime = Math.max(0, total - sqlTime);
+  const rawEvents = [
+    { label: "kernel.request  (Application)", duration: appTime, color: "#C87A3C" },
+    ...sqlTime > 0 ? [{ label: "kernel.response (Database SQL)", duration: sqlTime, color: "#2D6A4A" }] : []
+  ].filter((e) => e.duration > 0);
+  const events = rawEvents.map((e) => {
+    const pct = total > 0 ? Math.min(e.duration / total * 100, 100) : 0;
+    return {
+      label: e.label,
+      widthPct: Math.max(pct, 0.5).toFixed(1),
+      color: e.color,
+      durationFormatted: formatDuration(e.duration)
+    };
+  });
+  return {
+    total,
+    appTime,
+    memoryMiB: (Math.max(0, profile.memoryUsage) / 1024 / 1024).toFixed(2),
+    hasEvents: events.length > 0,
+    events,
+    hasSqlTime: sqlTime > 0,
+    processInfo: [
+      { key: "Node.js version", value: profile.nodeVersion },
+      { key: "App version", value: profile.appVersion },
+      { key: "Environment", badge: { text: profile.environment, variant: profile.environment === "production" ? "warn" : "info" } },
+      { key: "Process PID", value: String(process.pid) },
+      { key: "Platform", value: process.platform },
+      { key: "Heap used", value: formatMemory(process.memoryUsage().heapUsed) },
+      { key: "Heap total", value: formatMemory(process.memoryUsage().heapTotal) },
+      { key: "RSS", value: formatMemory(process.memoryUsage().rss) },
+      { key: "Uptime", value: `${Math.round(process.uptime())}s` }
+    ]
+  };
+}
+function sqlType(sql) {
+  const t = sql.trimStart().toUpperCase().slice(0, 6);
+  if (t.startsWith("SELECT")) return "SELECT";
+  if (t.startsWith("INSERT")) return "INSERT";
+  if (t.startsWith("UPDATE")) return "UPDATE";
+  if (t.startsWith("DELETE")) return "DELETE";
+  return "OTHER";
+}
+function buildDatabasePanel(profile) {
+  const queries = profile.queries;
+  const totalTime = sqlTotalTime(profile);
+  return {
+    hasQueries: queries.length > 0,
+    totalCount: queries.length,
+    totalTimeFormatted: formatDuration(totalTime),
+    avgFormatted: queries.length > 0 ? formatDuration(Math.round(totalTime / queries.length)) : "0 ms",
+    queries: queries.map((q, i) => ({
+      type: sqlType(q.sql),
+      index: i + 1,
+      hasError: !!q.error,
+      durationFormatted: formatDuration(q.duration),
+      sql: q.sql,
+      bindingsJson: q.bindings && q.bindings.length > 0 ? JSON.stringify(q.bindings) : null,
+      error: q.error ?? null
+    }))
+  };
+}
+function buildLogsPanel(profile) {
+  const logs = profile.logs;
+  if (logs.length === 0) {
+    return { hasLogs: false, errCount: 0, warnCount: 0, deprCount: 0, rows: [] };
+  }
+  const errCount = logs.filter((l) => l.level === "error" || l.level === "critical").length;
+  const warnCount = logs.filter((l) => l.level === "warning").length;
+  const deprCount = logs.filter((l) => l.level === "deprecation").length;
+  function levelCls(level) {
+    if (level === "critical") return "log-error";
+    if (level === "deprecation") return "log-deprecation";
+    return `log-${level}`;
+  }
+  function rowBorderCls(level) {
+    if (level === "error" || level === "critical") return "log-row-error";
+    if (level === "warning") return "log-row-warning";
+    if (level === "deprecation") return "log-row-deprecation";
+    return "";
+  }
+  function logType(level) {
+    if (level === "error" || level === "critical") return "error";
+    if (level === "warning") return "warning";
+    if (level === "deprecation") return "deprecation";
+    return "other";
+  }
+  const rows = logs.map((l, i) => {
+    const ctx = l.context ?? {};
+    const hasCtx = Object.keys(ctx).length > 0;
+    const hasStack = hasCtx && typeof ctx.stack === "string" && ctx.stack.length > 0;
+    const source = hasCtx && typeof ctx.source === "string" ? ctx.source : "";
+    const ctxId = `lctx${i}`;
+    const stackId = `lstk${i}`;
+    const ms = String(l.timestamp % 1e3).padStart(3, "0");
+    const timeStr = new Date(l.timestamp).toLocaleTimeString("en-US", {
+      hour: "2-digit",
+      minute: "2-digit",
+      second: "2-digit",
+      hour12: true
+    }) + "." + ms;
+    let extra = null;
+    if (hasStack) {
+      const stack = ctx.stack;
+      const ctxWithoutStack = {};
+      for (const [k, v] of Object.entries(ctx)) {
+        if (k !== "stack") ctxWithoutStack[k] = v;
+      }
+      const hasOtherCtx = Object.keys(ctxWithoutStack).length > 0;
+      extra = {
+        showContextBtn: hasOtherCtx,
+        showTraceBtn: true,
+        ctxId,
+        stackId,
+        ctxJson: hasOtherCtx ? JSON.stringify(ctxWithoutStack, null, 2) : null,
+        stackText: stack
+      };
+    } else if (hasCtx) {
+      extra = {
+        showContextBtn: true,
+        showTraceBtn: false,
+        ctxId,
+        stackId,
+        ctxJson: JSON.stringify(ctx, null, 2),
+        stackText: null
+      };
+    }
+    return {
+      rowClass: rowBorderCls(l.level),
+      logType: logType(l.level),
+      timeStr,
+      levelCls: levelCls(l.level),
+      level: l.level,
+      message: l.message,
+      source,
+      extra
+    };
+  });
+  return { hasLogs: true, errCount, warnCount, deprCount, rows };
+}
+function buildRoutingPanel(profile) {
+  const routeParams = profile.route.params ?? {};
+  const queryParams = profile.request.query ?? {};
+  return {
+    routeRows: [
+      { key: "Route", value: profile.route.path, code: true },
+      { key: "Method", badge: { text: profile.route.method, variant: "info" } },
+      { key: "Controller", value: profile.route.controller ?? "unknown" },
+      { key: "Full URL", value: profile.request.url, code: true }
+    ],
+    hasRouteParams: Object.keys(routeParams).length > 0,
+    routeParamsRows: Object.entries(routeParams).map(([key, v]) => ({ key, value: String(v), code: true })),
+    hasQueryParams: Object.keys(queryParams).length > 0,
+    queryParamsRows: Object.entries(queryParams).map(([key, v]) => ({ key, value: String(v), code: true }))
+  };
+}
+function buildConfigurationPanel(profile) {
+  const safeEnv = Object.entries(process.env).filter(([k]) => !/(PASSWORD|SECRET|KEY|TOKEN|AUTH|PASS|PRIVATE)/i.test(k)).sort(([a], [b]) => a.localeCompare(b));
+  return {
+    appInfo: [
+      { key: "App Version", value: profile.appVersion },
+      { key: "Node.js", value: profile.nodeVersion },
+      { key: "Environment", badge: { text: profile.environment, variant: profile.environment === "production" ? "warn" : "info" } },
+      { key: "Platform", value: `${process.platform} (${process.arch})` }
+    ],
+    envRows: safeEnv.map(([key, v]) => ({ key, value: v ?? "", title: v ?? "", truncate: true })),
+    envCount: safeEnv.length
+  };
+}
+function buildExceptionPanel(profile) {
+  const errLogs = profile.logs.filter((l) => l.level === "error" || l.level === "critical");
+  const isError = profile.statusCode >= 500;
+  const isNotFound = profile.statusCode === 404;
+  return {
+    noException: errLogs.length === 0 && !isError,
+    showBanner: isError || isNotFound,
+    statusCode: profile.statusCode,
+    statusMessage: profile.statusMessage,
+    method: profile.method,
+    url: profile.url,
+    errLogs: errLogs.map((l) => ({
+      levelUpper: l.level.toUpperCase(),
+      message: l.message,
+      contextJson: l.context ? highlightJson(l.context) : null
+    }))
+  };
+}
+function pathToSegments(path) {
+  const segments = [];
+  const re = /:([a-zA-Z_][a-zA-Z0-9_]*)/g;
+  let lastIndex = 0;
+  let m;
+  while ((m = re.exec(path)) !== null) {
+    if (m.index > lastIndex) segments.push({ type: "text", value: path.slice(lastIndex, m.index) });
+    segments.push({ type: "param", value: m[1] });
+    lastIndex = re.lastIndex;
+  }
+  if (lastIndex < path.length) segments.push({ type: "text", value: path.slice(lastIndex) });
+  return segments;
+}
+function methodClassOf(method) {
+  return ["GET", "POST", "PUT", "DELETE", "PATCH", "OPTIONS"].includes(method) ? `rm-${method}` : "rm-ALL";
+}
+function toRouteRows(routes) {
+  return routes.map((r) => ({
+    methodClass: methodClassOf(r.method),
+    method: r.method,
+    pathSegments: pathToSegments(r.path),
+    middlewareCount: r.middlewareCount
+  }));
+}
+function buildRoutesPanel(routes) {
+  if (routes.length === 0) {
+    return {
+      hasRoutes: false,
+      totalRoutes: 0,
+      appRoutesCount: 0,
+      methodCounts: [],
+      hasAppRoutes: false,
+      appRoutesRows: [],
+      hasDebugRoutes: false,
+      debugRoutesRows: []
+    };
+  }
+  const methods = [...new Set(routes.map((r) => r.method))].sort();
+  const appRoutes = routes.filter((r) => !r.path.startsWith("/_profiler") && r.path !== "/");
+  const debugRoutes = routes.filter((r) => r.path.startsWith("/_profiler") || r.path === "/");
+  return {
+    hasRoutes: true,
+    totalRoutes: routes.length,
+    appRoutesCount: appRoutes.length,
+    methodCounts: methods.map((m) => ({ method: m, count: routes.filter((r) => r.method === m).length })),
+    hasAppRoutes: appRoutes.length > 0,
+    appRoutesRows: toRouteRows(appRoutes),
+    hasDebugRoutes: debugRoutes.length > 0,
+    debugRoutesRows: toRouteRows(debugRoutes)
+  };
+}
+function buildProfilerDetailViewModel(profile, panelName = "request", appRoutes = []) {
+  const logErrors = profile.logs.filter((l) => l.level === "error" || l.level === "critical").length;
+  const hasException = profile.statusCode >= 400 || logErrors > 0;
+  let panelData;
+  switch (panelName) {
+    case "performance":
+      panelData = buildPerformancePanel(profile);
+      break;
+    case "logs":
+      panelData = buildLogsPanel(profile);
+      break;
+    case "routing":
+      panelData = buildRoutingPanel(profile);
+      break;
+    case "configuration":
+      panelData = buildConfigurationPanel(profile);
+      break;
+    case "database":
+      panelData = buildDatabasePanel(profile);
+      break;
+    case "exception":
+      panelData = buildExceptionPanel(profile);
+      break;
+    case "routes":
+      panelData = buildRoutesPanel(appRoutes);
+      break;
+    default:
+      panelData = buildRequestPanel(profile);
+  }
+  let banner;
+  if (profile.statusCode >= 500) {
+    banner = { bg: "#fcebec", border: "#e1142d", code: "#e1142d", msg: "#d98a8f", isError: true };
+  } else if (profile.statusCode >= 400) {
+    banner = { bg: "#fcebec", border: "#e1142d", code: "#e1142d", msg: "#d98a8f", isError: true };
+  } else if (profile.statusCode >= 300) {
+    banner = { bg: "#e3edf8", border: "#1565c0", code: "#1565c0", msg: "#6a9fd8", isError: false };
+  } else {
+    banner = { bg: "#e8f4ec", border: "#2e7d32", code: "#2e7d32", msg: "#6aaa6a", isError: false };
+  }
+  const panelLabel = {
+    request: "panel.request",
+    performance: "panel.performance",
+    logs: "panel.logs",
+    routing: "panel.routing",
+    configuration: "panel.configuration",
+    database: "panel.database",
+    exception: "panel.exception",
+    routes: "panel.routes"
+  };
+  const appRoutesForBadge = appRoutes.filter((r) => !r.path.startsWith("/_profiler") && r.path !== "/").length;
+  const sidebarItems = [
+    { icon: "route", label: "panel.request", panel: "request", active: panelName === "request", badge: 0, badgeIsError: false },
+    { icon: "perf", label: "panel.performance", panel: "performance", active: panelName === "performance", badge: 0, badgeIsError: false },
+    {
+      icon: "exception",
+      label: "panel.exception",
+      panel: "exception",
+      active: panelName === "exception",
+      badge: hasException ? profile.statusCode >= 400 ? 1 : logErrors : 0,
+      badgeIsError: true
+    },
+    {
+      icon: "log",
+      label: "panel.logs",
+      panel: "logs",
+      active: panelName === "logs",
+      badge: profile.logs.length,
+      badgeIsError: logErrors > 0
+    },
+    {
+      icon: "map",
+      label: "panel.routes",
+      panel: "routes",
+      active: panelName === "routes",
+      badge: appRoutesForBadge,
+      badgeIsError: false
+    },
+    { icon: "route", label: "panel.routing", panel: "routing", active: panelName === "routing", badge: 0, badgeIsError: false },
+    {
+      icon: "db",
+      label: "panel.database",
+      panel: "database",
+      active: panelName === "database",
+      badge: profile.queries.length,
+      badgeIsError: false
+    },
+    { icon: "config", label: "panel.configuration", panel: "configuration", active: panelName === "configuration", badge: 0, badgeIsError: false }
+  ];
+  return {
+    profile: {
+      method: profile.method,
+      url: profile.url,
+      statusCode: profile.statusCode,
+      statusMessage: profile.statusMessage,
+      ip: profile.request.ip,
+      date: new Date(profile.timestamp).toLocaleDateString("en-US", { month: "long", day: "numeric", year: "numeric" }),
+      time: new Date(profile.timestamp).toLocaleTimeString("en-US", { hour: "2-digit", minute: "2-digit", second: "2-digit" }),
+      token6: profile.token.slice(0, 6)
+    },
+    banner,
+    sidebarItems,
+    panelName,
+    panelLabel: panelLabel[panelName],
+    panelData
+  };
+}
+
+// src/controllers/profiler.controller.ts
+var SSE_HEARTBEAT_MS = 15e3;
+var PANELS = [
+  "request",
+  "performance",
+  "logs",
+  "routing",
+  "configuration",
+  "database",
+  "exception",
+  "routes"
+];
+function isValidPanel(p) {
+  return typeof p === "string" && PANELS.includes(p);
+}
+function getNpmVersion() {
+  try {
+    return (0, import_child_process.execSync)("npm --version", { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim();
+  } catch {
+    return "\u2014";
+  }
+}
+function createProfilerController(profiler) {
+  const { storage, routePrefix, security, maxRequests, enabled } = profiler.options;
+  async function recentLegacyProfiles(limit) {
+    const profiles = await storage.find(limit);
+    return profiles.map(toLegacyProfile);
+  }
+  return {
+    async home(req, res) {
+      const appVersion = process.env.npm_package_version ?? "1.0.0";
+      const nodeVersion = process.version;
+      const npmVersion = getNpmVersion();
+      const environment = process.env.NODE_ENV ?? "development";
+      await renderView(req, res, "home.njk", {
+        appVersion,
+        nodeVersion,
+        environment,
+        port: process.env.APP_PORT ?? "4200",
+        host: process.env.APP_HOST ?? "localhost",
+        showToolbar: enabled,
+        isProd: environment === "production"
+      });
+    },
+    async wdt(req, res) {
+      const raw = await storage.read(req.params.token);
+      if (!raw) {
+        res.status(404).send("");
+        return;
+      }
+      const profile = toLegacyProfile(raw);
+      const recent = await recentLegacyProfiles(maxRequests);
+      const vm = buildToolbarBarViewModel(profile, recent, security, routePrefix, maxRequests);
+      await renderView(req, res, "toolbar-wdt.njk", { ...vm, profilerBase: routePrefix });
+    },
+    async list(req, res) {
+      const qs = req.query;
+      const str = (k) => typeof qs[k] === "string" ? qs[k] : "";
+      const search = str("search");
+      const method = str("method");
+      const status = str("status");
+      const ip = str("ip");
+      const token = str("token");
+      const from = str("from");
+      const until = str("until");
+      const limitRaw = typeof qs.limit === "string" ? parseInt(qs.limit, 10) : 10;
+      const limit = [10, 25, 50, 100].includes(limitRaw) ? limitRaw : 10;
+      const tab = qs.tab === "commands" ? "commands" : "requests";
+      const all = await recentLegacyProfiles(1e3);
+      await renderView(req, res, "profiler-list.njk", buildProfilerListViewModel(
+        all,
+        search,
+        method,
+        status,
+        limit,
+        ip,
+        token,
+        from,
+        until,
+        tab
+      ));
+    },
+    /**
+     * Server-Sent Events stream: pushes one "profile" event per request
+     * the server finishes profiling, formatted exactly like a
+     * profiler-list.njk row. Replaces the old `setTimeout(location.reload)`
+     * polling on the list page — the client only re-renders when the
+     * server actually has something new, nothing is polled.
+     */
+    stream(req, res) {
+      res.setHeader("Content-Type", "text/event-stream");
+      res.setHeader("Cache-Control", "no-cache, no-transform");
+      res.setHeader("Connection", "keep-alive");
+      res.setHeader("X-Accel-Buffering", "no");
+      res.flushHeaders?.();
+      const send = (event, data) => {
+        res.write(`event: ${event}
+data: ${JSON.stringify(data)}
+
+`);
+      };
+      const onProfile = (profile) => {
+        send("profile", toProfilerListRow(toLegacyProfile(profile)));
+      };
+      profiler.events.on("profile", onProfile);
+      const heartbeat = setInterval(() => res.write(": heartbeat\n\n"), SSE_HEARTBEAT_MS);
+      req.on("close", () => {
+        clearInterval(heartbeat);
+        profiler.events.off("profile", onProfile);
+      });
+    },
+    async latestRedirect(_req, res) {
+      const [latest] = await storage.find(1);
+      if (!latest) {
+        res.redirect(routePrefix);
+        return;
+      }
+      res.redirect(`${routePrefix}/${latest.token}`);
+    },
+    async detail(req, res) {
+      const raw = await storage.read(req.params.token);
+      if (!raw) {
+        await renderView(req, res, "message.njk", {
+          titleKey: "message.not_found_title",
+          headingKey: "message.not_found_heading",
+          messageKey: "message.not_found_body",
+          messageParams: { token: req.params.token },
+          link: { href: routePrefix, labelKey: "message.back_to_list" }
+        });
+        return;
+      }
+      const profile = toLegacyProfile(raw);
+      const rawPanel = req.query.panel;
+      const panel = isValidPanel(rawPanel) ? rawPanel : "request";
+      await renderView(
+        req,
+        res,
+        "profiler-detail.njk",
+        buildProfilerDetailViewModel(profile, panel, getExpressRoutes())
+      );
+    }
+  };
+}
+
+// src/module.ts
+function registerProfilerViews(app, profiler) {
+  setIntrospectedApp(app);
+  configureProfilerViewEngine(app);
+  app.use(`${profiler.options.routePrefix}/assets`, import_opticore_express.express.static((0, import_path3.join)(__dirname, "assets"), { maxAge: 0, etag: true }));
+  const controller = createProfilerController(profiler);
+  app.use(import_opticore_router.OpticoreRoutingFactory.route({
+    method: "get",
+    path: "/",
+    handler: (async (ctx) => {
+      await controller.home(ctx.req, ctx.res);
+    })
+  }));
+}
+
+// src/routes/profiler.router.handler.ts
+var import_opticore_router2 = require("opticore-router");
+function createProfilerRouterHandler(profiler) {
+  const controller = createProfilerController(profiler);
+  const prefix = profiler.options.routePrefix;
+  return import_opticore_router2.OpticoreRoutingFactory.routes(
+    controller,
+    [
+      {
+        path: `${prefix}/wdt/:token`,
+        method: "get",
+        middlewares: [],
+        handler: async (ctx) => controller.wdt(ctx.req, ctx.res)
+      },
+      {
+        path: `${prefix}/stream`,
+        method: "get",
+        middlewares: [],
+        handler: async (ctx) => controller.stream(ctx.req, ctx.res)
+      },
+      {
+        path: `${prefix}/latest`,
+        method: "get",
+        middlewares: [],
+        handler: async (ctx) => controller.latestRedirect(ctx.req, ctx.res)
+      },
+      {
+        path: `${prefix}/:token`,
+        method: "get",
+        middlewares: [],
+        handler: async (ctx) => controller.detail(ctx.req, ctx.res)
+      },
+      {
+        path: prefix,
+        method: "get",
+        middlewares: [],
+        handler: async (ctx) => controller.list(ctx.req, ctx.res)
+      }
+    ]
+  );
+}
+
+// src/routes/profiler.router.ts
+function createProfilerRouter(profiler) {
+  const def = createProfilerRouterHandler(profiler);
+  return {
+    routes: [
+      { path: def.path, handler: def.handler }
+    ]
+  };
+}
+
+// src/instrumentation/mysql.instrumentation.ts
+var import_path4 = require("path");
+var INSTRUMENTED = /* @__PURE__ */ new WeakSet();
+function extractSql(sql) {
+  return typeof sql === "string" ? sql : sql.sql;
+}
+function captureCallSite() {
+  const probe = { stack: "" };
+  Error.captureStackTrace(probe, captureCallSite);
+  const lines = probe.stack.split("\n").slice(1);
+  const appFrame = lines.find(
+    (l) => !l.includes("mysql.instrumentation") && !l.includes(`${import_path4.sep}opticore-mysqldb${import_path4.sep}`)
+  );
+  return (appFrame ?? lines[0] ?? "").trim();
+}
+function instrumentMySQL(DriverClass) {
+  const proto = DriverClass.prototype;
+  if (INSTRUMENTED.has(proto)) return;
+  INSTRUMENTED.add(proto);
+  const original = proto.makeQuery;
+  proto.makeQuery = async function(sql, values, callback) {
+    const collector = getActiveCollector("database");
+    if (!collector) {
+      return original.call(this, sql, values, callback);
+    }
+    const sqlText = extractSql(sql);
+    const stack = captureCallSite();
+    const start = process.hrtime.bigint();
+    try {
+      const result = await original.call(this, sql, values, callback);
+      collector.record({
+        sql: sqlText,
+        bindings: values,
+        duration: Number((process.hrtime.bigint() - start) / 1000000n),
+        stack
+      });
+      return result;
+    } catch (err) {
+      collector.record({
+        sql: sqlText,
+        bindings: values,
+        duration: Number((process.hrtime.bigint() - start) / 1000000n),
+        stack,
+        error: err instanceof Error ? err.message : String(err)
+      });
+      throw err;
+    }
+  };
+}
+
+// src/instrumentation/logger.instrumentation.ts
+var INSTRUMENTED2 = /* @__PURE__ */ new WeakSet();
+function mirror(level, message, context) {
+  const collector = getActiveCollector("logger");
+  if (!collector) return;
+  collector.record({ level, message, context });
+}
+function instrumentLogger(LoggerClass) {
+  const proto = LoggerClass.prototype;
+  if (INSTRUMENTED2.has(proto)) {
+    return;
+  }
+  INSTRUMENTED2.add(proto);
+  const originalSuccess = proto.success;
+  proto.success = function(arg) {
+    mirror("info", arg.message ?? arg.title ?? "", arg.title ? { title: arg.title } : void 0);
+    return originalSuccess.call(this, arg);
+  };
+  const originalInfo = proto.info;
+  proto.info = function(arg) {
+    mirror("info", arg.message ?? arg.title ?? "", arg.title ? { title: arg.title } : void 0);
+    return originalInfo.call(this, arg);
+  };
+  const originalWarn = proto.warn;
+  proto.warn = function(arg) {
+    mirror("warning", arg.message, arg.title ? { title: arg.title } : void 0);
+    return originalWarn.call(this, arg);
+  };
+  const originalError = proto.error;
+  proto.error = function(arg) {
+    mirror("error", arg.message, {
+      ...arg.title ? { title: arg.title } : {},
+      ...arg.errorType ? { errorType: arg.errorType } : {},
+      ...arg.stackTrace ? { stack: arg.stackTrace } : {}
+    });
+    return originalError.call(this, arg);
+  };
+  const originalDebug = proto.debug;
+  proto.debug = function(message) {
+    mirror("debug", message);
+    return originalDebug.call(this, message);
+  };
+}
+
+// src/storage/memory.storage.ts
+var MemoryStorage = class {
+  constructor(limit = 100) {
+    this.limit = limit;
+    if (limit < 1) throw new Error("MemoryStorage limit must be >= 1");
+  }
+  limit;
+  profiles = /* @__PURE__ */ new Map();
+  order = [];
+  write(profile) {
+    if (this.profiles.has(profile.token)) {
+      const idx = this.order.indexOf(profile.token);
+      if (idx !== -1) this.order.splice(idx, 1);
+    } else if (this.order.length >= this.limit) {
+      const oldest = this.order.shift();
+      this.profiles.delete(oldest);
+    }
+    this.order.push(profile.token);
+    this.profiles.set(profile.token, profile);
+  }
+  read(token) {
+    return this.profiles.get(token);
+  }
+  find(limit) {
+    const tokens = [...this.order].reverse();
+    const sliced = limit ? tokens.slice(0, limit) : tokens;
+    return sliced.map((t) => this.profiles.get(t)).filter(Boolean);
+  }
+  purge(olderThanMs) {
+    if (!olderThanMs) return;
+    const cutoff = Date.now() - olderThanMs;
+    for (const token of [...this.order]) {
+      const profile = this.profiles.get(token);
+      if (profile && profile.time < cutoff) {
+        this.profiles.delete(token);
+        const idx = this.order.indexOf(token);
+        if (idx !== -1) this.order.splice(idx, 1);
+      }
+    }
+  }
+  clear() {
+    this.profiles.clear();
+    this.order.length = 0;
+  }
+  count() {
+    return this.order.length;
+  }
+};
+
+// src/storage/file.storage.ts
+var import_fs2 = require("fs");
+var import_path5 = require("path");
+var FileStorage = class {
+  constructor(dir = ".opticore-profiler-cache", maxIndexSize = 100) {
+    this.dir = dir;
+    this.maxIndexSize = maxIndexSize;
+    if (maxIndexSize < 1) throw new Error("FileStorage maxIndexSize must be >= 1");
+    this.indexPath = (0, import_path5.join)(this.dir, "index.json");
+    this.ensureDir();
+  }
+  dir;
+  maxIndexSize;
+  indexPath;
+  ensureDir() {
+    if (!(0, import_fs2.existsSync)(this.dir)) (0, import_fs2.mkdirSync)(this.dir, { recursive: true });
+  }
+  profilePath(token) {
+    return (0, import_path5.join)(this.dir, `${token}.json`);
+  }
+  readIndex() {
+    if (!(0, import_fs2.existsSync)(this.indexPath)) return [];
+    try {
+      return JSON.parse((0, import_fs2.readFileSync)(this.indexPath, "utf8"));
+    } catch {
+      return [];
+    }
+  }
+  writeIndex(entries) {
+    (0, import_fs2.writeFileSync)(this.indexPath, JSON.stringify(entries), "utf8");
+  }
+  write(profile) {
+    this.ensureDir();
+    (0, import_fs2.writeFileSync)(this.profilePath(profile.token), JSON.stringify(profile), "utf8");
+    const index = this.readIndex().filter((e) => e.token !== profile.token);
+    index.unshift({
+      token: profile.token,
+      ip: profile.ip,
+      method: profile.method,
+      url: profile.url,
+      statusCode: profile.statusCode,
+      time: profile.time,
+      duration: profile.duration,
+      contentType: profile.contentType
+    });
+    while (index.length > this.maxIndexSize) {
+      const dropped = index.pop();
+      this.deleteFile(dropped.token);
+    }
+    this.writeIndex(index);
+  }
+  read(token) {
+    const path = this.profilePath(token);
+    if (!(0, import_fs2.existsSync)(path)) return void 0;
+    try {
+      return JSON.parse((0, import_fs2.readFileSync)(path, "utf8"));
+    } catch {
+      return void 0;
+    }
+  }
+  find(limit) {
+    const entries = this.readIndex();
+    const sliced = limit ? entries.slice(0, limit) : entries;
+    return sliced.map((e) => ({ ...e, collectors: {} }));
+  }
+  purge(olderThanMs) {
+    if (!olderThanMs) return;
+    const cutoff = Date.now() - olderThanMs;
+    const index = this.readIndex();
+    const kept = index.filter((e) => {
+      if (e.time >= cutoff) return true;
+      this.deleteFile(e.token);
+      return false;
+    });
+    if (kept.length !== index.length) this.writeIndex(kept);
+  }
+  clear() {
+    for (const entry of this.readIndex()) {
+      this.deleteFile(entry.token);
+    }
+    this.writeIndex([]);
+  }
+  deleteFile(token) {
+    const path = this.profilePath(token);
+    if ((0, import_fs2.existsSync)(path)) {
+      try {
+        (0, import_fs2.unlinkSync)(path);
+      } catch {
+      }
+    }
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CollectorRegistry,
+  DEFAULT_EXCLUDE_PATHS,
+  DEFAULT_SENSITIVE_KEYS,
+  DatabaseCollector,
+  ExceptionCollector,
+  FileStorage,
+  LoggerCollector,
+  MemoryCollector,
+  MemoryStorage,
+  RequestCollector,
+  TimeCollector,
+  createProfilerRouter,
+  generateToken,
+  getActiveCollector,
+  instrumentLogger,
+  instrumentMySQL,
+  isValidToken,
+  opticoreProfiler,
+  profilerErrorHandler,
+  registerProfilerViews
+});