@oconde/radar 0.0.0-stage → 0.2.0

package/dist/nest/index.cjs

@@ -0,0 +1,1495 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp(target, key, result);
+  return result;
+};
+var __decorateParam = (index, decorator) => (target, key) => decorator(target, key, index);
+
+// src/nest/index.ts
+var nest_exports = {};
+__export(nest_exports, {
+  RADAR_OPTIONS: () => RADAR_OPTIONS,
+  RadarExceptionFilter: () => RadarExceptionFilter,
+  RadarInterceptor: () => RadarInterceptor,
+  RadarModule: () => RadarModule,
+  RadarService: () => RadarService,
+  shouldCapture: () => shouldCapture
+});
+module.exports = __toCommonJS(nest_exports);
+
+// node_modules/tsup/assets/cjs_shims.js
+var getImportMetaUrl = () => typeof document === "undefined" ? new URL(`file:${__filename}`).href : document.currentScript && document.currentScript.tagName.toUpperCase() === "SCRIPT" ? document.currentScript.src : new URL("main.js", document.baseURI).href;
+var importMetaUrl = /* @__PURE__ */ getImportMetaUrl();
+
+// src/nest/index.ts
+var import_node_module2 = require("module");
+var import_common = require("@nestjs/common");
+var import_core = require("@nestjs/core");
+var import_rxjs = require("rxjs");
+
+// src/context.ts
+var import_node_async_hooks = require("async_hooks");
+var import_node_crypto = require("crypto");
+
+// src/protocol/index.ts
+var INGEST_PATH = "/api/v1/events";
+var CHECKIN_PATH = "/api/v1/checkins/";
+var CHECKIN_SLUG = /^[a-z0-9][a-z0-9-]{0,63}$/;
+var CHECKIN_STATUSES = ["in_progress", "ok", "error"];
+var LIMITS = {
+  batchBytes: 1e6,
+  batchEvents: 500,
+  messageLength: 2e3,
+  stringLength: 2e3,
+  attrsBytes: 16384,
+  bodyBytes: 16384,
+  headers: 50,
+  frames: 50,
+  contextFrames: 10,
+  contextLines: 5,
+  contextLineLength: 300,
+  causeDepth: 5,
+  depth: 6,
+  arrayItems: 50,
+  requestIdLength: 128,
+  checkInIdLength: 64
+};
+
+// src/context.ts
+var STATE_KEY = /* @__PURE__ */ Symbol.for("@oconde/radar");
+function globalState() {
+  const holder = globalThis;
+  let state2 = holder[STATE_KEY];
+  if (!state2) {
+    state2 = { storage: new import_node_async_hooks.AsyncLocalStorage() };
+    holder[STATE_KEY] = state2;
+  }
+  return state2;
+}
+function currentContext() {
+  return globalState().storage.getStore();
+}
+function runWithContext(context, fn) {
+  return globalState().storage.run(context, fn);
+}
+var SAFE_REQUEST_ID = /^[\x21-\x7e]+$/;
+function requestIdFrom(incoming) {
+  const value = incoming?.trim();
+  return value && value.length <= LIMITS.requestIdLength && SAFE_REQUEST_ID.test(value) ? value : (0, import_node_crypto.randomUUID)();
+}
+
+// src/client.ts
+var import_node_crypto3 = require("crypto");
+var import_node_os = require("os");
+var import_node_perf_hooks3 = require("perf_hooks");
+
+// src/express.ts
+var import_node_perf_hooks = require("perf_hooks");
+
+// src/redact.ts
+var import_node_crypto2 = require("crypto");
+var SECRET_WORDS = /* @__PURE__ */ new Set([
+  "pass",
+  "passwd",
+  "password",
+  "passwords",
+  "senha",
+  "secret",
+  "secrets",
+  "token",
+  "tokens",
+  "authorization",
+  "auth",
+  "cookie",
+  "cookies",
+  "apikey",
+  "privatekey",
+  "cpf",
+  "card",
+  "cvv",
+  "cvc",
+  "pin",
+  "otp",
+  "signature",
+  "jwt",
+  "session",
+  "sessionid",
+  "credential",
+  "credentials"
+]);
+var SECRET_PAIRS = [
+  ["api", "key"],
+  ["private", "key"],
+  ["access", "key"],
+  ["secret", "key"]
+];
+var LOW_ENTROPY_WORDS = /* @__PURE__ */ new Set(["pass", "passwd", "password", "passwords", "senha", "cpf", "card", "cvv", "cvc", "pin", "otp"]);
+var CUSTOM_SECRET_HEADER = /^x-.+-(key|secret|token)$/i;
+var AUTH_SCHEME = /^(Bearer|Basic|Token|Digest|ApiKey)\s+/i;
+var JWT_PREFIX = /^eyJ[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}\./;
+var MAX_DEPTH = 8;
+var KEY_SLOT = /* @__PURE__ */ Symbol.for("@oconde/radar/fingerprint-key");
+function fingerprintSlot() {
+  const holder = globalThis;
+  let slot = holder[KEY_SLOT];
+  if (!slot) {
+    slot = { key: (0, import_node_crypto2.randomBytes)(32) };
+    holder[KEY_SLOT] = slot;
+  }
+  return slot;
+}
+function setFingerprintSecret(secret) {
+  fingerprintSlot().key = secret ? (0, import_node_crypto2.createHash)("sha256").update(`@oconde/radar:${secret}`).digest() : (0, import_node_crypto2.randomBytes)(32);
+}
+function fingerprint(value) {
+  return (0, import_node_crypto2.createHmac)("sha256", fingerprintSlot().key).update(value).digest("hex").slice(0, 8);
+}
+function words(name) {
+  return name.replace(/([a-z0-9])([A-Z])/g, "$1 $2").toLowerCase().split(/[^a-z0-9]+/).filter(Boolean);
+}
+function isSensitiveKey(key) {
+  const parts = words(key);
+  if (parts.length === 1 && parts[0] === "key") return true;
+  if (parts.some((part) => SECRET_WORDS.has(part))) return true;
+  return SECRET_PAIRS.some(([first, second]) => parts.some((part, index) => part === first && parts[index + 1] === second));
+}
+function isLowEntropyKey(key) {
+  return words(key).some((part) => LOW_ENTROPY_WORDS.has(part));
+}
+function isSensitiveHeader(name) {
+  return isSensitiveKey(name) || CUSTOM_SECRET_HEADER.test(name);
+}
+function looksLikeCredential(value) {
+  const head = value.slice(0, 64);
+  return AUTH_SCHEME.test(head.slice(0, 16)) || JWT_PREFIX.test(head);
+}
+function maskValue(value, revealEdges = true) {
+  const text = typeof value === "string" ? value : JSON.stringify(value) ?? String(value);
+  const scheme = AUTH_SCHEME.exec(text.slice(0, 16));
+  const prefix = scheme ? `${scheme[1]} ` : "";
+  const secret = scheme ? text.slice(scheme[0].length) : text;
+  const visible = revealEdges && secret.length > 12 ? `${secret.slice(0, 4)}\u2026${secret.slice(-4)}` : "\u2022\u2022\u2022";
+  return `${prefix}${visible} #${fingerprint(text)}`;
+}
+function redactDeep(value, mode, depth = 0) {
+  if (mode === "none" || depth > MAX_DEPTH || value === null) return value;
+  if (typeof value === "string") return looksLikeCredential(value) ? maskValue(value) : value;
+  if (typeof value !== "object") return value;
+  if (Array.isArray(value)) return value.map((item) => redactDeep(item, mode, depth + 1));
+  const result = {};
+  for (const [key, item] of Object.entries(value)) {
+    const hasValue = item !== null && item !== void 0 && item !== "";
+    result[key] = isSensitiveKey(key) && hasValue ? maskValue(item, !isLowEntropyKey(key)) : redactDeep(item, mode, depth + 1);
+  }
+  return result;
+}
+
+// src/serialize.ts
+var TRUNCATED = "\u2026[cortado]";
+var LIMIT_REACHED = "\u2026[limite]";
+var MAX_NODES = 2e3;
+function truncate(value, max = LIMITS.stringLength) {
+  return value.length > max ? value.slice(0, max) + TRUNCATED : value;
+}
+function sanitize(value, depth = 0, seen = /* @__PURE__ */ new WeakSet(), budget = { remaining: MAX_NODES }) {
+  if (value === null || value === void 0) return value;
+  budget.remaining -= 1;
+  switch (typeof value) {
+    case "string":
+      return truncate(value);
+    case "number":
+      return Number.isFinite(value) ? value : String(value);
+    case "boolean":
+      return value;
+    case "bigint":
+      return value.toString();
+    case "function":
+    case "symbol":
+      return void 0;
+  }
+  if (value instanceof Date) return Number.isNaN(value.getTime()) ? null : value.toISOString();
+  if (ArrayBuffer.isView(value) || value instanceof ArrayBuffer) return `[bin\xE1rio ${value.byteLength} bytes]`;
+  if (value instanceof Error) return { name: value.name, message: truncate(value.message) };
+  const object = value;
+  if (seen.has(object)) return "[circular]";
+  if (depth >= LIMITS.depth) return "[profundidade]";
+  if (budget.remaining <= 0) return LIMIT_REACHED;
+  seen.add(object);
+  try {
+    if (Array.isArray(object)) {
+      const items = [];
+      for (const item of object.slice(0, LIMITS.arrayItems)) {
+        if (budget.remaining <= 0) {
+          items.push(LIMIT_REACHED);
+          break;
+        }
+        items.push(sanitize(item, depth + 1, seen, budget) ?? null);
+      }
+      if (object.length > LIMITS.arrayItems) items.push(`\u2026[mais ${object.length - LIMITS.arrayItems}]`);
+      return items;
+    }
+    if (object instanceof Map) return sanitize(Object.fromEntries(object.entries()), depth + 1, seen, budget);
+    if (object instanceof Set) return sanitize([...object], depth + 1, seen, budget);
+    const result = {};
+    for (const key in object) {
+      if (!Object.prototype.hasOwnProperty.call(object, key)) continue;
+      if (budget.remaining <= 0) {
+        result["\u2026"] = LIMIT_REACHED;
+        break;
+      }
+      const clean = sanitize(object[key], depth + 1, seen, budget);
+      if (clean !== void 0) result[key] = clean;
+    }
+    return result;
+  } finally {
+    seen.delete(object);
+  }
+}
+function limitBytes(value, maxBytes) {
+  const json = JSON.stringify(value);
+  if (json === void 0 || Buffer.byteLength(json) <= maxBytes) return value;
+  return { _truncated: truncate(json, maxBytes) };
+}
+function prepareAttrs(data, mode) {
+  const clean = redactDeep(sanitize(data), mode);
+  const record = isRecord(clean) ? clean : { value: clean };
+  return limitBytes(record, LIMITS.attrsBytes);
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// src/request.ts
+function headerValue(value) {
+  if (value === void 0) return void 0;
+  return Array.isArray(value) ? value.join(", ") : String(value);
+}
+function requestHeaders(headers, mode) {
+  const result = {};
+  let count = 0;
+  for (const [name, raw] of Object.entries(headers)) {
+    const value = headerValue(raw);
+    if (value === void 0) continue;
+    if (count >= LIMITS.headers) break;
+    const key = name.toLowerCase();
+    result[key] = mode === "mask" && (isSensitiveHeader(key) || looksLikeCredential(value)) ? maskValue(value) : truncate(value);
+    count++;
+  }
+  return result;
+}
+function requestPath(req) {
+  const url = req.originalUrl ?? req.url ?? "";
+  const end = url.indexOf("?");
+  return end >= 0 ? url.slice(0, end) : url;
+}
+function requestRoute(req, route) {
+  if (route) return route;
+  return typeof req.route?.path === "string" ? req.route.path : void 0;
+}
+var ROUTE_PARAM = /^:([A-Za-z_$][\w$]*)/;
+function pathSegments(value) {
+  const segments = value.split("/");
+  while (segments.length > 1 && segments[segments.length - 1] === "") segments.pop();
+  return segments;
+}
+function decodeSegment(value) {
+  try {
+    return decodeURIComponent(value);
+  } catch {
+    return value;
+  }
+}
+function routeParams(req, path) {
+  if (typeof req.route?.path !== "string") return {};
+  const pattern = pathSegments(`${typeof req.baseUrl === "string" ? req.baseUrl : ""}${req.route.path}`).filter((segment, index) => index > 0 || segment !== "");
+  const values = pathSegments(path);
+  if (pattern.length > values.length) return {};
+  const offset = values.length - pattern.length;
+  const result = {};
+  for (let index = 0; index < pattern.length; index++) {
+    const value = values[offset + index];
+    const param = ROUTE_PARAM.exec(pattern[index]);
+    if (!param) {
+      if (pattern[index] !== value) return {};
+      continue;
+    }
+    if (value) result[param[1]] = decodeSegment(value);
+  }
+  return result;
+}
+function pathParams(req, path) {
+  return { ...routeParams(req, path), ...req.params ?? {} };
+}
+function redactPath(path, params, mode) {
+  if (mode === "none" || !params) return path;
+  let result = path;
+  for (const [key, value] of Object.entries(params)) {
+    if (typeof value !== "string" || value.length < 4 || !isSensitiveKey(key)) continue;
+    const masked = maskValue(value, !isLowEntropyKey(key));
+    for (const form of /* @__PURE__ */ new Set([value, encodeURIComponent(value)])) result = result.split(form).join(masked);
+  }
+  return result;
+}
+function safeUrl(req, mode) {
+  const url = req.originalUrl ?? req.url ?? "";
+  const queryStart = url.indexOf("?");
+  const path = queryStart >= 0 ? url.slice(0, queryStart) : url;
+  const query = queryStart >= 0 ? url.slice(queryStart) : "";
+  return redactUrl(redactPath(path, pathParams(req, path), mode) + query, mode);
+}
+function redactUrl(url, mode) {
+  const queryStart = url.indexOf("?");
+  if (mode === "none" || queryStart < 0) return url;
+  const params = new URLSearchParams(url.slice(queryStart + 1));
+  let changed = false;
+  for (const [key, value] of [...params.entries()]) {
+    if (isSensitiveKey(key) && value !== "") {
+      params.set(key, maskValue(value, !isLowEntropyKey(key)));
+      changed = true;
+    }
+  }
+  return changed ? `${url.slice(0, queryStart)}?${params.toString()}` : url;
+}
+function requestInfo(req, mode, extra = {}, detail = "full") {
+  const route = requestRoute(req, extra.route);
+  if (detail === "route") {
+    return {
+      method: (req.method ?? "GET").toUpperCase(),
+      url: route ?? "",
+      ...route ? { route } : {},
+      ...extra.status !== void 0 ? { status: extra.status } : {},
+      ...extra.durationMs !== void 0 ? { durationMs: extra.durationMs } : {}
+    };
+  }
+  const params = prepareRecord(req.params, mode);
+  const query = prepareRecord(req.query, mode);
+  const body = prepareBody(req.body, mode);
+  const userAgent = headerValue(req.headers["user-agent"]);
+  const ip = req.ip ?? req.socket?.remoteAddress;
+  return {
+    method: (req.method ?? "GET").toUpperCase(),
+    url: truncate(safeUrl(req, mode)),
+    ...route ? { route } : {},
+    ...params ? { params } : {},
+    ...query ? { query } : {},
+    headers: requestHeaders(req.headers, mode),
+    ...body !== void 0 ? { body } : {},
+    ...ip ? { ip } : {},
+    ...userAgent ? { userAgent: truncate(userAgent, 500) } : {},
+    ...extra.status !== void 0 ? { status: extra.status } : {},
+    ...extra.durationMs !== void 0 ? { durationMs: extra.durationMs } : {}
+  };
+}
+function isEmptyRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) && Object.keys(value).length === 0;
+}
+function prepareRecord(value, mode) {
+  if (typeof value !== "object" || value === null) return void 0;
+  const clean = prepare(value, mode);
+  return isEmptyRecord(clean) || typeof clean !== "object" || clean === null ? void 0 : clean;
+}
+function prepare(value, mode) {
+  return redactDeep(sanitize(value), mode);
+}
+function prepareBody(body, mode) {
+  if (body === void 0 || body === null || body === "") return void 0;
+  const clean = prepare(body, mode);
+  if (isEmptyRecord(clean)) return void 0;
+  return limitBytes(clean, LIMITS.bodyBytes);
+}
+
+// src/express.ts
+function createMiddleware(logger) {
+  return (req, res, next) => {
+    let context;
+    try {
+      const requestId = requestIdFrom(headerValue(req.headers["x-request-id"]));
+      context = { requestId, startedAt: import_node_perf_hooks.performance.now(), req };
+      res.setHeader("x-request-id", requestId);
+      if (logger.shouldLogRequest(req)) res.once("finish", () => logger.logHttpRequest(context, res.statusCode));
+    } catch {
+      next();
+      return;
+    }
+    runWithContext(context, () => next());
+  };
+}
+
+// src/options.ts
+var DEFAULT_ENDPOINT = "https://radar-ingest.oconde.dev";
+var LEVELS = ["debug", "info", "warn", "error"];
+function resolveOptions(options = {}, env = process.env) {
+  const key = options.key?.trim() || void 0;
+  return {
+    key,
+    endpoint: (options.endpoint ?? DEFAULT_ENDPOINT).replace(/\/+$/, ""),
+    environment: options.environment ?? env.NODE_ENV ?? "production",
+    release: options.release || void 0,
+    enabled: options.enabled ?? Boolean(key),
+    console: options.console ?? false,
+    minLevel: options.minLevel && LEVELS.includes(options.minLevel) ? options.minLevel : "info",
+    redact: options.redact === "none" ? "none" : "mask",
+    requestDetail: options.requestDetail === "route" ? "route" : "full",
+    logRequests: options.logRequests ?? true,
+    ignorePaths: options.ignorePaths ?? ["/healthz", "/health"],
+    captureUnhandled: options.captureUnhandled ?? true,
+    debug: options.debug ?? false
+  };
+}
+function levelEnabled(level, minLevel) {
+  return LEVELS.indexOf(level) >= LEVELS.indexOf(minLevel);
+}
+
+// src/process-handlers.ts
+var import_node_util = require("util");
+var INSTALLED = /* @__PURE__ */ Symbol.for("@oconde/radar/process-handlers");
+var MODE_FLAG = /^--unhandled-rejections=(\S+)$/;
+function unhandledRejectionsMode(execArgv = process.execArgv, nodeOptions = process.env.NODE_OPTIONS ?? "") {
+  for (const arg of [...nodeOptions.split(/\s+/), ...execArgv]) {
+    const match = MODE_FLAG.exec(arg);
+    if (match?.[1]) return match[1];
+  }
+  return "throw";
+}
+function asUncaught(reason) {
+  if (reason instanceof Error) return reason;
+  const error = new Error(
+    `This error originated either by throwing inside of an async function without a catch block, or by rejecting a promise which was not handled with .catch(). The promise rejected with the reason "${(0, import_node_util.inspect)(reason)}".`
+  );
+  error.code = "ERR_UNHANDLED_REJECTION";
+  return error;
+}
+function installProcessHandlers(capturer) {
+  const holder = process;
+  if (holder[INSTALLED]) return;
+  holder[INSTALLED] = true;
+  process.on("unhandledRejection", (reason) => {
+    const mode = unhandledRejectionsMode();
+    const othersListen = process.listenerCount("unhandledRejection") > 1;
+    if (othersListen || mode !== "throw") {
+      capturer.captureUnhandled(reason, "error");
+      if (!othersListen && mode === "warn-with-error-code") process.exitCode = 1;
+      return;
+    }
+    const uncaught = asUncaught(reason);
+    setImmediate(() => {
+      throw uncaught;
+    });
+  });
+  process.on("uncaughtException", (error) => {
+    capturer.captureUnhandled(error, "fatal");
+    if (process.listenerCount("uncaughtException") > 1) return;
+    try {
+      process.stderr.write(`${(0, import_node_util.inspect)(error)}
+`);
+    } catch {
+      process.exitCode = 1;
+    }
+    void capturer.flush(2e3).finally(() => process.exit(1));
+  });
+}
+
+// src/source.ts
+var import_promises = require("fs/promises");
+var import_node_module = require("module");
+var import_node_path = require("path");
+var import_node_url = require("url");
+
+// src/function-name.ts
+var IDENTIFIER = "[A-Za-z_$][\\w$]*";
+var MAX_LINES_UP = 400;
+var MAX_HEADER_LINES = 6;
+var MAX_NAME_LENGTH = 100;
+var CONTROL_BLOCK = /^\s*(?:\}\s*)?(?:if|else|for|while|do|switch|try|catch|finally|with)\b/;
+var CLASS_BODY = new RegExp(`\\bclass\\s+${IDENTIFIER}`);
+var MARKUP_BOUNDARY = /<\/?(?:script|style|template)\b/i;
+var KEYWORDS = /* @__PURE__ */ new Set(["if", "for", "while", "switch", "catch", "function", "return", "new", "typeof", "await", "else", "do", "try"]);
+var NAME_PATTERNS = [
+  new RegExp(`\\bfunction\\s*\\*?\\s*(${IDENTIFIER})\\s*\\(`),
+  new RegExp(`(${IDENTIFIER})\\s*[:=]\\s*(?:async\\s+)?function\\b`),
+  new RegExp(`(${IDENTIFIER})\\s*(?::\\s*[^=]+)?=\\s*(?:async\\s+)?(?:\\([^]*\\)|${IDENTIFIER})\\s*(?::\\s*[^=]+)?=>\\s*$`),
+  new RegExp(`(?:^|[{,(]\\s*)(${IDENTIFIER})\\s*:\\s*(?:async\\s+)?(?:\\([^]*\\)|${IDENTIFIER})\\s*(?::\\s*[^=]+)?=>\\s*$`)
+];
+var METHOD_PATTERN = new RegExp(`^\\s*(?:(?:export|default|public|private|protected|static|async|override|readonly|get|set)\\s+)*\\*?\\s*(${IDENTIFIER})\\s*(?:<[^>]*>)?\\s*\\([^]*\\)\\s*(?::\\s*[^{]+)?$`);
+var ANONYMOUS_FUNCTION = /\bfunction\b|=>/;
+function codeOnly(text) {
+  return text.replace(/(["'`])(?:\\.|(?!\1)[^\\])*\1/g, '""').replace(/\/\*.*?\*\//g, "").replace(/(^|[^:])\/\/.*$/, "$1");
+}
+function parenBalance(text) {
+  let balance = 0;
+  for (const char of text) {
+    if (char === "(") balance += 1;
+    else if (char === ")") balance -= 1;
+  }
+  return balance;
+}
+function headerOf(lines, index, prefix) {
+  let header = prefix;
+  for (let previous = index - 1; previous >= 0 && previous >= index - MAX_HEADER_LINES; previous--) {
+    if (header.trim() !== "" && parenBalance(header) >= 0) break;
+    header = `${codeOnly(lines[previous] ?? "")} ${header}`;
+  }
+  return header;
+}
+function nameIn(header) {
+  const patterns = ANONYMOUS_FUNCTION.test(header) ? NAME_PATTERNS : [...NAME_PATTERNS, METHOD_PATTERN];
+  for (const pattern of patterns) {
+    const name = pattern.exec(header)?.[1];
+    if (name && !KEYWORDS.has(name)) return name.slice(0, MAX_NAME_LENGTH);
+  }
+  return void 0;
+}
+function enclosingFunctionName(lines, line, column) {
+  const start = line - 1;
+  if (start < 0 || start >= lines.length) return void 0;
+  let depth = 0;
+  for (let index = start; index >= 0 && index >= start - MAX_LINES_UP; index--) {
+    const raw = lines[index] ?? "";
+    if (index < start && MARKUP_BOUNDARY.test(raw)) return void 0;
+    const code = codeOnly(index === start && column ? raw.slice(0, Math.max(0, column - 1)) : raw);
+    for (let position = code.length - 1; position >= 0; position--) {
+      const char = code[position];
+      if (char === "}") {
+        depth += 1;
+      } else if (char === "{") {
+        if (depth > 0) {
+          depth -= 1;
+          continue;
+        }
+        const header = headerOf(lines, index, code.slice(0, position));
+        if (CLASS_BODY.test(header)) return void 0;
+        if (CONTROL_BLOCK.test(header)) continue;
+        const name = nameIn(header);
+        if (name) return name;
+      }
+    }
+  }
+  return void 0;
+}
+
+// src/source.ts
+var MAX_FILE_BYTES = 2 * 1024 * 1024;
+var MAX_CACHED_FILES = 50;
+var MAPPING_URL = /\/\/[#@]\s*sourceMappingURL=(\S+)\s*$/;
+var cache = /* @__PURE__ */ new Map();
+async function enrichFrames(frames, cwd = process.cwd(), options = {}) {
+  const result = [];
+  let withContext = 0;
+  for (const frame of frames) {
+    try {
+      const { frame: located, lines, original } = await mapFrame(frame, options.mapLocator);
+      const named = options.inferFunctionNames && original && !located.fn && lines && located.line ? withInferredName(located, lines) : located;
+      const mapped = named.inApp && isLibraryPath(named.file) ? { ...named, inApp: false } : named;
+      let next = mapped;
+      if (mapped.inApp && lines && mapped.line && withContext < LIMITS.contextFrames) {
+        const context = contextFor(lines, mapped.line);
+        if (context) {
+          next = { ...mapped, context };
+          withContext++;
+        }
+      }
+      result.push({ ...next, file: relativize(next.file, cwd) });
+    } catch {
+      result.push({ ...frame, file: relativize(frame.file, cwd) });
+    }
+  }
+  return result;
+}
+async function enrichException(exception, cwd = process.cwd(), options = {}) {
+  const frames = await enrichFrames(exception.frames, cwd, options);
+  if (!exception.cause) return { ...exception, frames };
+  return { ...exception, frames, cause: await enrichException(exception.cause, cwd, options) };
+}
+function withInferredName(frame, lines) {
+  const fn = enclosingFunctionName(lines, frame.line ?? 0, frame.col);
+  return fn ? { ...frame, fn } : frame;
+}
+function isLibraryPath(file) {
+  return file.includes("/node_modules/") || file.includes("\\node_modules\\");
+}
+function relativize(file, cwd) {
+  if (!(0, import_node_path.isAbsolute)(file)) return file;
+  const path = (0, import_node_path.relative)(cwd, file);
+  return path.startsWith("..") || (0, import_node_path.isAbsolute)(path) ? file : path.split(import_node_path.sep).join("/");
+}
+async function mapFrame(frame, locator) {
+  if (!frame.line || !(0, import_node_path.isAbsolute)(frame.file)) return { frame, lines: null, original: false };
+  const file = await loadFile(frame.file, locator);
+  if (!file) return { frame, lines: null, original: false };
+  if (!file.map) return { frame, lines: file.lines, original: false };
+  const entry = file.map.map.findEntry(frame.line - 1, (frame.col ?? 1) - 1);
+  if (typeof entry.originalSource !== "string" || typeof entry.originalLine !== "number") return { frame, lines: file.lines, original: false };
+  const originalPath = resolveSource(file.map, entry.originalSource);
+  const mapped = { ...frame, file: originalPath, line: entry.originalLine + 1, col: (entry.originalColumn ?? 0) + 1 };
+  const lines = embeddedLines(file.map, file.map.sources.indexOf(entry.originalSource));
+  if (lines) return { frame: mapped, lines, original: true };
+  const original = await loadFile(originalPath);
+  return { frame: mapped, lines: original?.lines ?? null, original: true };
+}
+function embeddedLines(map, index) {
+  if (index < 0) return null;
+  const cached = map.lines.get(index);
+  if (cached) return cached;
+  const content = map.contents[index];
+  if (typeof content !== "string") return null;
+  const lines = content.split(/\r?\n/);
+  map.lines.set(index, lines);
+  return lines;
+}
+function contextFor(lines, line) {
+  const index = line - 1;
+  if (index < 0 || index >= lines.length) return void 0;
+  const clip = (text) => text.length > LIMITS.contextLineLength ? `${text.slice(0, LIMITS.contextLineLength)}\u2026` : text;
+  return {
+    pre: lines.slice(Math.max(0, index - LIMITS.contextLines), index).map(clip),
+    line: clip(lines[index] ?? ""),
+    post: lines.slice(index + 1, index + 1 + LIMITS.contextLines).map(clip)
+  };
+}
+function resolveSource(map, source) {
+  if (source.startsWith("file://")) {
+    try {
+      return (0, import_node_url.fileURLToPath)(source);
+    } catch {
+      return source;
+    }
+  }
+  return (0, import_node_path.isAbsolute)(source) ? source : (0, import_node_path.resolve)(map.baseDir, source);
+}
+function loadFile(path, locator) {
+  const key = locator ? `${path}\0located` : path;
+  const cached = cache.get(key);
+  if (cached) {
+    cache.delete(key);
+    cache.set(key, cached);
+    return cached;
+  }
+  const pending = readSource(path, locator).catch(() => null);
+  cache.set(key, pending);
+  if (cache.size > MAX_CACHED_FILES) {
+    const oldest = cache.keys().next().value;
+    if (oldest !== void 0) cache.delete(oldest);
+  }
+  return pending;
+}
+async function readSource(path, locator) {
+  const text = await readText(path);
+  if (text === null) return null;
+  const lines = text.split(/\r?\n/);
+  return { lines, map: await loadMap(path, lines, locator) };
+}
+async function readText(path) {
+  try {
+    const info = await (0, import_promises.stat)(path);
+    if (!info.isFile() || info.size > MAX_FILE_BYTES) return null;
+    return await (0, import_promises.readFile)(path, "utf8");
+  } catch {
+    return null;
+  }
+}
+async function loadMap(path, lines, locator) {
+  let url;
+  for (let index = lines.length - 1; index >= 0 && index >= lines.length - 5; index--) {
+    const match = MAPPING_URL.exec(lines[index] ?? "");
+    if (match) {
+      url = match[1];
+      break;
+    }
+  }
+  let raw;
+  let mapDir;
+  const located = url ? null : locator ? locator(path) : `${path}.map`;
+  if (located) {
+    raw = await readText(located);
+    mapDir = (0, import_node_path.dirname)(located);
+  } else if (!url) {
+    return null;
+  } else if (url.startsWith("data:")) {
+    const comma = url.indexOf(",");
+    const encoded = url.slice(comma + 1);
+    raw = url.slice(0, comma).endsWith(";base64") ? Buffer.from(encoded, "base64").toString("utf8") : decodeURIComponent(encoded);
+    mapDir = (0, import_node_path.dirname)(path);
+  } else {
+    const mapPath = url.startsWith("file://") ? (0, import_node_url.fileURLToPath)(url) : (0, import_node_path.resolve)((0, import_node_path.dirname)(path), decodeURIComponent(url));
+    raw = await readText(mapPath);
+    mapDir = (0, import_node_path.dirname)(mapPath);
+  }
+  if (!raw) return null;
+  try {
+    const payload = JSON.parse(raw);
+    return {
+      map: new import_node_module.SourceMap(payload),
+      baseDir: (0, import_node_path.resolve)(mapDir, payload.sourceRoot ?? ""),
+      sources: payload.sources ?? [],
+      contents: payload.sourcesContent ?? [],
+      lines: /* @__PURE__ */ new Map()
+    };
+  } catch {
+    return null;
+  }
+}
+
+// src/stack.ts
+var import_node_url2 = require("url");
+var WITH_FUNCTION = /^at (?:async )?(.+?) \((.+)\)$/;
+var LOCATION = /^(.+):(\d+):(\d+)$/;
+var MAX_FRAME_LINE = 1e3;
+function parseStack(stack) {
+  if (!stack) return [];
+  const frames = [];
+  for (const raw of stack.split("\n")) {
+    const line = raw.trim();
+    if (line.length > MAX_FRAME_LINE || !line.startsWith("at ")) continue;
+    const withFunction = WITH_FUNCTION.exec(line);
+    const fn = withFunction?.[1];
+    const location = withFunction ? withFunction[2] ?? "" : line.replace(/^at (?:async )?/, "");
+    const parsed = LOCATION.exec(location);
+    if (parsed) {
+      const file = toPath(parsed[1] ?? "");
+      frames.push({ ...fn ? { fn } : {}, file, line: Number(parsed[2]), col: Number(parsed[3]), inApp: isInApp(file) });
+    } else {
+      frames.push({ ...fn ? { fn } : {}, file: location, inApp: false });
+    }
+    if (frames.length >= LIMITS.frames) break;
+  }
+  return frames;
+}
+function isInApp(file) {
+  if (file.includes("/node_modules/") || file.includes("\\node_modules\\")) return false;
+  if (file.startsWith("node:") || file.startsWith("internal/")) return false;
+  return file.startsWith("/") || /^[A-Za-z]:[\\/]/.test(file);
+}
+function exceptionInfo(error, depth = 0) {
+  if (error instanceof Error) {
+    const info = {
+      type: errorType(error),
+      message: truncate(error.message ?? "", LIMITS.messageLength),
+      frames: parseStack(error.stack)
+    };
+    const cause = error.cause;
+    if (cause !== void 0 && cause !== null && depth < LIMITS.causeDepth) info.cause = exceptionInfo(cause, depth + 1);
+    return info;
+  }
+  if (typeof error === "object" && error !== null) {
+    const record = error;
+    const message = typeof record.message === "string" ? record.message : safeStringify(error);
+    return { type: typeof record.name === "string" ? record.name : "Object", message: truncate(message, LIMITS.messageLength), frames: [] };
+  }
+  return { type: "Error", message: truncate(String(error), LIMITS.messageLength), frames: [] };
+}
+function toPath(location) {
+  if (!location.startsWith("file://")) return location;
+  try {
+    return (0, import_node_url2.fileURLToPath)(location);
+  } catch {
+    return location;
+  }
+}
+function errorType(error) {
+  if (error.name && error.name !== "Error") return error.name;
+  const constructorName = error.constructor?.name;
+  return constructorName && constructorName !== "Object" ? constructorName : "Error";
+}
+function safeStringify(value) {
+  try {
+    return JSON.stringify(value) ?? String(value);
+  } catch {
+    return String(value);
+  }
+}
+
+// src/transport.ts
+var import_node_util2 = require("util");
+var import_node_zlib = require("zlib");
+
+// src/util.ts
+var import_node_perf_hooks2 = require("perf_hooks");
+function describeError(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function elapsedSince(startedAt) {
+  return Math.round(import_node_perf_hooks2.performance.now() - startedAt);
+}
+
+// src/transport.ts
+var gzipAsync = (0, import_node_util2.promisify)(import_node_zlib.gzip);
+var MAX_BATCH_BYTES = 9e5;
+var GZIP_THRESHOLD_BYTES = 8192;
+var MAX_BACKOFF_MS = 3e4;
+var MAX_RETRY_AFTER_MS = 864e5;
+var UNAUTHORIZED_PAUSE_MS = 10 * 6e4;
+var Transport = class {
+  constructor(config) {
+    this.config = config;
+    this.maxQueue = config.maxQueue ?? 1e3;
+    this.batchSize = Math.min(config.batchSize ?? 100, LIMITS.batchEvents);
+    this.timer = setInterval(() => {
+      void this.send();
+    }, config.flushIntervalMs ?? 2e3);
+    this.timer.unref();
+  }
+  config;
+  queue = [];
+  droppedCount = 0;
+  inFlight = null;
+  nextAttemptAt = 0;
+  backoffMs = 0;
+  unauthorizedUntil = 0;
+  stopped = false;
+  warned = /* @__PURE__ */ new Set();
+  timer;
+  maxQueue;
+  batchSize;
+  get pending() {
+    return this.queue.length;
+  }
+  get dropped() {
+    return this.droppedCount;
+  }
+  enqueue(event) {
+    if (this.stopped) return;
+    if (this.queue.length >= this.maxQueue) {
+      this.droppedCount += 1;
+      this.warn("queue_full", "fila do Radar cheia; eventos est\xE3o sendo descartados", false);
+      return;
+    }
+    this.queue.push(event);
+    if (this.queue.length >= this.batchSize) void this.send();
+  }
+  send() {
+    if (this.inFlight) return this.inFlight;
+    if (this.stopped || this.queue.length === 0 || Date.now() < this.nextAttemptAt) return Promise.resolve(false);
+    const attempt = this.sendBatch().catch((error) => {
+      this.warn("internal", `envio ao Radar falhou: ${describeError(error)}`, false);
+      return false;
+    });
+    this.inFlight = attempt.finally(() => {
+      this.inFlight = null;
+    });
+    return this.inFlight;
+  }
+  async flush(timeoutMs) {
+    const deadline = Date.now() + timeoutMs;
+    while (this.queue.length > 0 || this.inFlight) {
+      const remaining = deadline - Date.now();
+      if (remaining <= 0) return;
+      const progressed = await withTimeout(this.send(), remaining);
+      if (progressed !== true && !this.inFlight) return;
+    }
+  }
+  stop() {
+    this.stopped = true;
+    clearInterval(this.timer);
+  }
+  async sendBatch() {
+    const items = this.queue.splice(0, this.batchSize);
+    const resolved = await Promise.all(items.map((item) => Promise.resolve().then(() => typeof item === "function" ? item() : item).then((event) => event, () => null)));
+    const events = [];
+    const leftovers = [];
+    let bytes = 0;
+    for (const event of resolved) {
+      if (!event) {
+        this.droppedCount += 1;
+        continue;
+      }
+      const size = Buffer.byteLength(JSON.stringify(event));
+      if (events.length > 0 && bytes + size > MAX_BATCH_BYTES) {
+        leftovers.push(event);
+        continue;
+      }
+      events.push(event);
+      bytes += size;
+    }
+    if (leftovers.length > 0) this.queue.unshift(...leftovers);
+    if (events.length === 0) return true;
+    const dropped = this.droppedCount;
+    const batch = {
+      v: 1,
+      sdk: this.config.sdk,
+      environment: this.config.environment,
+      ...this.config.release ? { release: this.config.release } : {},
+      ...dropped > 0 ? { dropped } : {},
+      events
+    };
+    const outcome = await this.post(batch);
+    switch (outcome.kind) {
+      case "ok":
+        this.droppedCount -= dropped;
+        this.backoffMs = 0;
+        this.nextAttemptAt = 0;
+        return true;
+      case "retry":
+        this.requeue(events);
+        this.backoffMs = Math.min(this.backoffMs > 0 ? this.backoffMs * 2 : 1e3, MAX_BACKOFF_MS);
+        this.nextAttemptAt = Date.now() + Math.max(this.backoffMs, outcome.retryAfterMs ?? 0);
+        return false;
+      case "unauthorized":
+        this.droppedCount += events.length;
+        this.pauseUnauthorized(outcome.status);
+        return false;
+      case "rejected":
+        this.droppedCount += events.length;
+        this.warn(`rejected_${outcome.status}`, `lote recusado pelo Radar (${outcome.status}); eventos descartados`, true);
+        return true;
+    }
+  }
+  async checkIn(slug, payload) {
+    if (this.stopped || !this.config.checkInBaseUrl || Date.now() < this.unauthorizedUntil) return;
+    let response;
+    try {
+      response = await fetch(this.config.checkInBaseUrl + encodeURIComponent(slug), {
+        method: "POST",
+        headers: this.headers(),
+        body: JSON.stringify(payload),
+        redirect: "error",
+        signal: AbortSignal.timeout(this.config.requestTimeoutMs ?? 5e3)
+      });
+    } catch (error) {
+      this.warn("checkin_network", `check-in no Radar falhou: ${describeError(error)}`, false);
+      return;
+    }
+    await response.arrayBuffer().catch(() => void 0);
+    if (response.ok) return;
+    if (response.status === 401 || response.status === 403) {
+      this.pauseUnauthorized(response.status);
+      return;
+    }
+    if (response.status === 404) {
+      this.warn(`checkin_unknown_${slug}`, `tarefa agendada "${slug}" n\xE3o existe no projeto da chave; crie o monitor com esse slug no Radar`, true);
+      return;
+    }
+    this.warn(`checkin_rejected_${response.status}`, `check-in recusado pelo Radar (${response.status})`, false);
+  }
+  pauseUnauthorized(status) {
+    this.droppedCount += this.queue.length;
+    this.queue = [];
+    this.unauthorizedUntil = Date.now() + UNAUTHORIZED_PAUSE_MS;
+    this.nextAttemptAt = Math.max(this.nextAttemptAt, this.unauthorizedUntil);
+    this.warn("unauthorized", `chave do Radar recusada (${status}); envios pausados por 10 minutos`, true);
+  }
+  headers() {
+    return {
+      "content-type": "application/json",
+      authorization: `Bearer ${this.config.key}`,
+      "user-agent": `${this.config.sdk.name}/${this.config.sdk.version}`
+    };
+  }
+  requeue(events) {
+    this.queue.unshift(...events);
+    const overflow = this.queue.length - this.maxQueue;
+    if (overflow > 0) {
+      this.queue.splice(this.maxQueue, overflow);
+      this.droppedCount += overflow;
+    }
+  }
+  async post(batch) {
+    const json = JSON.stringify(batch);
+    const compress = Buffer.byteLength(json) > GZIP_THRESHOLD_BYTES;
+    const headers = this.headers();
+    if (compress) headers["content-encoding"] = "gzip";
+    let response;
+    try {
+      response = await fetch(this.config.url, {
+        method: "POST",
+        headers,
+        body: compress ? await gzipAsync(json) : json,
+        redirect: "error",
+        signal: AbortSignal.timeout(this.config.requestTimeoutMs ?? 5e3)
+      });
+    } catch (error) {
+      this.warn("network", `Radar indispon\xEDvel: ${describeError(error)}`, false);
+      return { kind: "retry" };
+    }
+    await response.arrayBuffer().catch(() => void 0);
+    if (response.ok) return { kind: "ok" };
+    if (response.status === 401 || response.status === 403) return { kind: "unauthorized", status: response.status };
+    if (response.status === 429) return { kind: "retry", retryAfterMs: retryAfterMs(response.headers.get("retry-after")) };
+    if (response.status >= 500) return { kind: "retry" };
+    return { kind: "rejected", status: response.status };
+  }
+  warn(key, message, always) {
+    if (this.warned.has(key)) return;
+    this.warned.add(key);
+    this.config.onWarning?.(message, always);
+  }
+};
+function retryAfterMs(header) {
+  if (!header) return void 0;
+  const seconds = Number(header);
+  if (Number.isFinite(seconds)) return Math.min(Math.max(0, seconds * 1e3), MAX_RETRY_AFTER_MS);
+  const date = Date.parse(header);
+  return Number.isNaN(date) ? void 0 : Math.min(Math.max(0, date - Date.now()), MAX_RETRY_AFTER_MS);
+}
+function withTimeout(promise, ms) {
+  return new Promise((resolve2) => {
+    const timer = setTimeout(() => resolve2(void 0), ms);
+    timer.unref();
+    promise.then(
+      (value) => {
+        clearTimeout(timer);
+        resolve2(value);
+      },
+      () => {
+        clearTimeout(timer);
+        resolve2(void 0);
+      }
+    );
+  });
+}
+
+// src/version.ts
+var SDK_NAME = "@oconde/radar";
+var SDK_VERSION = true ? "0.2.0" : "0.0.0-dev";
+
+// src/client.ts
+var MAX_CHECK_IN_DURATION_MS = 7 * 864e5;
+var MAX_CHECK_IN_ENVIRONMENT = 64;
+var MAX_CHECK_IN_RELEASE = 128;
+var RadarClient = class {
+  options = resolveOptions({}, {});
+  transport = null;
+  initialized = false;
+  closed = false;
+  captured = /* @__PURE__ */ new WeakSet();
+  get isEnabled() {
+    return this.transport !== null && !this.closed;
+  }
+  get settings() {
+    return this.options;
+  }
+  init(options = {}) {
+    try {
+      if (this.initialized) {
+        this.debugWarn("radar.init chamado mais de uma vez; mantida a primeira configura\xE7\xE3o");
+        return;
+      }
+      this.initialized = true;
+      this.options = resolveOptions(options);
+      setFingerprintSecret(this.options.key);
+      if (this.options.enabled && this.options.key) {
+        this.transport = new Transport({
+          url: this.options.endpoint + INGEST_PATH,
+          key: this.options.key,
+          sdk: { name: SDK_NAME, version: SDK_VERSION },
+          environment: this.options.environment,
+          ...this.options.release ? { release: this.options.release } : {},
+          checkInBaseUrl: this.options.endpoint + CHECKIN_PATH,
+          onWarning: (message, always) => always ? this.writeWarning(message) : this.debugWarn(message)
+        });
+      }
+      if (this.options.captureUnhandled && (this.transport || this.options.console)) installProcessHandlers(this);
+    } catch (error) {
+      this.debugWarn(`radar.init falhou: ${describeError(error)}`);
+    }
+  }
+  debug(message, data) {
+    this.safely(() => this.emitLog("debug", message, data));
+  }
+  info(message, data) {
+    this.safely(() => this.emitLog("info", message, data));
+  }
+  warn(message, data) {
+    this.safely(() => this.emitLog("warn", message, data));
+  }
+  error(message, data) {
+    this.safely(() => this.emitLog("error", message, data));
+  }
+  logRequest(title, data, options = {}) {
+    this.safely(() => {
+      const context = currentContext();
+      const mode = options.redact ?? this.options.redact;
+      const request = context?.req ? requestInfo(context.req, mode, { route: context.route }, this.options.requestDetail) : void 0;
+      this.emitLog(options.level ?? "info", title, data, { request, mode });
+    });
+  }
+  captureError(error, data) {
+    this.safely(() => this.emitError(error, data, "error", true));
+  }
+  captureUnhandled(error, level) {
+    this.safely(() => this.emitError(error, void 0, level, false));
+  }
+  setUser(user) {
+    this.safely(() => {
+      const context = currentContext();
+      if (!context) return;
+      context.user = {
+        ...user.id !== void 0 && user.id !== null ? { id: truncate(String(user.id), 200) } : {},
+        ...user.email ? { email: truncate(String(user.email), 200) } : {},
+        ...user.name ? { name: truncate(String(user.name), 200) } : {}
+      };
+    });
+  }
+  async track(name, fn, data) {
+    const execute = async () => {
+      const started = import_node_perf_hooks3.performance.now();
+      try {
+        const result = await fn();
+        this.info(name, { ...data, durationMs: elapsedSince(started), ok: true });
+        return result;
+      } catch (error) {
+        this.error(name, { ...data, durationMs: elapsedSince(started), ok: false });
+        this.captureError(error, data);
+        throw error;
+      }
+    };
+    if (currentContext()) return execute();
+    return runWithContext({ requestId: (0, import_node_crypto3.randomUUID)(), startedAt: import_node_perf_hooks3.performance.now() }, execute);
+  }
+  withContext(fn, options = {}) {
+    return runWithContext({ requestId: requestIdFrom(options.requestId), startedAt: import_node_perf_hooks3.performance.now() }, fn);
+  }
+  async checkIn(slug, status, options = {}) {
+    try {
+      if (!this.transport || this.closed) return;
+      if (typeof slug !== "string" || !CHECKIN_SLUG.test(slug)) {
+        this.debugWarn(`slug de tarefa agendada inv\xE1lido: ${String(slug).slice(0, 80)}`);
+        return;
+      }
+      if (!CHECKIN_STATUSES.includes(status)) return;
+      const checkInId = typeof options.checkInId === "string" && options.checkInId ? options.checkInId.slice(0, LIMITS.checkInIdLength) : void 0;
+      const durationMs = typeof options.durationMs === "number" && Number.isFinite(options.durationMs) && options.durationMs >= 0 ? Math.min(Math.round(options.durationMs), MAX_CHECK_IN_DURATION_MS) : void 0;
+      const environment = this.options.environment.slice(0, MAX_CHECK_IN_ENVIRONMENT) || "production";
+      const release = this.options.release?.slice(0, MAX_CHECK_IN_RELEASE);
+      const payload = {
+        status,
+        ...checkInId ? { checkInId } : {},
+        ...durationMs !== void 0 ? { durationMs } : {},
+        environment,
+        ...release ? { release } : {}
+      };
+      await this.transport.checkIn(slug, payload);
+    } catch (error) {
+      this.debugWarn(`check-in falhou: ${describeError(error)}`);
+    }
+  }
+  async cron(slug, fn) {
+    const checkInId = (0, import_node_crypto3.randomUUID)();
+    const started = import_node_perf_hooks3.performance.now();
+    const execute = async () => {
+      await this.checkIn(slug, "in_progress", { checkInId });
+      try {
+        const result = await fn();
+        await this.checkIn(slug, "ok", { checkInId, durationMs: elapsedSince(started) });
+        return result;
+      } catch (error) {
+        this.captureError(error, { cron: slug });
+        await this.checkIn(slug, "error", { checkInId, durationMs: elapsedSince(started) });
+        throw error;
+      }
+    };
+    if (currentContext()) return execute();
+    return this.withContext(execute);
+  }
+  middleware() {
+    return createMiddleware(this);
+  }
+  shouldLogRequest(req) {
+    return this.options.logRequests && !this.options.ignorePaths.includes(requestPath(req));
+  }
+  logHttpRequest(context, status) {
+    this.safely(() => {
+      const req = context.req;
+      if (!req) return;
+      const level = status >= 500 ? "error" : status >= 400 ? "warn" : "info";
+      const route = requestRoute(req, context.route);
+      runWithContext(
+        context,
+        () => this.emitLog(level, "http.request", {
+          method: (req.method ?? "GET").toUpperCase(),
+          ...route ? { route } : {},
+          ...this.options.requestDetail === "full" ? { path: redactPath(requestPath(req), pathParams(req, requestPath(req)), this.options.redact) } : {},
+          status,
+          durationMs: elapsedSince(context.startedAt)
+        })
+      );
+    });
+  }
+  async flush(timeoutMs = 2e3) {
+    try {
+      await this.transport?.flush(timeoutMs);
+    } catch (error) {
+      this.debugWarn(`flush falhou: ${describeError(error)}`);
+    }
+  }
+  async close(timeoutMs = 2e3) {
+    if (this.closed) return;
+    await this.flush(timeoutMs);
+    this.closed = true;
+    this.transport?.stop();
+  }
+  emitLog(level, message, data, extras = {}) {
+    if (this.closed || !levelEnabled(level, this.options.minLevel)) return;
+    const context = currentContext();
+    const mode = extras.mode ?? this.options.redact;
+    const event = {
+      type: "log",
+      ts: Date.now(),
+      level,
+      message: truncate(String(message), LIMITS.messageLength),
+      ...context ? { requestId: context.requestId } : {},
+      ...data !== void 0 ? { attrs: prepareAttrs(data, mode) } : {},
+      ...extras.request ? { request: extras.request } : {},
+      ...context?.user ? { user: context.user } : {}
+    };
+    this.print(event);
+    this.transport?.enqueue(event);
+  }
+  captureException(exception, options = {}) {
+    this.safely(() => this.emitException(exception, options));
+  }
+  emitError(error, data, level, handled) {
+    if (this.closed) return;
+    if (typeof error === "object" && error !== null) {
+      if (this.captured.has(error)) return;
+      this.captured.add(error);
+    }
+    this.emitException(exceptionInfo(error), { level, handled, ...data !== void 0 ? { attrs: data } : {} }, error instanceof Error ? error.stack : void 0);
+  }
+  emitException(exception, options, stack) {
+    if (this.closed) return;
+    const context = currentContext();
+    const mode = this.options.redact;
+    const request = options.request === null ? void 0 : options.request ?? (context?.req ? requestInfo(context.req, mode, { route: context.route }, this.options.requestDetail) : void 0);
+    const runtime = options.runtime === void 0 ? runtimeInfo() : options.runtime;
+    const event = {
+      type: "error",
+      ts: Date.now(),
+      level: options.level ?? "error",
+      handled: options.handled ?? true,
+      exception,
+      ...context ? { requestId: context.requestId } : {},
+      ...request ? { request } : {},
+      ...context?.user ? { user: context.user } : {},
+      ...runtime ? { runtime } : {},
+      ...options.attrs !== void 0 ? { attrs: prepareAttrs(options.attrs, mode) } : {}
+    };
+    this.print(event, stack);
+    if (!this.transport) return;
+    this.transport.enqueue(
+      () => enrichException(event.exception, process.cwd(), options.enrich).then(
+        (enriched) => ({ ...event, exception: enriched }),
+        () => event
+      )
+    );
+  }
+  print(event, stack) {
+    if (!this.options.console) return;
+    try {
+      const requestId = event.requestId ? { requestId: event.requestId } : {};
+      if (event.type === "log") {
+        const line2 = { ...event.attrs, ts: new Date(event.ts).toISOString(), level: event.level, message: event.message, ...requestId };
+        (event.level === "error" ? process.stderr : process.stdout).write(`${JSON.stringify(line2)}
+`);
+        return;
+      }
+      const line = {
+        ...event.attrs,
+        ts: new Date(event.ts).toISOString(),
+        level: event.level,
+        message: `${event.exception.type}: ${event.exception.message}`,
+        ...requestId,
+        ...stack ? { stack } : {}
+      };
+      process.stderr.write(`${JSON.stringify(line)}
+`);
+    } catch {
+      return;
+    }
+  }
+  safely(action) {
+    try {
+      action();
+    } catch (error) {
+      this.debugWarn(`falha interna do Radar: ${describeError(error)}`);
+    }
+  }
+  debugWarn(message) {
+    if (this.options.debug) this.writeWarning(message);
+  }
+  writeWarning(message) {
+    try {
+      process.stderr.write(`[radar] ${message}
+`);
+    } catch {
+      return;
+    }
+  }
+};
+function runtimeInfo() {
+  return {
+    name: "node",
+    version: process.versions.node,
+    host: (0, import_node_os.hostname)(),
+    pid: process.pid,
+    memoryMb: Math.round(process.memoryUsage.rss() / 1048576),
+    uptimeS: Math.round(process.uptime())
+  };
+}
+
+// src/radar.ts
+var state = globalState();
+var radar = state.client ?? (state.client = new RadarClient());
+
+// src/nest/index.ts
+var RADAR_OPTIONS = /* @__PURE__ */ Symbol.for("@oconde/radar/options");
+function shouldCapture(error) {
+  return !(error instanceof import_common.HttpException) || error.getStatus() >= 500;
+}
+var RadarInterceptor = class {
+  intercept(context, next) {
+    if (context.getType() === "http") {
+      const request = context.switchToHttp().getRequest();
+      const store = currentContext();
+      const route = request?.route?.path;
+      if (store && typeof route === "string") store.route = route;
+    }
+    return next.handle().pipe(
+      (0, import_rxjs.catchError)((error) => {
+        if (shouldCapture(error)) radar.captureError(error);
+        return (0, import_rxjs.throwError)(() => error);
+      })
+    );
+  }
+};
+RadarInterceptor = __decorateClass([
+  (0, import_common.Injectable)()
+], RadarInterceptor);
+var RadarService = class {
+  debug(message, data) {
+    radar.debug(message, data);
+  }
+  info(message, data) {
+    radar.info(message, data);
+  }
+  warn(message, data) {
+    radar.warn(message, data);
+  }
+  error(message, data) {
+    radar.error(message, data);
+  }
+  logRequest(title, data, options) {
+    radar.logRequest(title, data, options);
+  }
+  captureError(error, data) {
+    radar.captureError(error, data);
+  }
+  setUser(user) {
+    radar.setUser(user);
+  }
+  track(name, fn, data) {
+    return radar.track(name, fn, data);
+  }
+  flush(timeoutMs) {
+    return radar.flush(timeoutMs);
+  }
+};
+RadarService = __decorateClass([
+  (0, import_common.Injectable)()
+], RadarService);
+var RadarExceptionFilter = class extends import_core.BaseExceptionFilter {
+  catch(exception, host) {
+    if (shouldCapture(exception)) radar.captureError(exception);
+    super.catch(exception, host);
+  }
+};
+RadarExceptionFilter = __decorateClass([
+  (0, import_common.Catch)()
+], RadarExceptionFilter);
+function nestMajorVersion() {
+  try {
+    const load = (0, import_node_module2.createRequire)(importMetaUrl);
+    const { version } = load("@nestjs/core/package.json");
+    return Number.parseInt(version, 10);
+  } catch {
+    return 11;
+  }
+}
+var ALL_ROUTES = { path: nestMajorVersion() >= 11 ? "{*path}" : "*", method: import_common.RequestMethod.ALL };
+var RadarModule = class {
+  constructor(options) {
+    this.options = options;
+  }
+  options;
+  static forRoot(options = {}) {
+    return RadarModule.create(
+      [
+        {
+          provide: RADAR_OPTIONS,
+          useFactory: () => {
+            radar.init(options);
+            return options;
+          }
+        }
+      ],
+      []
+    );
+  }
+  static forRootAsync(options) {
+    const factory = options.useFactory;
+    return RadarModule.create(
+      [
+        {
+          provide: RADAR_OPTIONS,
+          inject: options.inject ?? [],
+          useFactory: async (...args) => {
+            const resolved = await factory(...args);
+            radar.init(resolved);
+            return resolved;
+          }
+        }
+      ],
+      options.imports ?? []
+    );
+  }
+  static create(providers, imports) {
+    return {
+      module: RadarModule,
+      global: true,
+      imports,
+      providers: [...providers, RadarService, { provide: import_core.APP_INTERCEPTOR, useClass: RadarInterceptor }],
+      exports: [RadarService, RADAR_OPTIONS]
+    };
+  }
+  configure(consumer) {
+    consumer.apply(radar.middleware()).forRoutes(ALL_ROUTES);
+  }
+  async onApplicationShutdown() {
+    await radar.close();
+  }
+};
+RadarModule = __decorateClass([
+  (0, import_common.Global)(),
+  (0, import_common.Module)({}),
+  __decorateParam(0, (0, import_common.Inject)(RADAR_OPTIONS))
+], RadarModule);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  RADAR_OPTIONS,
+  RadarExceptionFilter,
+  RadarInterceptor,
+  RadarModule,
+  RadarService,
+  shouldCapture
+});
+//# sourceMappingURL=index.cjs.map