autotel-edge 3.16.13 → 3.16.15

package/dist/logger.js

@@ -1,821 +1,830 @@
-export { getExecutionLogger } from './chunk-AL7ZD64M.js';
-import { createContextKey, context, trace } from '@opentelemetry/api';
+import { t as getExecutionLogger } from "./execution-logger-CoxSsBmU.js";
+import { context, createContextKey, trace } from "@opentelemetry/api";
 
-// src/api/redact.ts
-var DEFAULT_CENSOR = "[Redacted]";
+//#region src/api/redact.ts
+/**
+* Redaction utility for structured log output
+*
+* Inspired by pino's redaction — zero-dependency, edge-compatible.
+* Supports deep paths, wildcards, and custom censor values.
+*
+* @example
+* ```typescript
+* const redactor = createRedactor({
+*   paths: ['password', 'user.email', 'headers.authorization'],
+* })
+* const safe = redactor({ password: 'secret', user: { email: 'a@b.com' } })
+* // { password: '[Redacted]', user: { email: '[Redacted]' } }
+* ```
+*/
+const DEFAULT_CENSOR = "[Redacted]";
+/**
+* Validate and parse a dot/bracket path string into segments.
+*
+* Valid: "user.email", "users[*].name", "headers.*", "[0].secret"
+* Invalid: "user..email", "user[", "foo.]bar", ""
+*/
 function parsePath(path) {
-  if (typeof path !== "string" || path.length === 0) {
-    throw new Error(
-      `redact path must be a non-empty string, got: ${JSON.stringify(path)}`
-    );
-  }
-  if (path.includes("..")) {
-    throw new Error(
-      `redact path contains empty segment: ${JSON.stringify(path)}`
-    );
-  }
-  const openBracket = path.indexOf("[");
-  const closeBracket = path.indexOf("]");
-  if (openBracket !== -1 && closeBracket === -1 || closeBracket !== -1 && openBracket === -1) {
-    throw new Error(
-      `redact path has unclosed bracket: ${JSON.stringify(path)}`
-    );
-  }
-  if (openBracket !== -1 && closeBracket < openBracket) {
-    throw new Error(
-      `redact path has bracket close before open: ${JSON.stringify(path)}`
-    );
-  }
-  if (/\[\s*\]$/.test(path)) {
-    throw new Error(
-      `redact path has unclosed bracket: ${JSON.stringify(path)}`
-    );
-  }
-  if (/\][^.[\]]/.test(path) && !/\]\[/.test(path)) {
-    const afterClose = path.match(/\]([^.[\]]+)/);
-    if (afterClose) {
-      throw new Error(
-        `redact path has invalid characters after ']': ${JSON.stringify(path)}`
-      );
-    }
-  }
-  const segments = [];
-  const rx = /[^.[\]]+|\[(\d+|\*)\]/g;
-  let match;
-  let lastIndex = 0;
-  while ((match = rx.exec(path)) !== null) {
-    segments.push(match[1] ?? match[0]);
-    lastIndex = rx.lastIndex;
-  }
-  if (lastIndex < path.length) {
-    throw new Error(
-      `redact path has unexpected trailing content: ${JSON.stringify(path)}`
-    );
-  }
-  if (segments.length === 0) {
-    throw new Error(
-      `redact path produced no segments: ${JSON.stringify(path)}`
-    );
-  }
-  return segments;
+	if (typeof path !== "string" || path.length === 0) throw new Error(`redact path must be a non-empty string, got: ${JSON.stringify(path)}`);
+	if (path.includes("..")) throw new Error(`redact path contains empty segment: ${JSON.stringify(path)}`);
+	const openBracket = path.indexOf("[");
+	const closeBracket = path.indexOf("]");
+	if (openBracket !== -1 && closeBracket === -1 || closeBracket !== -1 && openBracket === -1) throw new Error(`redact path has unclosed bracket: ${JSON.stringify(path)}`);
+	if (openBracket !== -1 && closeBracket < openBracket) throw new Error(`redact path has bracket close before open: ${JSON.stringify(path)}`);
+	if (/\[\s*\]$/.test(path)) throw new Error(`redact path has unclosed bracket: ${JSON.stringify(path)}`);
+	if (/\][^.[\]]/.test(path) && !/\]\[/.test(path)) {
+		if (path.match(/\]([^.[\]]+)/)) throw new Error(`redact path has invalid characters after ']': ${JSON.stringify(path)}`);
+	}
+	const segments = [];
+	const rx = /[^.[\]]+|\[(\d+|\*)\]/g;
+	let match;
+	let lastIndex = 0;
+	while ((match = rx.exec(path)) !== null) {
+		segments.push(match[1] ?? match[0]);
+		lastIndex = rx.lastIndex;
+	}
+	if (lastIndex < path.length) throw new Error(`redact path has unexpected trailing content: ${JSON.stringify(path)}`);
+	if (segments.length === 0) throw new Error(`redact path produced no segments: ${JSON.stringify(path)}`);
+	return segments;
 }
 function isPlainObject(value) {
-  if (value === null || typeof value !== "object") return false;
-  const proto = Object.getPrototypeOf(value);
-  return proto === Object.prototype || proto === null;
+	if (value === null || typeof value !== "object") return false;
+	const proto = Object.getPrototypeOf(value);
+	return proto === Object.prototype || proto === null;
 }
+/**
+* Deep clone plain objects and arrays only.
+* Non-plain objects (Date, Map, Set, class instances) are returned by reference.
+*/
 function deepClone(value) {
-  if (value === null || typeof value !== "object") return value;
-  if (Array.isArray(value)) return value.map((v) => deepClone(v));
-  if (!isPlainObject(value)) return value;
-  const result = {};
-  for (const key of Object.keys(value)) {
-    result[key] = deepClone(value[key]);
-  }
-  return result;
+	if (value === null || typeof value !== "object") return value;
+	if (Array.isArray(value)) return value.map((v) => deepClone(v));
+	if (!isPlainObject(value)) return value;
+	const result = {};
+	for (const key of Object.keys(value)) result[key] = deepClone(value[key]);
+	return result;
 }
+/**
+* Insert a parsed path into the tree.
+*
+* buildPathTree([['user'], ['user', 'email']]) produces:
+* { user: { redact: true, children: { email: { redact: true } } } }
+*/
 function buildPathTree(paths) {
-  const root = {};
-  for (const segments of paths) {
-    let node = root;
-    for (let i = 0; i < segments.length; i++) {
-      const seg = segments[i];
-      const isLast = i === segments.length - 1;
-      if (!node.children) node.children = {};
-      if (!node.children[seg]) node.children[seg] = {};
-      if (isLast) {
-        node.children[seg].redact = true;
-      }
-      node = node.children[seg];
-    }
-  }
-  return root;
+	const root = {};
+	for (const segments of paths) {
+		let node = root;
+		for (let i = 0; i < segments.length; i++) {
+			const seg = segments[i];
+			const isLast = i === segments.length - 1;
+			if (!node.children) node.children = {};
+			if (!node.children[seg]) node.children[seg] = {};
+			if (isLast) node.children[seg].redact = true;
+			node = node.children[seg];
+		}
+	}
+	return root;
 }
