traceperf 0.2.1 → 1.3.0

package/dist/traceperf.browser.js

@@ -0,0 +1,1910 @@
+/*! traceperf v1.3.0 | MIT License | browser global build */
+"use strict";
+var TracePerf = (() => {
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+    get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+  }) : x)(function(x) {
+    if (typeof require !== "undefined") return require.apply(this, arguments);
+    throw Error('Dynamic require of "' + x + '" is not supported');
+  });
+  var __commonJS = (cb, mod) => function __require2() {
+    try {
+      return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+    } catch (e) {
+      throw mod = 0, e;
+    }
+  };
+
+  // dist/core/records.js
+  var require_records = __commonJS({
+    "dist/core/records.js"(exports) {
+      "use strict";
+      Object.defineProperty(exports, "__esModule", { value: true });
+      exports.coveredLength = coveredLength;
+      exports.walkRecords = walkRecords;
+      exports.formatTree = formatTree;
+      function coveredLength(intervals) {
+        if (intervals.length === 0)
+          return 0;
+        const sorted = intervals.slice().sort((a, b) => a[0] - b[0]);
+        let total = 0;
+        let [curStart, curEnd] = sorted[0];
+        for (let i = 1; i < sorted.length; i++) {
+          const [start, end] = sorted[i];
+          if (start > curEnd) {
+            total += curEnd - curStart;
+            curStart = start;
+            curEnd = end;
+          } else if (end > curEnd) {
+            curEnd = end;
+          }
+        }
+        return total + (curEnd - curStart);
+      }
+      function walkRecords(root, visit, depth = 0) {
+        visit(root, depth);
+        for (const child of root.children) {
+          walkRecords(child, visit, depth + 1);
+        }
+      }
+      var formatMs = (ms) => `${ms.toFixed(3)} ms`;
+      function formatError(error) {
+        return error instanceof Error ? error.message : String(error);
+      }
+      function formatLine(record, options) {
+        const args = record.args && record.args.length > 0 ? `(${record.args.join(", ")})` : "";
+        let line = `${record.label}${args}: ${formatMs(record.duration)}`;
+        if (options.detailed) {
+          const extra = [];
+          if (record.children.length > 0)
+            extra.push(`self ${formatMs(record.selfDuration)}`);
+          if (record.async)
+            extra.push(`sync ${formatMs(record.syncDuration)}`);
+          if (extra.length > 0)
+            line += ` (${extra.join(", ")})`;
+        }
+        if (record.memoryDelta !== void 0) {
+          const kb = (record.memoryDelta / 1024).toFixed(2);
+          line += ` \u{1F4CA} ${record.memoryDelta >= 0 ? "+" : ""}${kb} KB`;
+          if (record.memoryDelta < 0)
+            line += " (gc)";
+        }
+        if (options.detailed && options.blockingThreshold !== void 0 && options.blockingThreshold > 0 && record.syncDuration >= options.blockingThreshold) {
+          line += ` \u26A0 blocked event loop ${formatMs(record.syncDuration)}`;
+        }
+        if (options.showErrors && record.error !== void 0 && record.error !== null) {
+          line += ` \u2716 ${formatError(record.error)}`;
+        }
+        return line;
+      }
+      function formatTree(root, options = {}) {
+        const lines = [];
+        const visit = (record, ancestors, isLast) => {
+          const prefix = ancestors.map((hasMoreSiblings) => hasMoreSiblings ? "\u2502 " : "  ").join("");
+          lines.push(`${prefix}${isLast ? "\u2514\u2500 " : "\u251C\u2500 "}${formatLine(record, options)}`);
+          const shown = record.children.filter((child) => child.duration >= child.threshold);
+          shown.forEach((child, i) => visit(child, [...ancestors, !isLast], i === shown.length - 1));
+        };
+        visit(root, [], true);
+        return lines.join("\n");
+      }
+    }
+  });
+
+  // dist/core/stats.js
+  var require_stats = __commonJS({
+    "dist/core/stats.js"(exports) {
+      "use strict";
+      Object.defineProperty(exports, "__esModule", { value: true });
+      exports.StatsCollector = exports.OTHER_LABEL = void 0;
+      exports.formatStatsTable = formatStatsTable;
+      var records_1 = require_records();
+      exports.OTHER_LABEL = "(other)";
+      var LabelAccumulator = class {
+        constructor(reservoirSize) {
+          this.reservoirSize = reservoirSize;
+          this.count = 0;
+          this.errors = 0;
+          this.total = 0;
+          this.selfTotal = 0;
+          this.min = Infinity;
+          this.max = -Infinity;
+          this.samples = [];
+        }
+        add(duration, selfDuration, failed) {
+          this.count++;
+          this.total += duration;
+          this.selfTotal += selfDuration;
+          if (failed)
+            this.errors++;
+          if (duration < this.min)
+            this.min = duration;
+          if (duration > this.max)
+            this.max = duration;
+          if (this.samples.length < this.reservoirSize) {
+            this.samples.push(duration);
+          } else {
+            const slot = Math.floor(Math.random() * this.count);
+            if (slot < this.reservoirSize)
+              this.samples[slot] = duration;
+          }
+        }
+        snapshot() {
+          const sorted = this.samples.slice().sort((a, b) => a - b);
+          const pct = (p) => {
+            if (sorted.length === 0)
+              return 0;
+            const rank = Math.min(sorted.length - 1, Math.max(0, Math.ceil(p * sorted.length) - 1));
+            return sorted[rank];
+          };
+          return {
+            count: this.count,
+            errors: this.errors,
+            total: this.total,
+            mean: this.count ? this.total / this.count : 0,
+            min: this.count ? this.min : 0,
+            max: this.count ? this.max : 0,
+            p50: pct(0.5),
+            p95: pct(0.95),
+            p99: pct(0.99),
+            selfMean: this.count ? this.selfTotal / this.count : 0
+          };
+        }
+      };
+      var StatsCollector = class {
+        constructor(options = {}) {
+          var _a, _b;
+          this.labels = /* @__PURE__ */ new Map();
+          this.reservoirSize = Math.max(1, (_a = options.reservoirSize) !== null && _a !== void 0 ? _a : 1024);
+          this.maxLabels = Math.max(1, (_b = options.maxLabels) !== null && _b !== void 0 ? _b : 1e3);
+        }
+        /** Record one execution (not its children) */
+        add(record) {
+          let label = record.label;
+          let acc = this.labels.get(label);
+          if (!acc) {
+            if (this.labels.size >= this.maxLabels - 1) {
+              label = exports.OTHER_LABEL;
+              acc = this.labels.get(label);
+            }
+            if (!acc) {
+              acc = new LabelAccumulator(this.reservoirSize);
+              this.labels.set(label, acc);
+            }
+          }
+          acc.add(record.duration, record.selfDuration, record.error !== void 0 && record.error !== null);
+        }
+        /** Record a whole finished tree */
+        addTree(root) {
+          (0, records_1.walkRecords)(root, (record) => this.add(record));
+        }
+        get(label) {
+          var _a;
+          return (_a = this.labels.get(label)) === null || _a === void 0 ? void 0 : _a.snapshot();
+        }
+        all() {
+          const out = {};
+          this.labels.forEach((acc, label) => {
+            out[label] = acc.snapshot();
+          });
+          return out;
+        }
+        reset() {
+          this.labels = /* @__PURE__ */ new Map();
+        }
+      };
+      exports.StatsCollector = StatsCollector;
+      function formatStatsTable(stats) {
+        const rows = Object.keys(stats).map((label) => ({ label, ...stats[label] })).sort((a, b) => b.total - a.total);
+        if (rows.length === 0)
+          return "traceperf: no calls recorded";
+        const head = ["label", "calls", "errors", "total ms", "mean", "p50", "p95", "p99", "max", "self mean"];
+        const body = rows.map((r) => [
+          r.label,
+          String(r.count),
+          String(r.errors),
+          r.total.toFixed(1),
+          r.mean.toFixed(3),
+          r.p50.toFixed(3),
+          r.p95.toFixed(3),
+          r.p99.toFixed(3),
+          r.max.toFixed(3),
+          r.selfMean.toFixed(3)
+        ]);
+        const widths = head.map((h, i) => Math.max(h.length, ...body.map((row) => row[i].length)));
+        const fmt = (cells) => cells.map((c, i) => i === 0 ? c.padEnd(widths[i]) : c.padStart(widths[i])).join("  ");
+        return [fmt(head), widths.map((w) => "-".repeat(w)).join("  "), ...body.map(fmt)].join("\n");
+      }
+    }
+  });
+
+  // dist/core/exporters.js
+  var require_exporters = __commonJS({
+    "dist/core/exporters.js"(exports) {
+      "use strict";
+      Object.defineProperty(exports, "__esModule", { value: true });
+      exports.toChromeTrace = toChromeTrace;
+      exports.createTraceRecorder = createTraceRecorder;
+      exports.openTelemetryExporter = openTelemetryExporter;
+      exports.recordToJSON = recordToJSON;
+      exports.jsonLinesExporter = jsonLinesExporter;
+      var records_1 = require_records();
+      function toChromeTrace(roots) {
+        const events = [];
+        const lanes = [];
+        const fits = (lane, start, end) => {
+          while (lane.length > 0 && lane[lane.length - 1] <= start)
+            lane.pop();
+          return lane.length === 0 || end <= lane[lane.length - 1];
+        };
+        const place = (record, preferred) => {
+          const candidates = [preferred, ...lanes.map((_, i) => i).filter((i) => i !== preferred)];
+          for (const i of candidates) {
+            if (lanes[i] && fits(lanes[i], record.startTime, record.endTime)) {
+              lanes[i].push(record.endTime);
+              return i;
+            }
+          }
+          lanes.push([record.endTime]);
+          return lanes.length - 1;
+        };
+        const all = [];
+        const sortedRoots = roots.slice().sort((a, b) => a.startTime - b.startTime);
+        const visit = (record, parentLane) => {
+          all.push({ record, parentLane });
+        };
+        sortedRoots.forEach((root) => (0, records_1.walkRecords)(root, (r) => visit(r, 0)));
+        all.sort((a, b) => a.record.startTime - b.record.startTime || b.record.duration - a.record.duration);
+        const laneOf = /* @__PURE__ */ new Map();
+        for (const { record } of all) {
+          const preferred = record.parentId !== null && laneOf.has(record.parentId) ? laneOf.get(record.parentId) : 0;
+          const lane = place(record, preferred);
+          laneOf.set(record.id, lane);
+          const args = { selfMs: record.selfDuration, syncMs: record.syncDuration };
+          if (record.memoryDelta !== void 0)
+            args.memoryDeltaBytes = record.memoryDelta;
+          if (record.args && record.args.length)
+            args.args = record.args;
+          if (record.error !== void 0 && record.error !== null) {
+            args.error = record.error instanceof Error ? record.error.message : String(record.error);
+          }
+          events.push({
+            name: record.label,
+            cat: "traceperf",
+            ph: "X",
+            ts: Math.round(record.startTime * 1e3),
+            dur: Math.max(0, Math.round(record.duration * 1e3)),
+            pid: 1,
+            tid: lane + 1,
+            args
+          });
+        }
+        const meta = [
+          { name: "process_name", cat: "__metadata", ph: "M", ts: 0, pid: 1, tid: 0, args: { name: "traceperf" } },
+          ...lanes.map((_, i) => ({
+            name: "thread_name",
+            cat: "__metadata",
+            ph: "M",
+            ts: 0,
+            pid: 1,
+            tid: i + 1,
+            args: { name: i === 0 ? "main" : `concurrent ${i}` }
+          }))
+        ];
+        return { traceEvents: [...meta, ...events], displayTimeUnit: "ms" };
+      }
+      function createTraceRecorder(options = {}) {
+        var _a;
+        const maxRoots = Math.max(1, (_a = options.maxRoots) !== null && _a !== void 0 ? _a : 1e4);
+        const roots = [];
+        let stopped = false;
+        return {
+          name: "chrome-trace",
+          roots,
+          onComplete(root) {
+            if (stopped)
+              return;
+            roots.push(root);
+            if (roots.length > maxRoots)
+              roots.shift();
+          },
+          stop() {
+            if (!stopped) {
+              stopped = true;
+              if (options.onStop)
+                options.onStop();
+            }
+            return toChromeTrace(roots);
+          }
+        };
+      }
+      var OTEL_STATUS_ERROR = 2;
+      function decorateSpan(span, record) {
+        span.setAttribute("traceperf.self_ms", record.selfDuration);
+        span.setAttribute("traceperf.sync_ms", record.syncDuration);
+        span.setAttribute("traceperf.async", record.async);
+        if (record.memoryDelta !== void 0)
+          span.setAttribute("traceperf.memory_delta_bytes", record.memoryDelta);
+        if (record.args && record.args.length)
+          span.setAttribute("traceperf.args", record.args.join(", "));
+        if (record.error !== void 0 && record.error !== null) {
+          span.recordException(record.error);
+          span.setStatus({
+            code: OTEL_STATUS_ERROR,
+            message: record.error instanceof Error ? record.error.message : String(record.error)
+          });
+        }
+      }
+      function openTelemetryExporter(api, options = {}) {
+        var _a, _b;
+        const tracer = (_a = options.tracer) !== null && _a !== void 0 ? _a : api.trace.getTracer((_b = options.tracerName) !== null && _b !== void 0 ? _b : "traceperf");
+        if (options.live) {
+          if (typeof api.context.with !== "function") {
+            throw new Error("openTelemetryExporter: live mode needs api.context.with (pass @opentelemetry/api)");
+          }
+          const spans = /* @__PURE__ */ new Map();
+          return {
+            name: "opentelemetry-live",
+            onStart(execution) {
+              spans.set(execution.id, tracer.startSpan(execution.label, { startTime: execution.startEpochMs }, api.context.active()));
+            },
+            wrap(execution, run) {
+              const span = spans.get(execution.id);
+              if (!span)
+                return run();
+              return api.context.with(api.trace.setSpan(api.context.active(), span), run);
+            },
+            onComplete(root) {
+              (0, records_1.walkRecords)(root, (record) => {
+                const span = spans.get(record.id);
+                if (!span)
+                  return;
+                spans.delete(record.id);
+                if (span.updateName)
+                  span.updateName(record.label);
+                decorateSpan(span, record);
+                span.end(record.startEpochMs + record.duration);
+              });
+            }
+          };
+        }
+        const startContexts = /* @__PURE__ */ new Map();
+        return {
+          name: "opentelemetry",
+          onStart(execution) {
+            if (execution.parentId === null)
+              startContexts.set(execution.id, api.context.active());
+          },
+          onComplete(root) {
+            var _a2;
+            const parentContext = (_a2 = startContexts.get(root.id)) !== null && _a2 !== void 0 ? _a2 : api.context.active();
+            startContexts.delete(root.id);
+            const emit = (record, ctx) => {
+              const span = tracer.startSpan(record.label, { startTime: record.startEpochMs }, ctx);
+              decorateSpan(span, record);
+              const childCtx = api.trace.setSpan(ctx, span);
+              record.children.forEach((child) => emit(child, childCtx));
+              span.end(record.startEpochMs + record.duration);
+            };
+            emit(root, parentContext);
+          }
+        };
+      }
+      function recordToJSON(record) {
+        return {
+          label: record.label,
+          start: new Date(record.startEpochMs).toISOString(),
+          durationMs: record.duration,
+          selfMs: record.selfDuration,
+          syncMs: record.syncDuration,
+          async: record.async,
+          ...record.memoryDelta !== void 0 ? { memoryDeltaBytes: record.memoryDelta } : {},
+          ...record.args && record.args.length ? { args: record.args } : {},
+          ...record.error !== void 0 && record.error !== null ? { error: record.error instanceof Error ? record.error.message : String(record.error) } : {},
+          children: record.children.map(recordToJSON)
+        };
+      }
+      function jsonLinesExporter(write) {
+        const out = write !== null && write !== void 0 ? write : ((line) => {
+          const proc = typeof process !== "undefined" ? process : void 0;
+          if (proc && proc.stdout && typeof proc.stdout.write === "function")
+            proc.stdout.write(line + "\n");
+          else
+            console.log(line);
+        });
+        return {
+          name: "json-lines",
+          onComplete(root) {
+            out(JSON.stringify(recordToJSON(root)));
+          }
+        };
+      }
+    }
+  });
+
+  // dist/core/env.js
+  var require_env = __commonJS({
+    "dist/core/env.js"(exports) {
+      "use strict";
+      Object.defineProperty(exports, "__esModule", { value: true });
+      exports.loadNodeBuiltin = exports.provideNodeBuiltins = void 0;
+      var provided = {};
+      var provideNodeBuiltins = (modules) => {
+        Object.assign(provided, modules);
+      };
+      exports.provideNodeBuiltins = provideNodeBuiltins;
+      var loadNodeBuiltin = (id) => {
+        if (provided[id])
+          return provided[id];
+        try {
+          const proc = typeof process !== "undefined" ? process : void 0;
+          if (!proc || !proc.versions || !proc.versions.node)
+            return void 0;
+          if (typeof proc.getBuiltinModule === "function") {
+            return proc.getBuiltinModule(id);
+          }
+          const req = typeof __require === "function" ? __require : void 0;
+          return req ? req(id) : void 0;
+        } catch (_a) {
+          return void 0;
+        }
+      };
+      exports.loadNodeBuiltin = loadNodeBuiltin;
+    }
+  });
+
+  // dist/core/optimized-performance-monitor.js
+  var require_optimized_performance_monitor = __commonJS({
+    "dist/core/optimized-performance-monitor.js"(exports) {
+      "use strict";
+      Object.defineProperty(exports, "__esModule", { value: true });
+      exports.OptimizedPerformanceMonitor = exports.OptimizedExecutionTracker = exports.formatArg = exports.getDuration = exports.getTimestamp = exports.getMemoryUsage = exports.TrackingModes = void 0;
+      var records_1 = require_records();
+      var stats_1 = require_stats();
+      var exporters_1 = require_exporters();
+      var env_1 = require_env();
+      exports.TrackingModes = {
+        PERFORMANCE: "performance",
+        BALANCED: "balanced",
+        DETAILED: "detailed",
+        DEBUG: "debug"
+      };
+      var DEFAULT_TRACKING_MODE = exports.TrackingModes.BALANCED;
+      var v8Module = (0, env_1.loadNodeBuiltin)("v8");
+      var readHeapUsed = v8Module && typeof v8Module.getHeapStatistics === "function" ? () => v8Module.getHeapStatistics().used_heap_size : void 0;
+      var getMemoryUsage = () => {
+        var _a;
+        if (readHeapUsed) {
+          return readHeapUsed();
+        }
+        if (typeof process !== "undefined" && process.memoryUsage) {
+          const mem = process.memoryUsage();
+          return mem.heapUsed;
+        } else if (typeof performance !== "undefined" && "memory" in performance) {
+          return ((_a = performance.memory) === null || _a === void 0 ? void 0 : _a.usedJSHeapSize) || 0;
+        }
+        return 0;
+      };
+      exports.getMemoryUsage = getMemoryUsage;
+      exports.getTimestamp = // Clock chosen once at load time (the hot path should not re-detect it)
+      typeof performance !== "undefined" && typeof performance.now === "function" ? () => performance.now() * 1e6 : typeof process !== "undefined" && typeof process.hrtime === "function" ? () => {
+        const hrTime = process.hrtime();
+        return hrTime[0] * 1e9 + hrTime[1];
+      } : () => Date.now() * 1e6;
+      var getDuration = (startTime) => {
+        return (0, exports.getTimestamp)() - startTime;
+      };
+      exports.getDuration = getDuration;
+      var EPOCH_OFFSET_MS = Date.now() - (0, exports.getTimestamp)() / 1e6;
+      var MAX_ARG_LENGTH = 50;
+      var formatArg = (arg) => {
+        var _a, _b;
+        let text;
+        try {
+          if (typeof arg === "string") {
+            text = JSON.stringify(arg.length > MAX_ARG_LENGTH ? arg.slice(0, MAX_ARG_LENGTH) : arg);
+          } else if (typeof arg === "function") {
+            text = `[Function ${arg.name || "anonymous"}]`;
+          } else if (Array.isArray(arg)) {
+            text = `Array(${arg.length})`;
+          } else if (arg !== null && typeof arg === "object") {
+            const keys = Object.keys(arg);
+            if (keys.length <= 5) {
+              text = JSON.stringify(arg);
+            } else {
+              const name = ((_a = arg.constructor) === null || _a === void 0 ? void 0 : _a.name) || "Object";
+              text = `${name}{${keys.length} keys}`;
+            }
+          } else {
+            text = String(arg);
+          }
+        } catch (_c) {
+          const name = (_b = arg === null || arg === void 0 ? void 0 : arg.constructor) === null || _b === void 0 ? void 0 : _b.name;
+          text = typeof name === "string" && name ? `[${name}]` : "[object]";
+        }
+        return text.length > MAX_ARG_LENGTH ? `${text.slice(0, MAX_ARG_LENGTH - 1)}\u2026` : text;
+      };
+      exports.formatArg = formatArg;
+      var loadAsyncLocalStorage = () => {
+        var _a, _b;
+        return (_b = (_a = (0, env_1.loadNodeBuiltin)("async_hooks")) === null || _a === void 0 ? void 0 : _a.AsyncLocalStorage) !== null && _b !== void 0 ? _b : (
+          // Edge runtimes (e.g. Next.js Edge) expose it as a global
+          typeof globalThis !== "undefined" ? globalThis.AsyncLocalStorage : void 0
+        );
+      };
+      var createExecutionContext = (provided) => {
+        const AsyncLocalStorage = provided !== null && provided !== void 0 ? provided : loadAsyncLocalStorage();
+        if (AsyncLocalStorage) {
+          const storage = new AsyncLocalStorage();
+          return {
+            current: () => {
+              var _a;
+              return (_a = storage.getStore()) !== null && _a !== void 0 ? _a : null;
+            },
+            run: (executionId, fn) => storage.run(executionId, fn),
+            // AsyncLocalStorage.run forwards extra arguments to the callback
+            apply: (executionId, fn, thisArg, args) => storage.run(executionId, Reflect.apply, fn, thisArg, args)
+          };
+        }
+        let current = null;
+        const run = (executionId, fn) => {
+          const previous = current;
+          current = executionId;
+          try {
+            return fn();
+          } finally {
+            current = previous;
+          }
+        };
+        return {
+          current: () => current,
+          run,
+          apply: (executionId, fn, thisArg, args) => run(executionId, () => fn.apply(thisArg, args))
+        };
+      };
+      var NOOP_SPAN = {
+        id: "",
+        setLabel: () => void 0,
+        run: (fn) => fn(),
+        end: () => void 0
+      };
+      var clampRate = (rate) => Math.max(0, Math.min(1, rate));
+      var isNativePromise = (value) => value !== null && typeof value === "object" && (value instanceof Promise || typeof value.then === "function" && Object.prototype.toString.call(value) === "[object Promise]");
+      var OptimizedExecutionTracker = class {
+        /**
+         * Create a new execution tracker
+         * @param options Tracker configuration options
+         */
+        constructor(options = {}) {
+          var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+          this.executionTree = /* @__PURE__ */ new Map();
+          this.currentExecutionId = 0;
+          this.activeExecutions = /* @__PURE__ */ new Map();
+          this.plugins = [];
+          this.wrappers = [];
+          this.failedPlugins = /* @__PURE__ */ new Set();
+          this.showMemoryUsage = (_a = options.showMemoryUsage) !== null && _a !== void 0 ? _a : true;
+          this.enableNestedTracking = (_b = options.enableNestedTracking) !== null && _b !== void 0 ? _b : true;
+          this.silent = (_c = options.silent) !== null && _c !== void 0 ? _c : false;
+          this.trackingMode = (_d = options.trackingMode) !== null && _d !== void 0 ? _d : exports.TrackingModes.BALANCED;
+          this.defaultThreshold = (_e = options.threshold) !== null && _e !== void 0 ? _e : 0;
+          this.defaultSampleRate = clampRate((_f = options.sampleRate) !== null && _f !== void 0 ? _f : 1);
+          this.context = createExecutionContext(options.asyncLocalStorage);
+          this.enabled = (_g = options.enabled) !== null && _g !== void 0 ? _g : true;
+          this.blockingThreshold = (_h = options.blockingThreshold) !== null && _h !== void 0 ? _h : 50;
+          this.reporter = (_j = options.reporter) !== null && _j !== void 0 ? _j : null;
+          this.stats = options.stats === false ? null : new stats_1.StatsCollector(typeof options.stats === "object" ? options.stats : {});
+          (options.plugins || []).forEach((plugin) => this.use(plugin));
+        }
+        /**
+         * Register a plugin. Returns a function that removes it again.
+         */
+        use(plugin) {
+          this.plugins = [...this.plugins, plugin];
+          this.wrappers = this.plugins.filter((p) => typeof p.wrap === "function");
+          return () => {
+            this.plugins = this.plugins.filter((p) => p !== plugin);
+            this.wrappers = this.plugins.filter((p) => typeof p.wrap === "function");
+          };
+        }
+        /**
+         * Run `run` inside every plugin's wrap() (first registered = outermost).
+         * A wrap() that throws before calling run is reported once and skipped.
+         */
+        _wrap(execution, run) {
+          let next = run;
+          for (let i = this.wrappers.length - 1; i >= 0; i--) {
+            const plugin = this.wrappers[i];
+            const inner = next;
+            next = () => {
+              let ran = false;
+              const once = () => {
+                ran = true;
+                return inner();
+              };
+              try {
+                return plugin.wrap(execution, once);
+              } catch (error) {
+                if (ran)
+                  throw error;
+                this._pluginFailed(plugin, "wrap", error);
+                return inner();
+              }
+            };
+          }
+          return next();
+        }
+        _pluginFailed(plugin, hook, error) {
+          if (!this.failedPlugins.has(plugin)) {
+            this.failedPlugins.add(plugin);
+            console.warn(`traceperf: plugin ${plugin.name || "(unnamed)"} threw in ${hook}:`, error);
+          }
+        }
+        _callPlugins(hook, payload) {
+          for (const plugin of this.plugins) {
+            const fn = plugin[hook];
+            if (!fn)
+              continue;
+            try {
+              fn.call(plugin, payload);
+            } catch (error) {
+              this._pluginFailed(plugin, hook, error);
+            }
+          }
+        }
+        /**
+         * Start timing a function execution
+         * @param label Function name or label
+         * @param parentExecutionId ID of parent execution if nested
+         * @param options Additional options
+         * @returns Execution ID
+         */
+        startTimer(label, parentExecutionId = null, options = {}, args = options.args) {
+          var _a, _b, _c, _d;
+          const trackingMode = (_a = options.trackingMode) !== null && _a !== void 0 ? _a : this.trackingMode;
+          const trackMemory = (_b = options.trackMemory) !== null && _b !== void 0 ? _b : this.showMemoryUsage;
+          const collectMemory = trackingMode !== exports.TrackingModes.PERFORMANCE && trackMemory;
+          const startTime = (0, exports.getTimestamp)();
+          const executionId = (++this.currentExecutionId).toString();
+          const execution = {
+            id: executionId,
+            label: label || "anonymous",
+            startTime,
+            endTime: 0,
+            duration: 0,
+            parentId: parentExecutionId,
+            children: [],
+            args: options.captureArgs && args ? Array.from(args).map(exports.formatArg) : void 0,
+            complete: false,
+            silent: (_c = options.silent) !== null && _c !== void 0 ? _c : this.silent,
+            trackingMode,
+            threshold: (_d = options.threshold) !== null && _d !== void 0 ? _d : this.defaultThreshold
+          };
+          if (collectMemory) {
+            execution.memoryAtStart = (0, exports.getMemoryUsage)();
+            execution.memoryAtEnd = 0;
+            execution.memoryDelta = 0;
+          }
+          if (parentExecutionId && this.activeExecutions.has(parentExecutionId)) {
+            const parent = this.activeExecutions.get(parentExecutionId);
+            if (parent && parent.children) {
+              parent.children.push(executionId);
+            }
+          }
+          this.activeExecutions.set(executionId, execution);
+          if (this.plugins.length > 0) {
+            this._callPlugins("onStart", {
+              id: executionId,
+              label: execution.label,
+              parentId: parentExecutionId,
+              startEpochMs: EPOCH_OFFSET_MS + startTime / 1e6
+            });
+          }
+          return executionId;
+        }
+        /**
+         * End timing a function execution
+         * @param executionId ID of the execution to end
+         * @param result Result of the function
+         * @param error Error if the function threw
+         * @returns Execution data
+         */
+        endTimer(executionId, result, error = null) {
+          if (!this.activeExecutions.has(executionId)) {
+            return null;
+          }
+          const execution = this.activeExecutions.get(executionId);
+          this.activeExecutions.delete(executionId);
+          execution.endTime = (0, exports.getTimestamp)();
+          execution.duration = execution.endTime - execution.startTime;
+          execution.result = result;
+          execution.error = error;
+          execution.complete = true;
+          if (execution.memoryAtStart !== void 0) {
+            execution.memoryAtEnd = (0, exports.getMemoryUsage)();
+            execution.memoryDelta = execution.memoryAtEnd - (execution.memoryAtStart || 0);
+          }
+          const parentRunning = execution.parentId !== null && this.activeExecutions.has(execution.parentId);
+          if (parentRunning) {
+            this.executionTree.set(executionId, execution);
+            return execution;
+          }
+          const record = this._toRecord(execution);
+          if (execution.children.length > 0) {
+            this._release(execution);
+          }
+          if (this.stats) {
+            this.stats.addTree(record);
+          }
+          if (!record.silent && record.trackingMode !== exports.TrackingModes.PERFORMANCE && record.duration >= record.threshold) {
+            this._report(record);
+          }
+          if (this.plugins.length > 0) {
+            this._callPlugins("onComplete", record);
+          }
+          return execution;
+        }
+        /**
+         * Drop a finished execution and its finished descendants
+         */
+        _release(execution) {
+          for (const childId of execution.children) {
+            const child = this.executionTree.get(childId);
+            if (child) {
+              this.executionTree.delete(childId);
+              this._release(child);
+            }
+          }
+        }
+        /**
+         * Mark the end of the synchronous part of an execution that returned a promise
+         */
+        markSyncEnd(executionId) {
+          const execution = this.activeExecutions.get(executionId);
+          if (execution) {
+            execution.syncEndTime = (0, exports.getTimestamp)();
+          }
+        }
+        /**
+         * Convert a finished execution (and its finished children) to a record tree
+         */
+        _toRecord(execution) {
+          var _a, _b, _c;
+          const startTime = execution.startTime / 1e6;
+          const endTime = execution.endTime / 1e6;
+          const duration = execution.duration / 1e6;
+          const children = [];
+          let covered = 0;
+          if (execution.children.length > 0) {
+            for (const childId of execution.children) {
+              const child = this.executionTree.get(childId);
+              if (child) {
+                children.push(this._toRecord(child));
+              }
+            }
+            covered = (0, records_1.coveredLength)(children.map((c) => [Math.max(c.startTime, startTime), Math.min(c.endTime, endTime)]));
+          }
+          const isAsync = execution.syncEndTime !== void 0;
+          const record = {
+            id: execution.id,
+            label: execution.label,
+            parentId: execution.parentId,
+            startTime,
+            endTime,
+            startEpochMs: EPOCH_OFFSET_MS + startTime,
+            duration,
+            selfDuration: Math.max(0, duration - covered),
+            syncDuration: isAsync ? (execution.syncEndTime - execution.startTime) / 1e6 : duration,
+            async: isAsync,
+            children,
+            threshold: (_a = execution.threshold) !== null && _a !== void 0 ? _a : 0,
+            trackingMode: (_b = execution.trackingMode) !== null && _b !== void 0 ? _b : this.trackingMode,
+            silent: (_c = execution.silent) !== null && _c !== void 0 ? _c : this.silent
+          };
+          if (execution.memoryAtStart !== void 0 && execution.memoryDelta !== void 0) {
+            record.memoryDelta = execution.memoryDelta;
+          }
+          if (execution.error !== null && execution.error !== void 0) {
+            record.error = execution.error;
+          }
+          if (execution.args && execution.args.length > 0) {
+            record.args = execution.args;
+          }
+          return record;
+        }
+        /**
+         * Print a finished tree (or hand it to the custom reporter)
+         */
+        _report(record) {
+          if (this.reporter) {
+            this.reporter(record);
+            return;
+          }
+          const detailed = record.trackingMode === exports.TrackingModes.DETAILED || record.trackingMode === exports.TrackingModes.DEBUG;
+          console.log((0, records_1.formatTree)(record, {
+            detailed,
+            showErrors: detailed,
+            blockingThreshold: this.blockingThreshold
+          }));
+        }
+        /**
+         * Run one call of `fn` with tracking (shared by createTrackable and track)
+         */
+        _invoke(fn, thisArg, args, options, label) {
+          if (!this.enabled) {
+            return fn.apply(thisArg, args);
+          }
+          const sampleRate = options.sampleRate !== void 0 ? clampRate(options.sampleRate) : this.defaultSampleRate;
+          const shouldSample = Math.random() < sampleRate;
+          if (!shouldSample) {
+            return fn.apply(thisArg, args);
+          }
+          const nested = this.enableNestedTracking && options.enableNestedTracking !== false;
+          const explicitParentId = options.parentExecutionId || null;
+          const parentExecutionId = explicitParentId !== null && explicitParentId !== void 0 ? explicitParentId : nested ? this.context.current() : null;
+          const executionId = this.startTimer(label, parentExecutionId, options, args);
+          let result;
+          try {
+            if (this.wrappers.length > 0) {
+              result = this._wrap({ id: executionId, label, parentId: parentExecutionId }, () => nested ? this.context.apply(executionId, fn, thisArg, args) : fn.apply(thisArg, args));
+            } else {
+              result = nested ? this.context.apply(executionId, fn, thisArg, args) : fn.apply(thisArg, args);
+            }
+          } catch (error) {
+            this.endTimer(executionId, void 0, error);
+            throw error;
+          }
+          if (isNativePromise(result)) {
+            this.markSyncEnd(executionId);
+            return result.then((resolvedValue) => {
+              this.endTimer(executionId, resolvedValue);
+              return resolvedValue;
+            }, (error) => {
+              this.endTimer(executionId, void 0, error);
+              throw error;
+            });
+          }
+          this.endTimer(executionId, result);
+          return result;
+        }
+        /**
+         * Create a trackable version of a function
+         * @param fn Function to track
+         * @param options Tracking options
+         * @returns Tracked version of the function
+         */
+        createTrackable(fn, options = {}) {
+          var _a;
+          if (typeof fn !== "function") {
+            throw new Error("First argument must be a function");
+          }
+          const label = options.label || fn.name || "anonymous";
+          const silent = (_a = options.silent) !== null && _a !== void 0 ? _a : this.silent;
+          const trackingMode = options.trackingMode || this.trackingMode;
+          if (trackingMode === exports.TrackingModes.PERFORMANCE && silent && !this.enableNestedTracking) {
+            return fn;
+          }
+          const invoke = (thisArg, args) => this._invoke(fn, thisArg, args, options, label);
+          const trackedFn = function(...args) {
+            return invoke(this, args);
+          };
+          Object.defineProperty(trackedFn, "name", { value: fn.name, configurable: true });
+          Object.defineProperty(trackedFn, "length", { value: fn.length });
+          return trackedFn;
+        }
+        /**
+         * Start a manually-ended execution (a "span"). Use `run()` to execute code
+         * as part of it, so tracked calls inside attach as children, and `end()`
+         * when the work is finished.
+         */
+        startSpan(label, options = {}) {
+          if (!this.enabled) {
+            return NOOP_SPAN;
+          }
+          const sampleRate = options.sampleRate !== void 0 ? clampRate(options.sampleRate) : this.defaultSampleRate;
+          if (!(Math.random() < sampleRate)) {
+            return NOOP_SPAN;
+          }
+          const nested = this.enableNestedTracking && options.enableNestedTracking !== false;
+          const explicitParentId = options.parentExecutionId || null;
+          const parentExecutionId = explicitParentId !== null && explicitParentId !== void 0 ? explicitParentId : nested ? this.context.current() : null;
+          const executionId = this.startTimer(label || "anonymous", parentExecutionId, {
+            trackMemory: options.trackMemory,
+            silent: options.silent,
+            trackingMode: options.trackingMode,
+            threshold: options.threshold
+          });
+          let ended = false;
+          return {
+            id: executionId,
+            setLabel: (newLabel) => {
+              const execution = this.activeExecutions.get(executionId);
+              if (execution && newLabel) {
+                execution.label = newLabel;
+              }
+            },
+            run: (fn) => {
+              const runInContext = () => nested ? this.context.run(executionId, fn) : fn();
+              const result = this.wrappers.length > 0 ? this._wrap({ id: executionId, label: label || "anonymous", parentId: parentExecutionId }, runInContext) : runInContext();
+              const execution = this.activeExecutions.get(executionId);
+              if (execution && execution.syncEndTime === void 0) {
+                execution.syncEndTime = (0, exports.getTimestamp)();
+              }
+              return result;
+            },
+            end: (error) => {
+              if (ended)
+                return;
+              ended = true;
+              this.endTimer(executionId, void 0, error !== null && error !== void 0 ? error : null);
+            }
+          };
+        }
+        /**
+         * Track a module's methods
+         * @param module Module to track
+         * @param options Tracking options
+         * @returns Tracked module
+         */
+        trackModule(module2, options = {}) {
+          var _a;
+          if (!module2 || typeof module2 !== "object") {
+            throw new Error("Module must be an object");
+          }
+          const prefix = options.prefix || "";
+          const trackingMode = options.trackingMode || this.trackingMode;
+          if (trackingMode === exports.TrackingModes.PERFORMANCE && ((_a = options.silent) !== null && _a !== void 0 ? _a : this.silent) && !this.enableNestedTracking) {
+            return module2;
+          }
+          const trackedModule = Object.create(Object.getPrototypeOf(module2));
+          Object.getOwnPropertyNames(module2).forEach((key) => {
+            const descriptor = Object.getOwnPropertyDescriptor(module2, key);
+            if (!descriptor)
+              return;
+            if (typeof module2[key] === "function") {
+              const methodOptions = {
+                ...options,
+                label: `${prefix}${key}`
+              };
+              trackedModule[key] = this.createTrackable(module2[key], methodOptions);
+            } else {
+              Object.defineProperty(trackedModule, key, descriptor);
+            }
+          });
+          return trackedModule;
+        }
+        /**
+         * Track a function execution directly
+         * @param fn Function to track
+         * @param options Tracking options
+         * @returns Function result
+         */
+        track(fn, options = {}) {
+          var _a;
+          if (typeof fn !== "function") {
+            throw new Error("First argument must be a function");
+          }
+          if ((options.trackingMode || this.trackingMode) === exports.TrackingModes.PERFORMANCE && ((_a = options.silent) !== null && _a !== void 0 ? _a : this.silent) && !this.enableNestedTracking) {
+            return fn.apply(options.thisContext, options.args || []);
+          }
+          const label = options.label || fn.name || "anonymous";
+          return this._invoke(fn, options.thisContext, options.args || [], options, label);
+        }
+        /**
+         * Reset the tracker state
+         */
+        reset() {
+          this.executionTree = /* @__PURE__ */ new Map();
+          this.currentExecutionId = 0;
+          this.activeExecutions = /* @__PURE__ */ new Map();
+          if (this.stats) {
+            this.stats.reset();
+          }
+        }
+      };
+      exports.OptimizedExecutionTracker = OptimizedExecutionTracker;
+      var OptimizedPerformanceMonitor = class {
+        /**
+         * Create a new performance monitor instance
+         * @param options Configuration options
+         */
+        constructor(options = {}) {
+          var _a, _b, _c;
+          this.config = {
+            trackingMode: options.trackingMode || DEFAULT_TRACKING_MODE,
+            silent: options.silent || false,
+            trackMemory: options.trackMemory !== void 0 ? options.trackMemory : true,
+            enableNestedTracking: options.enableNestedTracking !== void 0 ? options.enableNestedTracking : true,
+            threshold: (_a = options.threshold) !== null && _a !== void 0 ? _a : 0,
+            sampleRate: options.sampleRate !== void 0 ? clampRate(options.sampleRate) : 1,
+            enabled: (_b = options.enabled) !== null && _b !== void 0 ? _b : true,
+            blockingThreshold: (_c = options.blockingThreshold) !== null && _c !== void 0 ? _c : 50
+          };
+          this.executionTracker = new OptimizedExecutionTracker({
+            trackingMode: this.config.trackingMode,
+            silent: this.config.silent,
+            showMemoryUsage: this.config.trackMemory,
+            enableNestedTracking: this.config.enableNestedTracking,
+            threshold: this.config.threshold,
+            sampleRate: this.config.sampleRate,
+            enabled: this.config.enabled,
+            blockingThreshold: this.config.blockingThreshold,
+            stats: options.stats,
+            reporter: options.reporter,
+            plugins: options.plugins,
+            asyncLocalStorage: options.asyncLocalStorage
+          });
+          if (options.onComplete) {
+            this.onComplete(options.onComplete);
+          }
+        }
+        /**
+         * Track a function execution
+         * @param fn The function to track
+         * @param options Tracking options
+         * @returns Result of the tracked function
+         */
+        track(fn, options = {}) {
+          if (typeof fn !== "function") {
+            throw new Error("First argument must be a function");
+          }
+          return this.executionTracker.track(fn, options);
+        }
+        /**
+         * Create a trackable version of a function
+         * @param fn The function to track
+         * @param options Tracking options
+         * @returns Tracked version of the function
+         */
+        createTrackable(fn, options = {}) {
+          if (typeof fn !== "function") {
+            throw new Error("First argument must be a function");
+          }
+          return this.executionTracker.createTrackable(fn, options);
+        }
+        /**
+         * Register a module for tracking
+         * @param module The module or object containing methods to track
+         * @param options Tracking options
+         * @returns Modified module with tracked methods
+         */
+        registerModule(module2, options = {}) {
+          if (!module2 || typeof module2 !== "object") {
+            throw new Error("Module must be an object");
+          }
+          return this.executionTracker.trackModule(module2, options);
+        }
+        /**
+         * Track every method of an object or class instance, including methods
+         * inherited from its prototype, without copying it. Returns a proxy:
+         * state changes go to the original object, and methods run with the
+         * original object as `this` (so private #fields keep working).
+         */
+        trackObject(target, options = {}) {
+          var _a;
+          if (!target || typeof target !== "object" && typeof target !== "function") {
+            throw new Error("trackObject expects an object");
+          }
+          const ctorName = target.constructor && target.constructor !== Object ? target.constructor.name : "";
+          const prefix = (_a = options.prefix) !== null && _a !== void 0 ? _a : ctorName ? `${ctorName}.` : "";
+          const trackOptions = { ...options };
+          delete trackOptions.prefix;
+          const cache = /* @__PURE__ */ new Map();
+          const wrap = (original, key, proxy2) => {
+            var _a2;
+            const tracked = this.createTrackable(original, {
+              ...trackOptions,
+              label: (_a2 = trackOptions.label) !== null && _a2 !== void 0 ? _a2 : `${prefix}${key}`
+            });
+            return function(...args) {
+              return tracked.apply(this === proxy2 ? target : this, args);
+            };
+          };
+          const proxy = new Proxy(target, {
+            get: (obj, key, receiver) => {
+              const value = Reflect.get(obj, key, receiver);
+              if (typeof value !== "function" || typeof key === "symbol" || key === "constructor" || Object.prototype[key] === value) {
+                return value;
+              }
+              const hit = cache.get(key);
+              if (hit && hit.original === value) {
+                return hit.tracked;
+              }
+              const tracked = wrap(value, key, proxy);
+              cache.set(key, { original: value, tracked });
+              return tracked;
+            }
+          });
+          return proxy;
+        }
+        /**
+         * Method decorator. Works with TypeScript 5 / TC39 standard decorators and
+         * with legacy `experimentalDecorators`. The label defaults to
+         * "ClassName.method".
+         *
+         *   class UserService {
+         *     @tp.traced()
+         *     async getUser(id: string) { ... }
+         *   }
+         */
+        traced(options = {}) {
+          const trackables = /* @__PURE__ */ new Map();
+          const trackedFor = (fn, label) => {
+            let tracked = trackables.get(label);
+            if (!tracked) {
+              tracked = this.createTrackable(fn, { ...options, label });
+              trackables.set(label, tracked);
+            }
+            return tracked;
+          };
+          const ownerName = (receiver) => {
+            var _a;
+            return typeof receiver === "function" ? receiver.name : ((_a = receiver === null || receiver === void 0 ? void 0 : receiver.constructor) === null || _a === void 0 ? void 0 : _a.name) || "anonymous";
+          };
+          const wrapMethod = (fn, methodName) => {
+            const wrapped = function(...args) {
+              var _a;
+              const label = (_a = options.label) !== null && _a !== void 0 ? _a : `${ownerName(this)}.${methodName}`;
+              return trackedFor(fn, label).apply(this, args);
+            };
+            Object.defineProperty(wrapped, "name", { value: fn.name, configurable: true });
+            Object.defineProperty(wrapped, "length", { value: fn.length, configurable: true });
+            return wrapped;
+          };
+          return (target, context, descriptor) => {
+            if (typeof target === "function" && context && typeof context === "object" && "kind" in context) {
+              if (context.kind !== "method") {
+                throw new TypeError("@traced can only decorate methods");
+              }
+              return wrapMethod(target, String(context.name));
+            }
+            if (descriptor && typeof descriptor.value === "function") {
+              descriptor.value = wrapMethod(descriptor.value, String(context));
+              return descriptor;
+            }
+            throw new TypeError("@traced can only decorate methods");
+          };
+        }
+        /**
+         * Start a manually-ended execution (a span), e.g. for a request:
+         *
+         *   const span = tp.start('GET /users');
+         *   span.run(() => next());      // tracked calls inside become children
+         *   res.on('finish', () => span.end());
+         */
+        start(label, options = {}) {
+          return this.executionTracker.startSpan(label, options);
+        }
+        /**
+         * Register a plugin (exporter, custom sink). Returns an unsubscribe function.
+         */
+        use(plugin) {
+          return this.executionTracker.use(plugin);
+        }
+        /**
+         * Call `listener` with every finished top-level execution tree (even when
+         * silent or below threshold). Returns an unsubscribe function.
+         */
+        onComplete(listener) {
+          return this.use({ name: "onComplete", onComplete: listener });
+        }
+        /**
+         * Call `listener` for every finished call (nested ones included) that
+         * took at least `threshold` ms. Pass a number, or per-label thresholds
+         * with an optional '*' default:
+         *
+         *   tp.onSlow(200, (call, root) => logger.warn(`${call.label} took ${call.duration}ms in ${root.label}`));
+         *   tp.onSlow({ 'db.query': 50, 'GET /search': 500, '*': 1000 }, alert);
+         *
+         * Works in every tracking mode and when silent. Returns an unsubscribe function.
+         */
+        onSlow(threshold, listener) {
+          const limitFor = typeof threshold === "number" ? () => threshold : (label) => label in threshold ? threshold[label] : threshold["*"];
+          return this.use({
+            name: "onSlow",
+            onComplete: (root) => {
+              (0, records_1.walkRecords)(root, (record) => {
+                const limit = limitFor(record.label);
+                if (limit !== void 0 && record.duration >= limit)
+                  listener(record, root);
+              });
+            }
+          });
+        }
+        getStats(label) {
+          const stats = this.executionTracker.stats;
+          if (label !== void 0) {
+            return stats ? stats.get(label) : void 0;
+          }
+          return stats ? stats.all() : {};
+        }
+        /** Clear collected statistics */
+        resetStats() {
+          if (this.executionTracker.stats) {
+            this.executionTracker.stats.reset();
+          }
+          return this;
+        }
+        /** Statistics as a text table, slowest total first */
+        formatStats() {
+          return (0, stats_1.formatStatsTable)(this.getStats());
+        }
+        /** Print the statistics table to the console */
+        printStats() {
+          console.log(this.formatStats());
+          return this;
+        }
+        /**
+         * Start recording finished calls for a Chrome/Perfetto trace.
+         *
+         *   const recording = tp.startTrace();
+         *   await work();
+         *   fs.writeFileSync('trace.json', JSON.stringify(recording.stop()));
+         *
+         * Open the file in https://ui.perfetto.dev or chrome://tracing.
+         */
+        startTrace(options = {}) {
+          let unsubscribe = () => void 0;
+          const recorder = (0, exporters_1.createTraceRecorder)({ maxRoots: options.maxRoots, onStop: () => unsubscribe() });
+          unsubscribe = this.use(recorder);
+          return recorder;
+        }
+        /** Turn tracking on */
+        enable() {
+          this.config.enabled = true;
+          this.executionTracker.enabled = true;
+          return this;
+        }
+        /** Turn tracking off: tracked functions become plain pass-through calls */
+        disable() {
+          this.config.enabled = false;
+          this.executionTracker.enabled = false;
+          return this;
+        }
+        /** Whether tracking is on */
+        isEnabled() {
+          return this.config.enabled;
+        }
+        /**
+         * Set configuration options
+         * @param config Configuration to update
+         * @returns Current configuration after update
+         */
+        setConfig(config = {}) {
+          if (config.trackingMode) {
+            this.config.trackingMode = config.trackingMode;
+            this.executionTracker.trackingMode = config.trackingMode;
+          }
+          if (config.silent !== void 0) {
+            this.config.silent = config.silent;
+            this.executionTracker.silent = config.silent;
+          }
+          if (config.trackMemory !== void 0) {
+            this.config.trackMemory = config.trackMemory;
+            this.executionTracker.showMemoryUsage = config.trackMemory;
+          }
+          if (config.enableNestedTracking !== void 0) {
+            this.config.enableNestedTracking = config.enableNestedTracking;
+            this.executionTracker.enableNestedTracking = config.enableNestedTracking;
+          }
+          if (config.threshold !== void 0) {
+            this.config.threshold = config.threshold;
+            this.executionTracker.defaultThreshold = config.threshold;
+          }
+          if (config.sampleRate !== void 0) {
+            this.config.sampleRate = clampRate(config.sampleRate);
+            this.executionTracker.defaultSampleRate = this.config.sampleRate;
+          }
+          if (config.enabled !== void 0) {
+            this.config.enabled = config.enabled;
+            this.executionTracker.enabled = config.enabled;
+          }
+          if (config.blockingThreshold !== void 0) {
+            this.config.blockingThreshold = config.blockingThreshold;
+            this.executionTracker.blockingThreshold = config.blockingThreshold;
+          }
+          if (config.reporter !== void 0) {
+            this.executionTracker.reporter = config.reporter;
+          }
+          if (config.plugins) {
+            config.plugins.forEach((plugin) => this.use(plugin));
+          }
+          if (config.onComplete) {
+            this.onComplete(config.onComplete);
+          }
+          return { ...this.config };
+        }
+        /**
+         * Enable silent mode (no console output)
+         * @returns This instance for chaining
+         */
+        enableSilentMode() {
+          this.config.silent = true;
+          this.executionTracker.silent = true;
+          return this;
+        }
+        /**
+         * Disable silent mode (allow console output)
+         * @returns This instance for chaining
+         */
+        disableSilentMode() {
+          this.config.silent = false;
+          this.executionTracker.silent = false;
+          return this;
+        }
+        /**
+         * Set the tracking mode
+         * @param mode Tracking mode from TrackingMode enum
+         * @returns This instance for chaining
+         */
+        setTrackingMode(mode) {
+          this.config.trackingMode = mode;
+          this.executionTracker.trackingMode = mode;
+          return this;
+        }
+        /**
+         * Get the current tracking mode
+         */
+        getTrackingMode() {
+          return this.config.trackingMode;
+        }
+        /**
+         * Enable memory usage tracking
+         * @returns This instance for chaining
+         */
+        enableMemoryTracking() {
+          this.config.trackMemory = true;
+          this.executionTracker.showMemoryUsage = true;
+          return this;
+        }
+        /**
+         * Disable memory usage tracking
+         * @returns This instance for chaining
+         */
+        disableMemoryTracking() {
+          this.config.trackMemory = false;
+          this.executionTracker.showMemoryUsage = false;
+          return this;
+        }
+        /**
+         * Set the sampling rate
+         * @param rate Sampling rate between 0.0 and 1.0
+         * @returns This instance for chaining
+         */
+        setSampleRate(rate) {
+          this.config.sampleRate = clampRate(rate);
+          this.executionTracker.defaultSampleRate = this.config.sampleRate;
+          return this;
+        }
+        /**
+         * Reset the tracker state (in-flight executions and statistics)
+         * @returns This instance for chaining
+         */
+        reset() {
+          this.executionTracker.reset();
+          return this;
+        }
+      };
+      exports.OptimizedPerformanceMonitor = OptimizedPerformanceMonitor;
+    }
+  });
+
+  // dist/core/timeline.js
+  var require_timeline = __commonJS({
+    "dist/core/timeline.js"(exports) {
+      "use strict";
+      Object.defineProperty(exports, "__esModule", { value: true });
+      exports.performanceTimeline = performanceTimeline;
+      var records_1 = require_records();
+      function performanceTimeline(options = {}) {
+        var _a;
+        const perf = typeof performance !== "undefined" ? performance : void 0;
+        const supported = !!perf && typeof perf.measure === "function";
+        const track = (_a = options.track) !== null && _a !== void 0 ? _a : "traceperf";
+        return {
+          name: "performance-timeline",
+          onComplete(root) {
+            if (!supported)
+              return;
+            (0, records_1.walkRecords)(root, (record) => {
+              const failed = record.error !== void 0 && record.error !== null;
+              const properties = [
+                ["duration", `${record.duration.toFixed(3)} ms`],
+                ["self", `${record.selfDuration.toFixed(3)} ms`]
+              ];
+              if (record.async)
+                properties.push(["sync", `${record.syncDuration.toFixed(3)} ms`]);
+              if (record.memoryDelta !== void 0)
+                properties.push(["heap \u0394", `${(record.memoryDelta / 1024).toFixed(2)} KB`]);
+              if (failed)
+                properties.push(["error", record.error instanceof Error ? record.error.message : String(record.error)]);
+              try {
+                perf.measure(record.label, {
+                  start: record.startTime,
+                  duration: record.duration,
+                  detail: {
+                    devtools: {
+                      dataType: "track-entry",
+                      track,
+                      ...options.trackGroup ? { trackGroup: options.trackGroup } : {},
+                      color: failed ? "error" : "primary",
+                      properties,
+                      tooltipText: `${record.label}: ${record.duration.toFixed(2)} ms`
+                    }
+                  }
+                });
+                if (!options.keep && typeof perf.clearMeasures === "function")
+                  perf.clearMeasures(record.label);
+              } catch (_a2) {
+              }
+            });
+          }
+        };
+      }
+    }
+  });
+
+  // dist/instrument.js
+  var require_instrument = __commonJS({
+    "dist/instrument.js"(exports) {
+      "use strict";
+      Object.defineProperty(exports, "__esModule", { value: true });
+      exports.instrumentFetch = instrumentFetch;
+      exports.instrumentHttp = instrumentHttp;
+      exports.instrumentMethods = instrumentMethods;
+      exports.prismaExtension = prismaExtension;
+      exports.normalizePath = normalizePath;
+      exports.instrumentHttpServer = instrumentHttpServer;
+      var env_1 = require_env();
+      var PATCHED = /* @__PURE__ */ Symbol.for("traceperf.instrumented");
+      function describeUrl(input) {
+        try {
+          if (typeof input === "string" || input instanceof URL) {
+            const url = new URL(String(input), "http://localhost");
+            return { host: url.host, path: url.pathname };
+          }
+          if (input && typeof input.url === "string") {
+            const url = new URL(input.url, "http://localhost");
+            return { method: input.method, host: url.host, path: url.pathname };
+          }
+        } catch (_a) {
+        }
+        return { host: "unknown", path: "" };
+      }
+      function instrumentFetch(tp, options = {}) {
+        const g = typeof globalThis !== "undefined" ? globalThis : void 0;
+        if (!g || typeof g.fetch !== "function")
+          return () => void 0;
+        if (g.fetch[PATCHED])
+          return () => void 0;
+        const { errorStatus = 500, ...trackOptions } = options;
+        const original = g.fetch;
+        const patched = function fetch(input, init) {
+          const { method: inputMethod, host, path } = describeUrl(input);
+          const method = init && init.method || inputMethod || "GET";
+          const span = tp.start(`fetch ${method.toUpperCase()} ${host}${path}`, trackOptions);
+          let promise;
+          try {
+            promise = span.run(() => original.call(this, input, init));
+          } catch (error) {
+            span.end(error);
+            throw error;
+          }
+          return Promise.resolve(promise).then((response) => {
+            span.end(response && response.status >= errorStatus ? new Error(`HTTP ${response.status}`) : void 0);
+            return response;
+          }, (error) => {
+            span.end(error);
+            throw error;
+          });
+        };
+        patched[PATCHED] = original;
+        g.fetch = patched;
+        return () => {
+          if (g.fetch === patched)
+            g.fetch = original;
+        };
+      }
+      function instrumentHttp(tp, options = {}) {
+        const { errorStatus = 500, ...trackOptions } = options;
+        const restores = [];
+        for (const moduleName of ["http", "https"]) {
+          const mod = (0, env_1.loadNodeBuiltin)(moduleName);
+          if (!mod)
+            continue;
+          for (const fnName of ["request", "get"]) {
+            const original = mod[fnName];
+            if (typeof original !== "function" || original[PATCHED])
+              continue;
+            const patched = function(...args) {
+              const span = tp.start(`${moduleName} request`, trackOptions);
+              let req;
+              try {
+                req = span.run(() => original.apply(this, args));
+              } catch (error) {
+                span.end(error);
+                throw error;
+              }
+              const host = typeof req.getHeader === "function" && req.getHeader("host") || req.host || "unknown";
+              span.setLabel(`${moduleName} ${req.method || "GET"} ${host}${String(req.path || "").split("?")[0]}`);
+              let ended = false;
+              let statusError;
+              const end = (error = statusError) => {
+                if (ended)
+                  return;
+                ended = true;
+                span.end(error);
+              };
+              req.once("response", (res) => {
+                statusError = res.statusCode >= errorStatus ? new Error(`HTTP ${res.statusCode}`) : void 0;
+                res.once("end", () => end());
+                res.once("close", () => end());
+              });
+              req.once("error", (error) => end(error));
+              req.once("close", () => end());
+              return req;
+            };
+            patched[PATCHED] = original;
+            mod[fnName] = patched;
+            restores.push(() => {
+              if (mod[fnName] === patched)
+                mod[fnName] = original;
+            });
+          }
+        }
+        return () => restores.forEach((restore) => restore());
+      }
+      function instrumentMethods(tp, target, methods, options = {}) {
+        const { prefix, labelFor, ...trackOptions } = options;
+        const ctor = target.constructor;
+        const ownerName = typeof target === "function" ? target.name : ctor && ctor.prototype === target ? ctor.name : ctor && ctor !== Object ? ctor.name : "";
+        const labelPrefix = prefix !== null && prefix !== void 0 ? prefix : ownerName ? `${ownerName}.` : "";
+        const names = methods !== null && methods !== void 0 ? methods : Object.getOwnPropertyNames(target).filter((name) => {
+          if (name === "constructor")
+            return false;
+          const descriptor = Object.getOwnPropertyDescriptor(target, name);
+          return !!descriptor && typeof descriptor.value === "function";
+        });
+        const restores = [];
+        for (const name of names) {
+          const original = target[name];
+          if (typeof original !== "function" || original[PATCHED])
+            continue;
+          const patched = function(...args) {
+            const label = labelFor ? labelFor(name, args) : `${labelPrefix}${name}`;
+            return tp.track(() => original.apply(this, args), { ...trackOptions, label });
+          };
+          Object.defineProperty(patched, "name", { value: original.name, configurable: true });
+          Object.defineProperty(patched, "length", { value: original.length, configurable: true });
+          patched[PATCHED] = original;
+          const hadOwn = Object.prototype.hasOwnProperty.call(target, name);
+          target[name] = patched;
+          restores.push(() => {
+            if (target[name] !== patched)
+              return;
+            if (hadOwn)
+              target[name] = original;
+            else
+              delete target[name];
+          });
+        }
+        return () => restores.forEach((restore) => restore());
+      }
+      function prismaExtension(tp, options = {}) {
+        return {
+          name: "traceperf",
+          query: {
+            $allModels: {
+              $allOperations(params) {
+                var _a, _b;
+                const label = (_a = options.label) !== null && _a !== void 0 ? _a : `prisma.${(_b = params.model) !== null && _b !== void 0 ? _b : "raw"}.${params.operation}`;
+                return tp.track(() => params.query(params.args), { ...options, label });
+              }
+            }
+          }
+        };
+      }
+      function normalizePath(url) {
+        let path = String(url || "/");
+        const q = path.search(/[?#]/);
+        if (q !== -1)
+          path = path.slice(0, q);
+        if (!path)
+          return "/";
+        if (!/\d/.test(path))
+          return path;
+        const segments = path.split("/");
+        for (let i = 0; i < segments.length; i++) {
+          const seg = segments[i];
+          if (seg && /\d/.test(seg) && isIdSegment(seg))
+            segments[i] = ":id";
+        }
+        return segments.join("/");
+      }
+      var UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+      function isIdSegment(seg) {
+        if (/^\d+$/.test(seg))
+          return true;
+        if (seg.length === 36 && UUID.test(seg))
+          return true;
+        if (seg.length >= 16 && /^[0-9a-f]+$/i.test(seg))
+          return true;
+        return seg.length >= 20 && /^[A-Za-z0-9_-]+$/.test(seg);
+      }
+      function instrumentHttpServer(tp, options = {}) {
+        const { errorStatus = 500, labelFor, ignore, ...trackOptions } = options;
+        const restores = [];
+        for (const moduleName of ["http", "https"]) {
+          const mod = (0, env_1.loadNodeBuiltin)(moduleName);
+          const proto = mod && mod.Server && mod.Server.prototype;
+          if (!proto)
+            continue;
+          const original = proto.emit;
+          if (typeof original !== "function" || original[PATCHED])
+            continue;
+          const hadOwn = Object.prototype.hasOwnProperty.call(proto, "emit");
+          const patched = function(event, req, res, ...rest) {
+            if (event !== "request" || !req || !res || typeof res.once !== "function" || ignore && ignore(req)) {
+              return original.call(this, event, req, res, ...rest);
+            }
+            const label = labelFor ? labelFor(req) : `${req.method || "GET"} ${normalizePath(req.url)}`;
+            const span = tp.start(label, trackOptions);
+            if (!span.id)
+              return original.call(this, event, req, res, ...rest);
+            let ended = false;
+            const end = (error) => {
+              if (ended)
+                return;
+              ended = true;
+              span.end(error);
+            };
+            res.once("finish", () => end(res.statusCode >= errorStatus ? new Error(`HTTP ${res.statusCode}`) : void 0));
+            res.once("close", () => end(res.writableFinished ? void 0 : new Error("connection closed before the response was sent")));
+            try {
+              return span.run(() => original.call(this, event, req, res, ...rest));
+            } catch (error) {
+              end(error);
+              throw error;
+            }
+          };
+          patched[PATCHED] = original;
+          proto.emit = patched;
+          restores.push(() => {
+            if (proto.emit !== patched)
+              return;
+            if (hadOwn)
+              proto.emit = original;
+            else
+              delete proto.emit;
+          });
+        }
+        return () => restores.forEach((restore) => restore());
+      }
+    }
+  });
+
+  // dist/browser.js
+  var require_browser = __commonJS({
+    "dist/browser.js"(exports, module) {
+      Object.defineProperty(exports, "__esModule", { value: true });
+      exports.instrumentFetch = exports.formatTree = exports.recordToJSON = exports.openTelemetryExporter = exports.jsonLinesExporter = exports.toChromeTrace = exports.performanceTimeline = exports.BrowserLogger = exports.TrackingMode = void 0;
+      exports.createBrowserLogger = createBrowserLogger;
+      exports.createTracePerf = createTracePerf;
+      var optimized_performance_monitor_1 = require_optimized_performance_monitor();
+      exports.TrackingMode = optimized_performance_monitor_1.TrackingModes;
+      var preserveSignature = (wrapper, fn) => {
+        Object.defineProperty(wrapper, "name", { value: fn.name, configurable: true });
+        Object.defineProperty(wrapper, "length", { value: fn.length, configurable: true });
+      };
+      var BrowserLogger = class extends optimized_performance_monitor_1.OptimizedPerformanceMonitor {
+        constructor(config = {}) {
+          super({
+            trackingMode: config.trackingMode,
+            silent: config.silent,
+            trackMemory: config.trackMemory,
+            enableNestedTracking: config.enableNestedTracking,
+            threshold: config.threshold,
+            sampleRate: config.sampleRate,
+            enabled: config.enabled,
+            blockingThreshold: config.blockingThreshold,
+            stats: config.stats,
+            plugins: config.plugins,
+            onComplete: config.onComplete,
+            reporter: config.reporter,
+            asyncLocalStorage: config.asyncLocalStorage
+          });
+          this._mode = "dev";
+          this._indentLevel = 0;
+          this._mode = config.mode || "dev";
+          this._slowThreshold = config.performanceThreshold || 100;
+          if (!config.reporter) {
+            this.setConfig({ reporter: (root) => console.log(this.formatFlow(root)) });
+          }
+        }
+        /**
+         * Render an execution tree in the browser output format
+         */
+        formatFlow(root) {
+          const lines = ["Execution Flow:"];
+          const visit = (record, level) => {
+            const indent = "  ".repeat(level);
+            const slowThreshold = record.threshold > 0 ? record.threshold : this._slowThreshold;
+            const isSlow = record.duration > slowThreshold;
+            const memory = record.memoryDelta !== void 0 && record.memoryDelta > 0 ? ` [${formatMemorySize(record.memoryDelta)}]` : "";
+            lines.push(`${indent}\u2192 ${record.label} (${record.duration.toFixed(2)}ms)${isSlow ? " [SLOW]" : ""}${memory}`);
+            const suggestion = isSlow ? slowSuggestion(record.label, record.duration) : "";
+            if (suggestion) {
+              lines.push(`${indent}  \u26A0\uFE0F ${suggestion}`);
+            }
+            record.children.filter((child) => child.duration >= child.threshold).forEach((child) => visit(child, level + 1));
+          };
+          visit(root, 0);
+          return lines.join("\n");
+        }
+        info(message, ...args) {
+          this.log("info", message, args);
+        }
+        warn(message, ...args) {
+          this.log("warn", message, args);
+        }
+        error(message, ...args) {
+          this.log("error", message, args);
+        }
+        debug(message, ...args) {
+          if (this._mode === "prod") {
+            return;
+          }
+          this.log("debug", message, args);
+        }
+        group(label) {
+          this.info(label);
+          this._indentLevel++;
+          if (typeof console.group === "function") {
+            console.group(label);
+          }
+        }
+        groupEnd() {
+          if (this._indentLevel > 0) {
+            this._indentLevel--;
+          }
+          if (typeof console.groupEnd === "function") {
+            console.groupEnd();
+          }
+        }
+        setMode(mode) {
+          this._mode = mode;
+        }
+        getMode() {
+          return this._mode;
+        }
+        /**
+         * Set the tracking mode
+         * @param mode Tracking mode from TrackingMode enum
+         * @returns This instance for chaining
+         */
+        setTrackingMode(mode) {
+          super.setTrackingMode(mode);
+          return this;
+        }
+        /**
+         * Create a trackable version of a function. Calls go through `track()`,
+         * so nested trackables attach to their caller.
+         */
+        createTrackable(fn, options = {}) {
+          const label = options.label || fn.name || "anonymous";
+          const run = (thisArg, args) => this.track(() => fn.apply(thisArg, args), {
+            ...options,
+            label
+          });
+          const tracked = function(...args) {
+            return run(this, args);
+          };
+          preserveSignature(tracked, fn);
+          return tracked;
+        }
+        log(level, message, args) {
+          if (this._mode === "prod" && level !== "error") {
+            return;
+          }
+          if (this._mode === "staging" && (level === "debug" || level === "info")) {
+            return;
+          }
+          let formattedMessage;
+          if (typeof message === "string") {
+            formattedMessage = message;
+          } else {
+            try {
+              formattedMessage = JSON.stringify(message, null, 2);
+            } catch (_a) {
+              formattedMessage = String(message);
+            }
+          }
+          const indent = "  ".repeat(this._indentLevel);
+          formattedMessage = `${indent}${formattedMessage}`;
+          switch (level) {
+            case "info":
+              console.info(formattedMessage, ...args);
+              break;
+            case "warn":
+              console.warn(formattedMessage, ...args);
+              break;
+            case "error":
+              console.error(formattedMessage, ...args);
+              break;
+            case "debug":
+              console.debug(formattedMessage, ...args);
+              break;
+          }
+        }
+      };
+      exports.BrowserLogger = BrowserLogger;
+      function formatMemorySize(bytes) {
+        if (bytes < 1024) {
+          return `${bytes.toFixed(2)}B`;
+        } else if (bytes < 1024 * 1024) {
+          return `${(bytes / 1024).toFixed(2)}KB`;
+        } else if (bytes < 1024 * 1024 * 1024) {
+          return `${(bytes / (1024 * 1024)).toFixed(2)}MB`;
+        }
+        return `${(bytes / (1024 * 1024 * 1024)).toFixed(2)}GB`;
+      }
+      function slowSuggestion(name, duration) {
+        if (duration > 500) {
+          return `Function "${name}" took ${duration.toFixed(2)}ms to execute. Consider optimizing or breaking it down into smaller functions.`;
+        } else if (duration > 200) {
+          return `Function "${name}" took ${duration.toFixed(2)}ms to execute. Consider optimizing if called frequently.`;
+        } else if (duration > 100) {
+          return `Function "${name}" took ${duration.toFixed(2)}ms to execute. Monitor if called in critical paths.`;
+        }
+        return "";
+      }
+      function createBrowserLogger(config = {}) {
+        if (config.logger instanceof BrowserLogger) {
+          return config.logger;
+        }
+        return new BrowserLogger(config);
+      }
+      function createTracePerf(config = {}) {
+        return createBrowserLogger(config);
+      }
+      var browserLogger = createBrowserLogger();
+      exports.default = browserLogger;
+      var timeline_1 = require_timeline();
+      Object.defineProperty(exports, "performanceTimeline", { enumerable: true, get: function() {
+        return timeline_1.performanceTimeline;
+      } });
+      var exporters_1 = require_exporters();
+      Object.defineProperty(exports, "toChromeTrace", { enumerable: true, get: function() {
+        return exporters_1.toChromeTrace;
+      } });
+      Object.defineProperty(exports, "jsonLinesExporter", { enumerable: true, get: function() {
+        return exporters_1.jsonLinesExporter;
+      } });
+      Object.defineProperty(exports, "openTelemetryExporter", { enumerable: true, get: function() {
+        return exporters_1.openTelemetryExporter;
+      } });
+      Object.defineProperty(exports, "recordToJSON", { enumerable: true, get: function() {
+        return exporters_1.recordToJSON;
+      } });
+      var records_1 = require_records();
+      Object.defineProperty(exports, "formatTree", { enumerable: true, get: function() {
+        return records_1.formatTree;
+      } });
+      var instrument_1 = require_instrument();
+      Object.defineProperty(exports, "instrumentFetch", { enumerable: true, get: function() {
+        return instrument_1.instrumentFetch;
+      } });
+      if (typeof module !== "undefined" && module.exports) {
+        module.exports = Object.assign(browserLogger, module.exports, {
+          default: browserLogger,
+          createBrowserLogger,
+          createTracePerf,
+          BrowserLogger,
+          TrackingMode: exports.TrackingMode
+        });
+      }
+    }
+  });
+  return require_browser();
+})();