+/**
+* Walk a compiled path tree and redact matching values in `obj`.
+* Mutates `obj` in place (caller should clone before calling).
+*/
 function redactWithTree(obj, node, censor, remove, path = []) {
-  if (!node.children) return;
-  const applyCensor = (target, k, currentPath) => {
-    if (remove) {
-      delete target[k];
-    } else {
-      target[k] = typeof censor === "function" ? censor(target[k], currentPath) : censor;
-    }
-  };
-  for (const [key, childNode] of Object.entries(node.children)) {
-    if (key === "*") {
-      for (const k of Object.keys(obj)) {
-        const wildcardPath = [...path, k];
-        if (childNode.redact && !childNode.children) {
-          applyCensor(obj, k, wildcardPath);
-        } else if (childNode.redact && childNode.children) {
-          const child = obj[k];
-          if (child != null && typeof child === "object" && !Array.isArray(child)) {
-            redactWithTree(child, childNode, censor, remove, wildcardPath);
-          } else {
-            applyCensor(obj, k, wildcardPath);
-          }
-        } else if (childNode.children) {
-          const child = obj[k];
-          if (child != null && typeof child === "object") {
-            redactWithTree(child, childNode, censor, remove, wildcardPath);
-          }
-        }
-      }
-      continue;
-    }
-    if (!Object.prototype.hasOwnProperty.call(obj, key)) continue;
-    const val = obj[key];
-    const currentPath = [...path, key];
-    if (childNode.redact && !childNode.children) {
-      applyCensor(obj, key, currentPath);
-    } else if (childNode.redact && childNode.children) {
-      if (val != null && typeof val === "object") {
-        redactWithTree(val, childNode, censor, remove, currentPath);
-      }
-    } else if (childNode.children && val != null && typeof val === "object") {
-      redactWithTree(val, childNode, censor, remove, currentPath);
-    }
-  }
+	if (!node.children) return;
+	const applyCensor = (target, k, currentPath) => {
+		if (remove) delete target[k];
+		else target[k] = typeof censor === "function" ? censor(target[k], currentPath) : censor;
+	};
+	for (const [key, childNode] of Object.entries(node.children)) {
+		if (key === "*") {
+			for (const k of Object.keys(obj)) {
+				const wildcardPath = [...path, k];
+				if (childNode.redact && !childNode.children) applyCensor(obj, k, wildcardPath);
+				else if (childNode.redact && childNode.children) {
+					const child = obj[k];
+					if (child != null && typeof child === "object" && !Array.isArray(child)) redactWithTree(child, childNode, censor, remove, wildcardPath);
+					else applyCensor(obj, k, wildcardPath);
+				} else if (childNode.children) {
+					const child = obj[k];
+					if (child != null && typeof child === "object") redactWithTree(child, childNode, censor, remove, wildcardPath);
+				}
+			}
+			continue;
+		}
+		if (!Object.prototype.hasOwnProperty.call(obj, key)) continue;
+		const val = obj[key];
+		const currentPath = [...path, key];
+		if (childNode.redact && !childNode.children) applyCensor(obj, key, currentPath);
+		else if (childNode.redact && childNode.children) {
+			if (val != null && typeof val === "object") redactWithTree(val, childNode, censor, remove, currentPath);
+		} else if (childNode.children && val != null && typeof val === "object") redactWithTree(val, childNode, censor, remove, currentPath);
+	}
 }
-var SENSITIVE_KEY_PATHS = [
-  "password",
-  "passwd",
-  "pwd",
-  "secret",
-  "token",
-  "apiKey",
-  "api_key",
-  "auth",
-  "credential",
-  "privateKey",
-  "private_key",
-  "authorization"
+/**
+* Paths that match the main autotel package's `sensitiveKey` pattern:
+* `/^(password|passwd|pwd|secret|token|api[_-]?key|auth|credential|private[_-]?key|authorization)$/i`
+*
+* Copied here so the edge logger stays zero-dependency.
+*/
+const SENSITIVE_KEY_PATHS = [
+	"password",
+	"passwd",
+	"pwd",
+	"secret",
+	"token",
+	"apiKey",
+	"api_key",
+	"auth",
+	"credential",
+	"privateKey",
+	"private_key",
+	"authorization"
 ];
-var SENSITIVE_HEADER_PATHS = [
-  "req.headers.authorization",
-  "req.headers.cookie",
-  "headers.authorization",
-  "headers.cookie",
-  "request.headers.authorization",
-  "request.headers.cookie"
+/**
+* Common request header paths that often carry secrets.
+*/
+const SENSITIVE_HEADER_PATHS = [
+	"req.headers.authorization",
+	"req.headers.cookie",
+	"headers.authorization",
+	"headers.cookie",
+	"request.headers.authorization",
+	"request.headers.cookie"
 ];
-var REDACT_PRESETS = {
-  /**
-   * Default: covers the same sensitive-key names as the main autotel package's
-   * `sensitiveKey` pattern, plus common request header paths.
-   *
-   * Redacted keys: password, passwd, pwd, secret, token, apiKey, auth,
-   *                credential, privateKey, authorization
-   * Redacted headers: req.headers.authorization, req.headers.cookie, etc.
-   */
-  default: {
-    paths: [...SENSITIVE_KEY_PATHS, ...SENSITIVE_HEADER_PATHS]
-  },
-  /**
-   * Strict: everything in default, plus nested paths for bearer tokens,
-   * JWT fields, and API key fields at common depths.
-   */
-  strict: {
-    paths: [
-      ...SENSITIVE_KEY_PATHS,
-      ...SENSITIVE_HEADER_PATHS,
-      // Common nested auth shapes
-      "bearer",
-      "jwt",
-      "apiSecret",
-      "api_secret",
-      "accessToken",
-      "access_token",
-      "refreshToken",
-      "refresh_token",
-      "clientSecret",
-      "client_secret"
-    ]
-  },
-  /**
-   * PCI-DSS: credit card and payment-related fields.
-   */
-  "pci-dss": {
-    paths: [
-      "card",
-      "cardNumber",
-      "card_number",
-      "ccn",
-      "pan",
-      "cvv",
-      "cvc",
-      "expirationDate",
-      "expiration_date",
-      "exp",
-      "payment.card",
-      "payment.cardNumber",
-      "payment.cvv"
-    ]
-  }
+/**
+* Built-in redactor presets.
+*
+* - `default` — sensitive keys + request headers (passwords, tokens, secrets, auth headers)
+* - `strict` — default + bearer/jwt/api-key patterns nested at any depth
+* - `pci-dss` — credit card and payment-related fields
+*/
+const REDACT_PRESETS = {
+	/**
+	* Default: covers the same sensitive-key names as the main autotel package's
+	* `sensitiveKey` pattern, plus common request header paths.
+	*
+	* Redacted keys: password, passwd, pwd, secret, token, apiKey, auth,
+	*                credential, privateKey, authorization
+	* Redacted headers: req.headers.authorization, req.headers.cookie, etc.
+	*/
+	default: { paths: [...SENSITIVE_KEY_PATHS, ...SENSITIVE_HEADER_PATHS] },
+	/**
+	* Strict: everything in default, plus nested paths for bearer tokens,
+	* JWT fields, and API key fields at common depths.
+	*/
+	strict: { paths: [
+		...SENSITIVE_KEY_PATHS,
+		...SENSITIVE_HEADER_PATHS,
+		"bearer",
+		"jwt",
+		"apiSecret",
+		"api_secret",
+		"accessToken",
+		"access_token",
+		"refreshToken",
+		"refresh_token",
+		"clientSecret",
+		"client_secret"
+	] },
+	/**
+	* PCI-DSS: credit card and payment-related fields.
+	*/
+	"pci-dss": { paths: [
+		"card",
+		"cardNumber",
+		"card_number",
+		"ccn",
+		"pan",
+		"cvv",
+		"cvc",
+		"expirationDate",
+		"expiration_date",
+		"exp",
+		"payment.card",
+		"payment.cardNumber",
+		"payment.cvv"
+	] }
 };
+/**
+* Resolve a preset name or explicit options into RedactorOptions.
+*/
 function resolveConfig(config) {
-  if (typeof config === "string") {
-    const preset = REDACT_PRESETS[config];
-    if (!preset) {
-      throw new Error(
-        `Unknown redactor preset: "${config}". Available: ${Object.keys(REDACT_PRESETS).join(", ")}`
-      );
-    }
-    return preset;
-  }
-  return config;
+	if (typeof config === "string") {
+		const preset = REDACT_PRESETS[config];
+		if (!preset) throw new Error(`Unknown redactor preset: "${config}". Available: ${Object.keys(REDACT_PRESETS).join(", ")}`);
+		return preset;
+	}
+	return config;
 }
+/**
+* Create a redactor function from a list of paths.
+*
+* Paths use dot notation for nested fields and `[*]` or `*` for wildcards:
+* - `"password"` — top-level key
+* - `"user.email"` — nested field
+* - `"users[*].password"` or `"users.*.password"` — all items in array/object
+* - `"headers.authorization"` — nested header
+* - `"[*].secret"` — wildcard at root
+*
+* Overlapping paths are supported — e.g. `['user', 'user.email']` will
+* redact `user` as a whole while still recursing into `user.email`.
+*
+* The returned function clones plain objects/arrays before mutating,
+* so the original is never modified. Non-plain objects (Date, Map, etc.)
+* are passed through by reference.
+*
+* @example
+* ```typescript
+* // Using a preset
+* const redactor = createRedactor('default')
+*
+* // Using explicit paths
+* const redactor = createRedactor({
+*   paths: ['password', 'token', 'user.email', 'users[*].ssn'],
+*   censor: '[Filtered]',       // optional, default '[Redacted]'
+* })
+*
+* redactor({ password: 's3cret', user: { email: 'a@b.com' } })
+* // → { password: '[Filtered]', user: { email: '[Filtered]' } }
+*
+* // Custom censor function:
+* const mask = createRedactor({
+*   paths: ['ccn'],
+*   censor: (val) => '****' + String(val).slice(-4),
+* })
+* ```
+*/
 function createRedactor(config) {
-  const { paths, censor = DEFAULT_CENSOR, remove = false } = resolveConfig(config);
-  if (paths.length === 0) {
-    return (obj) => obj;
-  }
-  const parsed = paths.map((p) => parsePath(p));
-  const tree = buildPathTree(parsed);
-  return function redactor(obj) {
-    if (obj == null || typeof obj !== "object") return obj;
-    const clone = deepClone(obj);
-    redactWithTree(clone, tree, censor, remove);
-    return clone;
-  };
+	const { paths, censor = DEFAULT_CENSOR, remove = false } = resolveConfig(config);
+	if (paths.length === 0) return (obj) => obj;
+	const tree = buildPathTree(paths.map((p) => parsePath(p)));
+	return function redactor(obj) {
+		if (obj == null || typeof obj !== "object") return obj;
+		const clone = deepClone(obj);
+		redactWithTree(clone, tree, censor, remove);
+		return clone;
+	};
 }
 
-// src/api/logger.ts
-var LOG_LEVEL_KEY = createContextKey("autotel-edge-log-level");
-var PINO_LEVELS = {
-  values: {
-    trace: 10,
-    debug: 20,
-    info: 30,
-    warn: 40,
-    error: 50,
-    fatal: 60,
-    silent: Infinity
-  }};
-var LOGGER_VERSION = "autotel-edge";
+//#endregion
+//#region src/api/logger.ts
+/**
+* Pino-compatible structured logger for edge environments.
+*
+* Supports the practical Pino surface used by app code:
+* - Pino-style `LogFn` calls: string-first, object-first, and error-first
+* - Child loggers, level control, custom levels, and `msgPrefix`
+* - Serializers, formatters, mixins, redaction, and browser-style `transmit`
+* - Trace context injection (`traceId`, `spanId`, `correlationId`)
+* - Worker-safe EventEmitter-like methods for `level-change`
+*
+* The implementation stays dependency-light and console/write based so it
+* works in Cloudflare Workers and similar edge runtimes.
+*/
+/**
+* Context key for storing active log level (enables per-request log levels)
+*/
+const LOG_LEVEL_KEY = createContextKey("autotel-edge-log-level");
+const PINO_LEVELS = {
+	values: {
+		trace: 10,
+		debug: 20,
+		info: 30,
+		warn: 40,
+		error: 50,
+		fatal: 60,
+		silent: Infinity
+	},
+	labels: {
+		10: "trace",
+		20: "debug",
+		30: "info",
+		40: "warn",
+		50: "error",
+		60: "fatal",
+		[Infinity]: "silent"
+	}
+};
+const LOGGER_VERSION = "autotel-edge";
+/**
+* Get the active log level from context (if set)
+* Falls back to undefined if no log level is set in context
+*/
 function getActiveLogLevel() {
-  return context.active().getValue(LOG_LEVEL_KEY);
+	return context.active().getValue(LOG_LEVEL_KEY);
 }
+/**
+* Run a function with a specific log level
+* The log level is stored in OpenTelemetry context and applies to all logger calls within the callback
+*
+* This works in edge runtimes (uses OTel context, not Node.js AsyncLocalStorage)
+*
+* @example
+* ```typescript
+* // Enable debug logging for a specific request
+* runWithLogLevel('debug', () => {
+*   log.debug('This will be logged')
+*   processRequest()
+* })
+*
+* // Disable logging temporarily
+* runWithLogLevel('silent', () => {
+*   log.info('This will NOT be logged')
+* })
+* ```
+*/
 function runWithLogLevel(level, callback) {
-  const ctx = context.active().setValue(LOG_LEVEL_KEY, level);
-  return context.with(ctx, callback);
+	const ctx = context.active().setValue(LOG_LEVEL_KEY, level);
+	return context.with(ctx, callback);
 }
+/**
+* Get current trace context from active span
+*/
 function getTraceContext() {
-  const span = trace.getActiveSpan();
-  if (!span) return null;
-  const ctx = span.spanContext();
-  return {
-    traceId: ctx.traceId,
-    spanId: ctx.spanId,
-    correlationId: ctx.traceId.slice(0, 16)
-    // First 16 chars for grouping
-  };
+	const span = trace.getActiveSpan();
+	if (!span) return null;
+	const ctx = span.spanContext();
+	return {
+		traceId: ctx.traceId,
+		spanId: ctx.spanId,
+		correlationId: ctx.traceId.slice(0, 16)
+	};
 }
 function isRecord(value) {
-  return typeof value === "object" && value !== null;
+	return typeof value === "object" && value !== null;
 }
 function toErrorAttrs(error) {
-  if (error instanceof Error) {
-    return {
-      error: {
-        message: error.message,
-        type: error.name,
-        stack: error.stack
-      }
-    };
-  }
-  return { error: { message: String(error), type: "Error" } };
+	if (error instanceof Error) return { error: {
+		message: error.message,
+		type: error.name,
+		stack: error.stack
+	} };
+	return { error: {
+		message: String(error),
+		type: "Error"
+	} };
 }
 function formatMessage(template, args) {
-  if (args.length === 0) return template;
-  let argIndex = 0;
-  const formatted = template.replaceAll(/%[sdjifoO%]/g, (token) => {
-    if (token === "%%") return "%";
-    if (argIndex >= args.length) return token;
-    const value = args[argIndex++];
-    switch (token) {
-      case "%d":
-      case "%i":
-      case "%f": {
-        return String(Number(value));
-      }
-      case "%j": {
-        try {
-          return JSON.stringify(value);
-        } catch {
-          return "[Circular]";
-        }
-      }
-      case "%s": {
-        return String(value);
-      }
-      case "%o":
-      case "%O": {
-        try {
-          return JSON.stringify(value);
-        } catch {
-          return String(value);
-        }
-      }
-      default: {
-        return token;
-      }
-    }
-  });
-  return formatted;
+	if (args.length === 0) return template;
+	let argIndex = 0;
+	return template.replaceAll(/%[sdjifoO%]/g, (token) => {
+		if (token === "%%") return "%";
+		if (argIndex >= args.length) return token;
+		const value = args[argIndex++];
+		switch (token) {
+			case "%d":
+			case "%i":
+			case "%f": return String(Number(value));
+			case "%j": try {
+				return JSON.stringify(value);
+			} catch {
+				return "[Circular]";
+			}
+			case "%s": return String(value);
+			case "%o":
+			case "%O": try {
+				return JSON.stringify(value);
+			} catch {
+				return String(value);
+			}
+			default: return token;
+		}
+	});
 }
-var ANSI_RESET = "\x1B[0m";
-var ANSI_DIM = "\x1B[2m";
-var ANSI_BOLD = "\x1B[1m";
-var ANSI_COLORS = {
-  fatal: "\x1B[41m\x1B[37m",
-  // white on red bg
-  error: "\x1B[31m",
-  // red
-  warn: "\x1B[33m",
-  // yellow
-  info: "\x1B[36m",
-  // cyan
-  debug: "\x1B[34m",
-  // blue
-  trace: "\x1B[90m"
-  // gray
+const ANSI_RESET = "\x1B[0m";
+const ANSI_DIM = "\x1B[2m";
+const ANSI_BOLD = "\x1B[1m";
+const ANSI_COLORS = {
+	fatal: "\x1B[41m\x1B[37m",
+	error: "\x1B[31m",
+	warn: "\x1B[33m",
+	info: "\x1B[36m",
+	debug: "\x1B[34m",
+	trace: "\x1B[90m"
 };
-var LEVEL_SYMBOLS = {
-  fatal: "\u2717",
-  error: "\u2717",
-  warn: "\u26A0",
-  info: "\u25CF",
-  debug: "\u25E6",
-  trace: "\u2026"
+const LEVEL_SYMBOLS = {
+	fatal: "✗",
+	error: "✗",
+	warn: "⚠",
+	info: "●",
+	debug: "◦",
+	trace: "…"
 };
 function formatPrettyTimestamp() {
-  const d = /* @__PURE__ */ new Date();
-  const h = String(d.getHours()).padStart(2, "0");
-  const m = String(d.getMinutes()).padStart(2, "0");
-  const s = String(d.getSeconds()).padStart(2, "0");
-  const ms = String(d.getMilliseconds()).padStart(3, "0");
-  return `${h}:${m}:${s}.${ms}`;
+	const d = /* @__PURE__ */ new Date();
+	return `${String(d.getHours()).padStart(2, "0")}:${String(d.getMinutes()).padStart(2, "0")}:${String(d.getSeconds()).padStart(2, "0")}.${String(d.getMilliseconds()).padStart(3, "0")}`;
 }
 function formatPrettyAttrs(attrs) {
-  const keys = Object.keys(attrs);
-  if (keys.length === 0) return "";
-  return "\n" + JSON.stringify(attrs, null, 2).split("\n").map((line) => `    ${line}`).join("\n");
+	if (Object.keys(attrs).length === 0) return "";
+	return "\n" + JSON.stringify(attrs, null, 2).split("\n").map((line) => `    ${line}`).join("\n");
 }
 function safeStringify(obj, depthLimit, edgeLimit) {
-  const ancestors = [];
-  return JSON.stringify(obj, function replacer(_key, value) {
-    if (typeof value === "object" && value !== null) {
-      while (ancestors.length > 0 && ancestors[ancestors.length - 1] !== this) {
-        ancestors.pop();
-      }
-      if (ancestors.includes(value)) return "[Circular]";
-      if (ancestors.length >= depthLimit) return "[Object]";
-      ancestors.push(value);
-      if (!Array.isArray(value)) {
-        const keys = Object.keys(value);
-        if (keys.length > edgeLimit) {
-          const truncated = {};
-          for (let i = 0; i < edgeLimit; i++) {
-            truncated[keys[i]] = value[keys[i]];
-          }
-          truncated["..."] = `[${keys.length - edgeLimit} more properties]`;
-          return truncated;
-        }
-      }
-    }
-    return value;
-  });
+	const ancestors = [];
+	return JSON.stringify(obj, function replacer(_key, value) {
+		if (typeof value === "object" && value !== null) {
+			while (ancestors.length > 0 && ancestors[ancestors.length - 1] !== this) ancestors.pop();
+			if (ancestors.includes(value)) return "[Circular]";
+			if (ancestors.length >= depthLimit) return "[Object]";
+			ancestors.push(value);
+			if (!Array.isArray(value)) {
+				const keys = Object.keys(value);
+				if (keys.length > edgeLimit) {
+					const truncated = {};
+					for (let i = 0; i < edgeLimit; i++) truncated[keys[i]] = value[keys[i]];
+					truncated["..."] = `[${keys.length - edgeLimit} more properties]`;
+					return truncated;
+				}
+			}
+		}
+		return value;
+	});
 }
 function parseLogArgs(args) {
-  const [first, ...rest] = args;
-  if (typeof first === "string") {
-    return {
-      msg: formatMessage(first, rest),
-      attrs: void 0
-    };
-  }
-  if (first instanceof Error) {
-    return {
-      msg: typeof rest[0] === "string" ? formatMessage(rest[0], rest.slice(1)) : first.message,
-      attrs: toErrorAttrs(first)
-    };
-  }
-  if (isRecord(first)) {
-    return {
-      msg: typeof rest[0] === "string" ? formatMessage(rest[0], rest.slice(1)) : "",
-      attrs: first
-    };
-  }
-  return {
-    msg: String(first ?? ""),
-    attrs: void 0
-  };
+	const [first, ...rest] = args;
+	if (typeof first === "string") return {
+		msg: formatMessage(first, rest),
+		attrs: void 0
+	};
+	if (first instanceof Error) return {
+		msg: typeof rest[0] === "string" ? formatMessage(rest[0], rest.slice(1)) : first.message,
+		attrs: toErrorAttrs(first)
+	};
+	if (isRecord(first)) return {
+		msg: typeof rest[0] === "string" ? formatMessage(rest[0], rest.slice(1)) : "",
+		attrs: first
+	};
+	return {
+		msg: String(first ?? ""),
+		attrs: void 0
+	};
 }
 function createEdgeLogger(service, options) {
-  const customLevels = {
-    ...options?.customLevels
-  };
-  const availableLevels = options?.useOnlyCustomLevels ? { ...customLevels, silent: Infinity } : { ...PINO_LEVELS.values, ...customLevels };
-  const defaultLevel = options?.level ?? (options?.useOnlyCustomLevels ? Object.keys(customLevels)[0] : "info") ?? "info";
-  let currentLevel = defaultLevel;
-  const pretty = options?.pretty || false;
-  const currentBindings = { ...options?.bindings };
-  const resolvedRedact = Array.isArray(options?.redact) ? { paths: options.redact } : options?.redact;
-  const redactor = resolvedRedact ? createRedactor(resolvedRedact) : null;
-  const msgPrefix = options?.msgPrefix;
-  const levelValues = availableLevels;
-  const levelListeners = [];
-  const onChildCallback = options?.onChild ?? (() => {
-  });
-  const listeners = /* @__PURE__ */ new Map();
-  let maxListeners = 10;
-  const messageKey = options?.messageKey ?? "msg";
-  const errorKey = options?.errorKey ?? "err";
-  const nestedKey = options?.nestedKey;
-  const serializers = { ...options?.serializers };
-  const bindingsFormatter = options?.formatters?.bindings;
-  const levelFormatter = options?.formatters?.level;
-  const logFormatter = options?.formatters?.log;
-  const mixin = options?.mixin;
-  const levelComparison = options?.levelComparison;
-  const mixinMergeStrategy = options?.mixinMergeStrategy ?? ((mergeObject, mixinObject) => ({ ...mergeObject, ...mixinObject }));
-  let enabled = options?.enabled ?? true;
-  const loggerName = options?.name;
-  const base = options?.base;
-  const timestamp = options?.timestamp ?? true;
-  const safe = options?.safe ?? true;
-  const crlf = options?.crlf ?? false;
-  const depthLimit = options?.depthLimit ?? 5;
-  const edgeLimitOpt = options?.edgeLimit ?? 100;
-  const hooks = options?.hooks;
-  const writeFn = options?.write;
-  const transmit = options?.transmit;
-  const bindingsChain = options?._bindingsChain ?? [];
-  const compareLevels = (current, expected, comparison) => {
-    if (typeof comparison === "function") return comparison(current, expected);
-    if (comparison === "DESC") return current <= expected;
-    return current >= expected;
-  };
-  const addListener = (event, listener, prepend = false) => {
-    const activeListeners = listeners.get(event) ?? [];
-    if (prepend) {
-      activeListeners.unshift(listener);
-    } else {
-      activeListeners.push(listener);
-    }
-    listeners.set(event, activeListeners);
-    if (event === "level-change") {
-      levelListeners.length = 0;
-      levelListeners.push(
-        ...listeners.get(event) ?? []
-      );
-    }
-  };
-  const notifyLevelChange = (nextLevel, previousLevel, instance) => {
-    const nextValue = levelValues[nextLevel] ?? Infinity;
-    const previousValue = levelValues[previousLevel] ?? Infinity;
-    const snapshot = [...levelListeners];
-    for (const listener of snapshot) {
-      listener(nextLevel, nextValue, previousLevel, previousValue, instance);
-    }
-  };
-  const removeEventListener = (event, listener) => {
-    const activeListeners = listeners.get(event);
-    if (!activeListeners) {
-      return;
-    }
-    const index = activeListeners.indexOf(listener);
-    if (index !== -1) {
-      activeListeners.splice(index, 1);
-    }
-    if (activeListeners.length === 0) {
-      listeners.delete(event);
-    } else {
-      listeners.set(event, activeListeners);
-    }
-    if (event === "level-change") {
-      levelListeners.length = 0;
-      levelListeners.push(
-        ...listeners.get(event) ?? []
-      );
-    }
-  };
-  const shouldLog = (level) => {
-    if (!enabled) return false;
-    const activeLevel = getActiveLogLevel() ?? currentLevel;
-    if (activeLevel === "silent") return false;
-    const currentValue = levelValues[activeLevel];
-    const expectedValue = levelValues[level];
-    if (currentValue === void 0 || expectedValue === void 0) return false;
-    return compareLevels(
-      expectedValue,
-      currentValue,
-      levelComparison
-    );
-  };
-  const stringify = (obj) => {
-    if (safe) {
-      return safeStringify(obj, depthLimit, edgeLimitOpt);
-    }
-    return JSON.stringify(obj);
-  };
-  const getTimestamp = () => {
-    if (timestamp === false) return void 0;
-    if (typeof timestamp === "function") return timestamp();
-    return (/* @__PURE__ */ new Date()).toISOString();
-  };
-  const writeOutput = (level, logObject) => {
-    if (writeFn) {
-      if (typeof writeFn === "function") {
-        writeFn(logObject);
-      } else if (typeof writeFn === "object" && writeFn[level]) {
-        writeFn[level](logObject);
-      } else {
-        console.log(stringify(logObject));
-      }
-    } else if (pretty) {
-      return;
-    } else {
-      const json = stringify(logObject);
-      console.log(crlf ? json + "\r\n" : json);
-    }
-  };
-  const applySerializers = (obj) => {
-    if (Object.keys(serializers).length === 0) return obj;
-    return Object.fromEntries(
-      Object.entries(obj).map(([key, value]) => [
-        key,
-        key in serializers ? serializers[key](value) : value
-      ])
-    );
-  };
-  const emitTransmit = (level, rawArgs) => {
-    if (!transmit) return;
-    if (transmit.level) {
-      const transmitValue = levelValues[transmit.level];
-      const logValue = levelValues[level];
-      if (transmitValue !== void 0 && logValue !== void 0 && logValue < transmitValue) {
-        return;
-      }
-    }
-    const processedMessages = rawArgs.map((m) => {
-      if (typeof m !== "object" || m === null) return m;
-      const serialized = applySerializers(m);
-      return redactor ? redactor(serialized) : serialized;
-    });
-    const processedBindings = bindingsChain.map((b) => {
-      const serialized = applySerializers({ ...b });
-      return redactor ? redactor(serialized) : serialized;
-    });
-    const logEvent = {
-      ts: Date.now(),
-      messages: processedMessages,
-      bindings: processedBindings,
-      level: { label: level, value: levelValues[level] }
-    };
-    transmit.send(level, logEvent);
-  };
-  const log = (level, msg, attrs, rawArgs) => {
-    if (!shouldLog(level)) return;
-    const ctx = getTraceContext();
-    const message = msgPrefix ? `${msgPrefix}${msg}` : msg;
-    const baseBindings = bindingsFormatter ? bindingsFormatter({ ...currentBindings }) : { ...currentBindings };
-    const serializedAttrs = attrs ? Object.fromEntries(
-      Object.entries(attrs).map(([key, value]) => [
-        key,
-        key in serializers ? serializers[key](value) : value
-      ])
-    ) : void 0;
-    const mergeObject = nestedKey ? { [nestedKey]: serializedAttrs ?? {} } : serializedAttrs ?? {};
-    const mixinObject = mixin?.(mergeObject, levelValues[level], logger) ?? {};
-    const mergedLogObject = mixinMergeStrategy(mergeObject, mixinObject);
-    const formattedLogObject = logFormatter ? logFormatter(mergedLogObject) : mergedLogObject;
-    const formattedLevel = levelFormatter ? levelFormatter(level, levelValues[level]) : {
-      level: logger.useLevelLabels ? level : levelValues[level]
-    };
-    const ts = getTimestamp();
-    const logEntry = {
-      ...formattedLevel,
-      ...loggerName === void 0 ? {} : { name: loggerName },
-      service,
-      ...message === "" ? {} : { [messageKey]: message },
-      ...base === null || base === void 0 ? {} : base,
-      ...baseBindings,
-      ...formattedLogObject,
-      ...ctx,
-      // Auto-inject traceId, spanId, correlationId
-      ...ts === void 0 ? {} : { timestamp: ts }
-    };
-    if (serializedAttrs && !nestedKey && errorKey !== "error" && "error" in logEntry) {
-      logEntry[errorKey] = logEntry.error;
-      delete logEntry.error;
-    }
-    if (pretty && !writeFn) {
-      const color = ANSI_COLORS[level] ?? ANSI_COLORS.info;
-      const symbol = LEVEL_SYMBOLS[level] ?? "\u25CF";
-      const time = formatPrettyTimestamp();
-      const traceInfo = ctx ? ` ${ANSI_DIM}[${ctx.traceId.slice(0, 8)}/${ctx.spanId.slice(0, 8)}]${ANSI_RESET}` : "";
-      const prettyAttrs = {
-        ...baseBindings,
-        ...formattedLogObject
-      };
-      const safeAttrs = redactor ? redactor(prettyAttrs) : prettyAttrs;
-      const attrsStr = formatPrettyAttrs(safeAttrs);
-      console.log(
-        `${ANSI_DIM}${time}${ANSI_RESET} ${color}${ANSI_BOLD}${symbol} ${level.toUpperCase()}${ANSI_RESET}${traceInfo} ${ANSI_DIM}(${service})${ANSI_RESET} ${message}${attrsStr}`
-      );
-    } else {
-      const safeEntry = redactor ? redactor(logEntry) : logEntry;
-      writeOutput(level, safeEntry);
-    }
-    emitTransmit(level, rawArgs ?? []);
-  };
-  const makeLogMethod = (levelName) => {
-    return ((...args) => {
-      if (hooks?.logMethod) {
-        const method = ((...methodArgs) => {
-          const { msg: msg2, attrs: attrs2 } = parseLogArgs(methodArgs);
-          log(levelName, msg2, attrs2, methodArgs);
-        });
-        hooks.logMethod.call(logger, args, method, levelValues[levelName]);
-        return;
-      }
-      const { msg, attrs } = parseLogArgs(args);
-      log(levelName, msg, attrs, args);
-    });
-  };
-  const logger = {
-    version: LOGGER_VERSION,
-    get name() {
-      return loggerName;
-    },
-    levels: {
-      values: levelValues,
-      labels: Object.fromEntries(
-        Object.entries(levelValues).map(([label, value]) => [value, label])
-      )
-    },
-    useLevelLabels: options?.useLevelLabels ?? false,
-    customLevels: { ...customLevels },
-    useOnlyCustomLevels: options?.useOnlyCustomLevels ?? false,
-    get level() {
-      return currentLevel;
-    },
-    set level(level) {
-      const previousLevel = currentLevel;
-      currentLevel = level;
-      notifyLevelChange(level, previousLevel, logger);
-    },
-    get levelVal() {
-      return levelValues[currentLevel] ?? Infinity;
-    },
-    get msgPrefix() {
-      return msgPrefix;
-    },
-    onChild: onChildCallback,
-    get enabled() {
-      return enabled;
-    },
-    set enabled(value) {
-      enabled = value;
-    },
-    info: makeLogMethod("info"),
-    error: makeLogMethod("error"),
-    warn: makeLogMethod("warn"),
-    debug: makeLogMethod("debug"),
-    trace: makeLogMethod("trace"),
-    fatal: makeLogMethod("fatal"),
-    silent: (() => {
-    }),
-    child: (bindings, childOptions) => {
-      const childLogger = createEdgeLogger(service, {
-        level: childOptions?.level ?? currentLevel,
-        pretty,
-        bindings: { ...currentBindings, ...bindings },
-        redact: childOptions?.redact ?? options?.redact,
-        msgPrefix: childOptions?.msgPrefix === void 0 ? msgPrefix : `${msgPrefix ?? ""}${childOptions.msgPrefix}`,
-        useLevelLabels: logger.useLevelLabels,
-        onChild: onChildCallback,
-        enabled,
-        messageKey,
-        errorKey,
-        nestedKey,
-        serializers: { ...serializers, ...childOptions?.serializers },
-        formatters: {
-          level: childOptions?.formatters?.level ?? levelFormatter,
-          bindings: childOptions?.formatters?.bindings ?? bindingsFormatter,
-          log: childOptions?.formatters?.log ?? logFormatter
-        },
-        mixin,
-        mixinMergeStrategy,
-        customLevels,
-        useOnlyCustomLevels: options?.useOnlyCustomLevels,
-        levelComparison: options?.levelComparison,
-        name: loggerName,
-        base,
-        timestamp,
-        safe,
-        crlf,
-        depthLimit,
-        edgeLimit: edgeLimitOpt,
-        hooks,
-        write: writeFn,
-        transmit,
-        _bindingsChain: [...bindingsChain, bindings]
-      });
-      onChildCallback(childLogger);
-      return childLogger;
-    },
-    isLevelEnabled: (level) => shouldLog(level),
-    bindings: () => ({ ...currentBindings }),
-    setBindings: (bindings) => {
-      for (const [key, value] of Object.entries(bindings)) {
-        if (!(key in currentBindings)) {
-          currentBindings[key] = value;
-        }
-      }
-    },
-    flush: (cb) => {
-      cb?.();
-    },
-    emit: (event, ...args) => {
-      const activeListeners = listeners.get(event);
-      if (!activeListeners || activeListeners.length === 0) {
-        return false;
-      }
-      const snapshot = [...activeListeners];
-      for (const listener of snapshot) {
-        listener(...args);
-      }
-      return true;
-    },
-    eventNames: () => [...listeners.keys()],
-    getMaxListeners: () => maxListeners,
-    listenerCount: (event) => listeners.get(event)?.length ?? 0,
-    listeners: (event) => [...listeners.get(event) ?? []],
-    on: (event, listener) => {
-      addListener(event, listener);
-      return logger;
-    },
-    addListener: (event, listener) => {
-      addListener(event, listener);
-      return logger;
-    },
-    once: (event, listener) => {
-      const wrapped = (...args) => {
-        removeEventListener(event, wrapped);
-        listener(...args);
-      };
-      addListener(event, wrapped);
-      return logger;
-    },
-    prependListener: (event, listener) => {
-      addListener(event, listener, true);
-      return logger;
-    },
-    prependOnceListener: (event, listener) => {
-      const wrapped = (...args) => {
-        removeEventListener(event, wrapped);
-        listener(...args);
-      };
-      addListener(event, wrapped, true);
-      return logger;
-    },
-    rawListeners: (event) => [...listeners.get(event) ?? []],
-    off: (event, listener) => {
-      removeEventListener(event, listener);
-      return logger;
-    },
-    removeAllListeners: (event) => {
-      if (event === void 0) {
-        listeners.clear();
-        levelListeners.length = 0;
-        return logger;
-      }
-      listeners.delete(event);
-      if (event === "level-change") {
-        levelListeners.length = 0;
-      }
-      return logger;
-    },
-    removeListener: (event, listener) => {
-      removeEventListener(event, listener);
-      return logger;
-    },
-    setMaxListeners: (n) => {
-      maxListeners = n;
-      return logger;
-    }
-  };
-  for (const levelName of Object.keys(customLevels)) {
-    logger[levelName] = makeLogMethod(levelName);
-  }
-  return logger;
+	const customLevels = { ...options?.customLevels };
+	const availableLevels = options?.useOnlyCustomLevels ? {
+		...customLevels,
+		silent: Infinity
+	} : {
+		...PINO_LEVELS.values,
+		...customLevels
+	};
+	let currentLevel = options?.level ?? (options?.useOnlyCustomLevels ? Object.keys(customLevels)[0] : "info") ?? "info";
+	const pretty = options?.pretty || false;
+	const currentBindings = { ...options?.bindings };
+	const resolvedRedact = Array.isArray(options?.redact) ? { paths: options.redact } : options?.redact;
+	const redactor = resolvedRedact ? createRedactor(resolvedRedact) : null;
+	const msgPrefix = options?.msgPrefix;
+	const levelValues = availableLevels;
+	const levelListeners = [];
+	const onChildCallback = options?.onChild ?? (() => {});
+	const listeners = /* @__PURE__ */ new Map();
+	let maxListeners = 10;
+	const messageKey = options?.messageKey ?? "msg";
+	const errorKey = options?.errorKey ?? "err";
+	const nestedKey = options?.nestedKey;
+	const serializers = { ...options?.serializers };
+	const bindingsFormatter = options?.formatters?.bindings;
+	const levelFormatter = options?.formatters?.level;
+	const logFormatter = options?.formatters?.log;
+	const mixin = options?.mixin;
+	const levelComparison = options?.levelComparison;
+	const mixinMergeStrategy = options?.mixinMergeStrategy ?? ((mergeObject, mixinObject) => ({
+		...mergeObject,
+		...mixinObject
+	}));
+	let enabled = options?.enabled ?? true;
+	const loggerName = options?.name;
+	const base = options?.base;
+	const timestamp = options?.timestamp ?? true;
+	const safe = options?.safe ?? true;
+	const crlf = options?.crlf ?? false;
+	const depthLimit = options?.depthLimit ?? 5;
+	const edgeLimitOpt = options?.edgeLimit ?? 100;
+	const hooks = options?.hooks;
+	const writeFn = options?.write;
+	const transmit = options?.transmit;
+	const bindingsChain = options?._bindingsChain ?? [];
+	const compareLevels = (current, expected, comparison) => {
+		if (typeof comparison === "function") return comparison(current, expected);
+		if (comparison === "DESC") return current <= expected;
+		return current >= expected;
+	};
+	const addListener = (event, listener, prepend = false) => {
+		const activeListeners = listeners.get(event) ?? [];
+		if (prepend) activeListeners.unshift(listener);
+		else activeListeners.push(listener);
+		listeners.set(event, activeListeners);
+		if (event === "level-change") {
+			levelListeners.length = 0;
+			levelListeners.push(...listeners.get(event) ?? []);
+		}
+	};
+	const notifyLevelChange = (nextLevel, previousLevel, instance) => {
+		const nextValue = levelValues[nextLevel] ?? Infinity;
+		const previousValue = levelValues[previousLevel] ?? Infinity;
+		const snapshot = [...levelListeners];
+		for (const listener of snapshot) listener(nextLevel, nextValue, previousLevel, previousValue, instance);
+	};
+	const removeEventListener = (event, listener) => {
+		const activeListeners = listeners.get(event);
+		if (!activeListeners) return;
+		const index = activeListeners.indexOf(listener);
+		if (index !== -1) activeListeners.splice(index, 1);
+		if (activeListeners.length === 0) listeners.delete(event);
+		else listeners.set(event, activeListeners);
+		if (event === "level-change") {
+			levelListeners.length = 0;
+			levelListeners.push(...listeners.get(event) ?? []);
+		}
+	};
+	const shouldLog = (level) => {
+		if (!enabled) return false;
+		const activeLevel = getActiveLogLevel() ?? currentLevel;
+		if (activeLevel === "silent") return false;
+		const currentValue = levelValues[activeLevel];
+		const expectedValue = levelValues[level];
+		if (currentValue === void 0 || expectedValue === void 0) return false;
+		return compareLevels(expectedValue, currentValue, levelComparison);
+	};
+	const stringify = (obj) => {
+		if (safe) return safeStringify(obj, depthLimit, edgeLimitOpt);
+		return JSON.stringify(obj);
+	};
+	const getTimestamp = () => {
+		if (timestamp === false) return void 0;
+		if (typeof timestamp === "function") return timestamp();
+		return (/* @__PURE__ */ new Date()).toISOString();
+	};
+	const writeOutput = (level, logObject) => {
+		if (writeFn) if (typeof writeFn === "function") writeFn(logObject);
+		else if (typeof writeFn === "object" && writeFn[level]) writeFn[level](logObject);
+		else console.log(stringify(logObject));
+		else if (pretty) return;
+		else {
+			const json = stringify(logObject);
+			console.log(crlf ? json + "\r\n" : json);
+		}
+	};
+	const applySerializers = (obj) => {
+		if (Object.keys(serializers).length === 0) return obj;
+		return Object.fromEntries(Object.entries(obj).map(([key, value]) => [key, key in serializers ? serializers[key](value) : value]));
+	};
+	const emitTransmit = (level, rawArgs) => {
+		if (!transmit) return;
+		if (transmit.level) {
+			const transmitValue = levelValues[transmit.level];
+			const logValue = levelValues[level];
+			if (transmitValue !== void 0 && logValue !== void 0 && logValue < transmitValue) return;
+		}
+		const processedMessages = rawArgs.map((m) => {
+			if (typeof m !== "object" || m === null) return m;
+			const serialized = applySerializers(m);
+			return redactor ? redactor(serialized) : serialized;
+		});
+		const processedBindings = bindingsChain.map((b) => {
+			const serialized = applySerializers({ ...b });
+			return redactor ? redactor(serialized) : serialized;
+		});
+		const logEvent = {
+			ts: Date.now(),
+			messages: processedMessages,
+			bindings: processedBindings,
+			level: {
+				label: level,
+				value: levelValues[level]
+			}
+		};
+		transmit.send(level, logEvent);
+	};
+	const log = (level, msg, attrs, rawArgs) => {
+		if (!shouldLog(level)) return;
+		const ctx = getTraceContext();
+		const message = msgPrefix ? `${msgPrefix}${msg}` : msg;
+		const baseBindings = bindingsFormatter ? bindingsFormatter({ ...currentBindings }) : { ...currentBindings };
+		const serializedAttrs = attrs ? Object.fromEntries(Object.entries(attrs).map(([key, value]) => [key, key in serializers ? serializers[key](value) : value])) : void 0;
+		const mergeObject = nestedKey ? { [nestedKey]: serializedAttrs ?? {} } : serializedAttrs ?? {};
+		const mergedLogObject = mixinMergeStrategy(mergeObject, mixin?.(mergeObject, levelValues[level], logger) ?? {});
+		const formattedLogObject = logFormatter ? logFormatter(mergedLogObject) : mergedLogObject;
+		const formattedLevel = levelFormatter ? levelFormatter(level, levelValues[level]) : { level: logger.useLevelLabels ? level : levelValues[level] };
+		const ts = getTimestamp();
+		const logEntry = {
+			...formattedLevel,
+			...loggerName === void 0 ? {} : { name: loggerName },
+			service,
+			...message === "" ? {} : { [messageKey]: message },
+			...base === null || base === void 0 ? {} : base,
+			...baseBindings,
+			...formattedLogObject,
+			...ctx,
+			...ts === void 0 ? {} : { timestamp: ts }
+		};
+		if (serializedAttrs && !nestedKey && errorKey !== "error" && "error" in logEntry) {
+			logEntry[errorKey] = logEntry.error;
+			delete logEntry.error;
+		}
+		if (pretty && !writeFn) {
+			const color = ANSI_COLORS[level] ?? ANSI_COLORS.info;
+			const symbol = LEVEL_SYMBOLS[level] ?? "●";
+			const time = formatPrettyTimestamp();
+			const traceInfo = ctx ? ` ${ANSI_DIM}[${ctx.traceId.slice(0, 8)}/${ctx.spanId.slice(0, 8)}]${ANSI_RESET}` : "";
+			const prettyAttrs = {
+				...baseBindings,
+				...formattedLogObject
+			};
+			const attrsStr = formatPrettyAttrs(redactor ? redactor(prettyAttrs) : prettyAttrs);
+			console.log(`${ANSI_DIM}${time}${ANSI_RESET} ${color}${ANSI_BOLD}${symbol} ${level.toUpperCase()}${ANSI_RESET}${traceInfo} ${ANSI_DIM}(${service})${ANSI_RESET} ${message}${attrsStr}`);
+		} else writeOutput(level, redactor ? redactor(logEntry) : logEntry);
+		emitTransmit(level, rawArgs ?? []);
+	};
+	const makeLogMethod = (levelName) => {
+		return ((...args) => {
+			if (hooks?.logMethod) {
+				const method = ((...methodArgs) => {
+					const { msg, attrs } = parseLogArgs(methodArgs);
+					log(levelName, msg, attrs, methodArgs);
+				});
+				hooks.logMethod.call(logger, args, method, levelValues[levelName]);
+				return;
+			}
+			const { msg, attrs } = parseLogArgs(args);
+			log(levelName, msg, attrs, args);
+		});
+	};
+	const logger = {
+		version: LOGGER_VERSION,
+		get name() {
+			return loggerName;
+		},
+		levels: {
+			values: levelValues,
+			labels: Object.fromEntries(Object.entries(levelValues).map(([label, value]) => [value, label]))
+		},
+		useLevelLabels: options?.useLevelLabels ?? false,
+		customLevels: { ...customLevels },
+		useOnlyCustomLevels: options?.useOnlyCustomLevels ?? false,
+		get level() {
+			return currentLevel;
+		},
+		set level(level) {
+			const previousLevel = currentLevel;
+			currentLevel = level;
+			notifyLevelChange(level, previousLevel, logger);
+		},
+		get levelVal() {
+			return levelValues[currentLevel] ?? Infinity;
+		},
+		get msgPrefix() {
+			return msgPrefix;
+		},
+		onChild: onChildCallback,
+		get enabled() {
+			return enabled;
+		},
+		set enabled(value) {
+			enabled = value;
+		},
+		info: makeLogMethod("info"),
+		error: makeLogMethod("error"),
+		warn: makeLogMethod("warn"),
+		debug: makeLogMethod("debug"),
+		trace: makeLogMethod("trace"),
+		fatal: makeLogMethod("fatal"),
+		silent: (() => {}),
+		child: (bindings, childOptions) => {
+			const childLogger = createEdgeLogger(service, {
+				level: childOptions?.level ?? currentLevel,
+				pretty,
+				bindings: {
+					...currentBindings,
+					...bindings
+				},
+				redact: childOptions?.redact ?? options?.redact,
+				msgPrefix: childOptions?.msgPrefix === void 0 ? msgPrefix : `${msgPrefix ?? ""}${childOptions.msgPrefix}`,
+				useLevelLabels: logger.useLevelLabels,
+				onChild: onChildCallback,
+				enabled,
+				messageKey,
+				errorKey,
+				nestedKey,
+				serializers: {
+					...serializers,
+					...childOptions?.serializers
+				},
+				formatters: {
+					level: childOptions?.formatters?.level ?? levelFormatter,
+					bindings: childOptions?.formatters?.bindings ?? bindingsFormatter,
+					log: childOptions?.formatters?.log ?? logFormatter
+				},
+				mixin,
+				mixinMergeStrategy,
+				customLevels,
+				useOnlyCustomLevels: options?.useOnlyCustomLevels,
+				levelComparison: options?.levelComparison,
+				name: loggerName,
+				base,
+				timestamp,
+				safe,
+				crlf,
+				depthLimit,
+				edgeLimit: edgeLimitOpt,
+				hooks,
+				write: writeFn,
+				transmit,
+				_bindingsChain: [...bindingsChain, bindings]
+			});
+			onChildCallback(childLogger);
+			return childLogger;
+		},
+		isLevelEnabled: (level) => shouldLog(level),
+		bindings: () => ({ ...currentBindings }),
+		setBindings: (bindings) => {
+			for (const [key, value] of Object.entries(bindings)) if (!(key in currentBindings)) currentBindings[key] = value;
+		},
+		flush: (cb) => {
+			cb?.();
+		},
+		emit: (event, ...args) => {
+			const activeListeners = listeners.get(event);
+			if (!activeListeners || activeListeners.length === 0) return false;
+			const snapshot = [...activeListeners];
+			for (const listener of snapshot) listener(...args);
+			return true;
+		},
+		eventNames: () => [...listeners.keys()],
+		getMaxListeners: () => maxListeners,
+		listenerCount: (event) => listeners.get(event)?.length ?? 0,
+		listeners: (event) => [...listeners.get(event) ?? []],
+		on: (event, listener) => {
+			addListener(event, listener);
+			return logger;
+		},
+		addListener: (event, listener) => {
+			addListener(event, listener);
+			return logger;
+		},
+		once: (event, listener) => {
+			const wrapped = (...args) => {
+				removeEventListener(event, wrapped);
+				listener(...args);
+			};
+			addListener(event, wrapped);
+			return logger;
+		},
+		prependListener: (event, listener) => {
+			addListener(event, listener, true);
+			return logger;
+		},
+		prependOnceListener: (event, listener) => {
+			const wrapped = (...args) => {
+				removeEventListener(event, wrapped);
+				listener(...args);
+			};
+			addListener(event, wrapped, true);
+			return logger;
+		},
+		rawListeners: (event) => [...listeners.get(event) ?? []],
+		off: (event, listener) => {
+			removeEventListener(event, listener);
+			return logger;
+		},
+		removeAllListeners: (event) => {
+			if (event === void 0) {
+				listeners.clear();
+				levelListeners.length = 0;
+				return logger;
+			}
+			listeners.delete(event);
+			if (event === "level-change") levelListeners.length = 0;
+			return logger;
+		},
+		removeListener: (event, listener) => {
+			removeEventListener(event, listener);
+			return logger;
+		},
+		setMaxListeners: (n) => {
+			maxListeners = n;
+			return logger;
+		}
+	};
+	for (const levelName of Object.keys(customLevels)) logger[levelName] = makeLogMethod(levelName);
+	return logger;
 }
+/**
+* Helper to get trace context (useful for BYOL - Bring Your Own Logger)
+*
+* @example
+* ```typescript
+* import bunyan from 'bunyan'
+* import { getEdgeTraceContext } from 'autotel-edge/api/logger'
+*
+* const bunyanLogger = bunyan.createLogger({ name: 'myapp' })
+* const ctx = getEdgeTraceContext()
+* bunyanLogger.info({ ...ctx, email: 'test@example.com' }, 'Creating user')
+* ```
+*/
 function getEdgeTraceContext() {
-  return getTraceContext();
+	return getTraceContext();
 }
 
-export { REDACT_PRESETS, createEdgeLogger, createRedactor, getActiveLogLevel, getEdgeTraceContext, runWithLogLevel };
-//# sourceMappingURL=logger.js.map
+//#endregion
+export { REDACT_PRESETS, createEdgeLogger, createRedactor, getActiveLogLevel, getEdgeTraceContext, getExecutionLogger, runWithLogLevel };
 //# sourceMappingURL=logger.js.map