@unhingged/logit 0.0.0-stage → 0.1.0

package/dist/chunk-GW7WQELF.js

@@ -0,0 +1,2117 @@
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/levels.ts
+var LEVELS = ["verbose", "debug", "info", "warn", "error", "fatal"];
+var LEVEL_ORDER = {
+  verbose: 0,
+  debug: 1,
+  info: 2,
+  warn: 3,
+  error: 4,
+  fatal: 5
+};
+var SERILOG_LEVEL_NAMES = {
+  verbose: "Verbose",
+  debug: "Debug",
+  info: "Information",
+  warn: "Warning",
+  error: "Error",
+  fatal: "Fatal"
+};
+var LEVEL_CODES = {
+  verbose: "VRB",
+  debug: "DBG",
+  info: "INF",
+  warn: "WRN",
+  error: "ERR",
+  fatal: "FTL"
+};
+var LEVEL_NUMBERS = {
+  verbose: 10,
+  debug: 20,
+  info: 30,
+  warn: 40,
+  error: 50,
+  fatal: 60
+};
+var ALIASES = {
+  verbose: "verbose",
+  trace: "verbose",
+  vrb: "verbose",
+  debug: "debug",
+  dbg: "debug",
+  info: "info",
+  information: "info",
+  informational: "info",
+  inf: "info",
+  warn: "warn",
+  warning: "warn",
+  wrn: "warn",
+  error: "error",
+  err: "error",
+  fatal: "fatal",
+  critical: "fatal",
+  crit: "fatal",
+  ftl: "fatal",
+  silent: "fatal"
+};
+function parseLevel(input) {
+  if (typeof input === "number") {
+    if (input <= 10) return "verbose";
+    if (input <= 20) return "debug";
+    if (input <= 30) return "info";
+    if (input <= 40) return "warn";
+    if (input <= 50) return "error";
+    return "fatal";
+  }
+  const level = ALIASES[String(input).trim().toLowerCase()];
+  if (!level) throw new Error(`logit: unknown log level "${input}" (expected one of ${LEVELS.join(", ")})`);
+  return level;
+}
+function isLevel(input) {
+  return typeof input === "string" && Object.prototype.hasOwnProperty.call(LEVEL_ORDER, input);
+}
+function levelAtLeast(level, minimum) {
+  return LEVEL_ORDER[level] >= LEVEL_ORDER[minimum];
+}
+var LevelSwitch = class {
+  #level;
+  #listeners = /* @__PURE__ */ new Set();
+  constructor(initial = "info") {
+    this.#level = parseLevel(initial);
+  }
+  get level() {
+    return this.#level;
+  }
+  set level(next) {
+    const parsed = parseLevel(next);
+    if (parsed === this.#level) return;
+    this.#level = parsed;
+    for (const listener of this.#listeners) listener(parsed);
+  }
+  /** Called with the new level on every change; returns an unsubscribe function. */
+  onChange(listener) {
+    this.#listeners.add(listener);
+    return () => this.#listeners.delete(listener);
+  }
+};
+function resolveLevel(value) {
+  return value instanceof LevelSwitch ? value.level : parseLevel(value);
+}
+
+// src/template.ts
+var HOLE = /^([@$])?([0-9A-Za-z_]+)(?:,(-?\d+))?(?::([^}]+))?$/;
+var CACHE_LIMIT = 2e3;
+var cache = /* @__PURE__ */ new Map();
+function parseTemplate(raw) {
+  const cached = cache.get(raw);
+  if (cached) return cached;
+  const parsed = parse(raw);
+  if (cache.size >= CACHE_LIMIT) cache.clear();
+  cache.set(raw, parsed);
+  return parsed;
+}
+function parse(raw) {
+  const tokens = [];
+  const holes = [];
+  let text = "";
+  let i = 0;
+  const n = raw.length;
+  while (i < n) {
+    const ch = raw[i];
+    if (ch === "{") {
+      if (raw[i + 1] === "{") {
+        text += "{";
+        i += 2;
+        continue;
+      }
+      const close = raw.indexOf("}", i + 1);
+      if (close !== -1) {
+        const body = raw.slice(i + 1, close);
+        const m = HOLE.exec(body);
+        if (m) {
+          if (text) {
+            tokens.push({ kind: "text", text });
+            text = "";
+          }
+          const name = m[2];
+          const isIndex = /^\d+$/.test(name);
+          const hole = {
+            kind: "hole",
+            raw: raw.slice(i, close + 1),
+            name,
+            ...isIndex ? { index: Number(name) } : {},
+            ...m[1] ? { operator: m[1] } : {},
+            ...m[3] !== void 0 ? { alignment: Number(m[3]) } : {},
+            ...m[4] !== void 0 ? { format: m[4] } : {}
+          };
+          tokens.push(hole);
+          holes.push(hole);
+          i = close + 1;
+          continue;
+        }
+      }
+      text += "{";
+      i += 1;
+      continue;
+    }
+    if (ch === "}" && raw[i + 1] === "}") {
+      text += "}";
+      i += 2;
+      continue;
+    }
+    text += ch;
+    i += 1;
+  }
+  if (text) tokens.push({ kind: "text", text });
+  const positional = holes.length > 0 && holes.every((h) => h.index !== void 0);
+  return { raw, tokens, holes, positional };
+}
+function templateHash(raw) {
+  let hash = 0;
+  for (let i = 0; i < raw.length; i++) {
+    hash = hash + raw.charCodeAt(i) >>> 0;
+    hash = hash + (hash << 10) >>> 0;
+    hash = (hash ^ hash >>> 6) >>> 0;
+  }
+  hash = hash + (hash << 3) >>> 0;
+  hash = (hash ^ hash >>> 11) >>> 0;
+  hash = hash + (hash << 15) >>> 0;
+  return hash.toString(16).padStart(8, "0");
+}
+function align(text, alignment) {
+  if (!alignment) return text;
+  const width = Math.abs(alignment);
+  if (text.length >= width) return text;
+  return alignment > 0 ? text.padStart(width) : text.padEnd(width);
+}
+
+// src/capture.ts
+var DEFAULT_DESTRUCTURING = {
+  maxDepth: 10,
+  maxStringLength: Infinity,
+  maxCollectionCount: Infinity,
+  redact: [],
+  redactedValue: "[Redacted]",
+  policies: [],
+  typeTag: true
+};
+function resolveDestructuring(partial) {
+  return { ...DEFAULT_DESTRUCTURING, ...partial };
+}
+function byTransforming(type, transform) {
+  return (value) => value instanceof type ? { value: transform(value) } : void 0;
+}
+var PLAIN_PROTOS = /* @__PURE__ */ new Set([Object.prototype, null]);
+function isPlainObject(value) {
+  return PLAIN_PROTOS.has(Object.getPrototypeOf(value));
+}
+function className(value) {
+  const name = value.constructor?.name;
+  return typeof name === "string" && name.length > 0 && name !== "Object" ? name : void 0;
+}
+function truncate(text, max) {
+  return text.length > max ? `${text.slice(0, max)}\u2026` : text;
+}
+function compileRedact(rules) {
+  return rules.map((rule) => rule.includes(".") ? { path: rule.toLowerCase().split(".") } : { key: rule.toLowerCase() });
+}
+var redactCache = /* @__PURE__ */ new WeakMap();
+function redactRules(options) {
+  let rules = redactCache.get(options.redact);
+  if (!rules) {
+    rules = compileRedact(options.redact);
+    redactCache.set(options.redact, rules);
+  }
+  return rules;
+}
+function isRedacted(rules, path) {
+  if (rules.length === 0) return false;
+  const last = path[path.length - 1];
+  for (const rule of rules) {
+    if (rule.key !== void 0) {
+      if (rule.key === last) return true;
+      continue;
+    }
+    const segs = rule.path;
+    if (segs.length !== path.length) continue;
+    let ok = true;
+    for (let i = 0; i < segs.length; i++) {
+      if (segs[i] !== "*" && segs[i] !== path[i]) {
+        ok = false;
+        break;
+      }
+    }
+    if (ok) return true;
+  }
+  return false;
+}
+function captureValue(value, operator, options, path = [], seen = /* @__PURE__ */ new Set(), depth = 0) {
+  switch (typeof value) {
+    case "string":
+      return truncate(value, options.maxStringLength);
+    case "number":
+      return Number.isFinite(value) ? value : String(value);
+    case "boolean":
+      return value;
+    case "undefined":
+      return null;
+    case "bigint":
+      return Number.isSafeInteger(Number(value)) ? Number(value) : value.toString();
+    case "symbol":
+      return value.toString();
+    case "function":
+      return `[Function${value.name ? ` ${value.name}` : ""}]`;
+    case "object":
+      if (value === null) return null;
+      return captureObject(value, operator, options, path, seen, depth);
+    default:
+      return String(value);
+  }
+}
+function captureProperty(name, value, operator, options) {
+  const path = [name.toLowerCase()];
+  if (isRedacted(redactRules(options), path)) return options.redactedValue;
+  return captureValue(value, operator, options, path);
+}
+function captureObject(value, operator, options, path, seen, depth) {
+  if (operator === "$") return stringify(value, options);
+  for (const policy of options.policies) {
+    let answer;
+    try {
+      answer = policy(value);
+    } catch {
+      answer = void 0;
+    }
+    if (answer) return captureValue(answer.value, void 0, options, path, seen, depth);
+  }
+  if (value instanceof Date) return Number.isNaN(value.getTime()) ? null : value;
+  if (value instanceof Error) return captureError(value, options, path, seen, depth);
+  if (seen.has(value)) return "[Circular]";
+  if (depth >= options.maxDepth) return Array.isArray(value) ? "[Array]" : "[Object]";
+  if (Array.isArray(value)) return captureArray(value, options, path, seen, depth);
+  if (value instanceof Set) return captureArray(Array.from(value), options, path, seen, depth);
+  if (value instanceof Map) return captureMap(value, options, path, seen, depth);
+  if (ArrayBuffer.isView(value) && !(value instanceof DataView)) {
+    return captureArray(Array.from(value), options, path, seen, depth);
+  }
+  const plain = isPlainObject(value);
+  if (!plain && operator !== "@") return stringify(value, options);
+  return captureStructure(value, plain, options, path, seen, depth);
+}
+function stringify(value, options) {
+  const asString = value.toString;
+  if (typeof asString === "function" && asString !== Object.prototype.toString && asString !== Error.prototype.toString) {
+    try {
+      return truncate(String(value), options.maxStringLength);
+    } catch {
+    }
+  }
+  const toJSON = value.toJSON;
+  if (typeof toJSON === "function") {
+    try {
+      const json = toJSON.call(value);
+      if (typeof json === "string") return truncate(json, options.maxStringLength);
+      if (json !== null && typeof json === "object") return captureValue(json, "@", options);
+      return json;
+    } catch {
+    }
+  }
+  if (Array.isArray(value)) return `[Array(${value.length})]`;
+  return className(value) ?? "[object Object]";
+}
+function captureArray(items, options, path, seen, depth) {
+  seen.add(items);
+  const limit = Math.min(items.length, options.maxCollectionCount);
+  const out = new Array(limit);
+  for (let i = 0; i < limit; i++) out[i] = captureValue(items[i], "@", options, path, seen, depth + 1);
+  seen.delete(items);
+  return out;
+}
+function captureMap(map, options, path, seen, depth) {
+  seen.add(map);
+  const rules = redactRules(options);
+  let count = 0;
+  let allScalarKeys = true;
+  for (const key of map.keys()) {
+    if (typeof key !== "string" && typeof key !== "number") {
+      allScalarKeys = false;
+      break;
+    }
+  }
+  let result;
+  if (allScalarKeys) {
+    const out = {};
+    for (const [key, item] of map) {
+      if (count++ >= options.maxCollectionCount) break;
+      const name = String(key);
+      const next = [...path, name.toLowerCase()];
+      out[name] = isRedacted(rules, next) ? options.redactedValue : captureValue(item, "@", options, next, seen, depth + 1);
+    }
+    result = out;
+  } else {
+    const out = [];
+    for (const [key, item] of map) {
+      if (count++ >= options.maxCollectionCount) break;
+      out.push([captureValue(key, "@", options, path, seen, depth + 1), captureValue(item, "@", options, path, seen, depth + 1)]);
+    }
+    result = out;
+  }
+  seen.delete(map);
+  return result;
+}
+function captureStructure(value, plain, options, path, seen, depth) {
+  seen.add(value);
+  const rules = redactRules(options);
+  const out = {};
+  if (!plain && options.typeTag) {
+    const name = className(value);
+    if (name) out.$type = name;
+  }
+  for (const key of Object.keys(value)) {
+    const next = [...path, key.toLowerCase()];
+    if (isRedacted(rules, next)) {
+      out[key] = options.redactedValue;
+      continue;
+    }
+    let item;
+    try {
+      item = value[key];
+    } catch (error) {
+      item = `[Throws: ${error instanceof Error ? error.message : String(error)}]`;
+    }
+    out[key] = captureValue(item, "@", options, next, seen, depth + 1);
+  }
+  seen.delete(value);
+  return out;
+}
+function captureError(error, options = DEFAULT_DESTRUCTURING, path = [], seen = /* @__PURE__ */ new Set(), depth = 0) {
+  const out = {
+    $type: "Error",
+    name: error.name || "Error",
+    message: truncate(String(error.message ?? ""), options.maxStringLength)
+  };
+  if (typeof error.stack === "string" && error.stack) out.stack = error.stack;
+  if (seen.has(error) || depth >= options.maxDepth) return out;
+  seen.add(error);
+  const rules = redactRules(options);
+  for (const key of Object.keys(error)) {
+    if (key === "name" || key === "message" || key === "stack") continue;
+    const next = [...path, key.toLowerCase()];
+    out[key] = isRedacted(rules, next) ? options.redactedValue : captureValue(error[key], "@", options, next, seen, depth + 1);
+  }
+  if ("cause" in error && error.cause !== void 0 && !("cause" in out)) {
+    out.cause = captureValue(error.cause, "@", options, [...path, "cause"], seen, depth + 1);
+  }
+  if (error instanceof AggregateError && !("errors" in out)) {
+    out.errors = captureArray(error.errors, options, [...path, "errors"], seen, depth + 1);
+  }
+  seen.delete(error);
+  return out;
+}
+function captureArguments(holes, positional, args, options, into) {
+  if (positional) {
+    for (const hole of holes) {
+      const i = hole.index;
+      if (i < args.length) into[hole.name] = captureProperty(hole.name, args[i], hole.operator, options);
+    }
+    return;
+  }
+  const n = Math.min(holes.length, args.length);
+  for (let i = 0; i < n; i++) {
+    const hole = holes[i];
+    into[hole.name] = captureProperty(hole.name, args[i], hole.operator, options);
+  }
+}
+
+// src/format/render.ts
+var NONE = (text) => text;
+var NO_STYLES = Object.freeze({ string: NONE, number: NONE, boolean: NONE, null: NONE, name: NONE, punctuation: NONE, missing: NONE });
+function resolveStyles(styles) {
+  return styles ? { ...NO_STYLES, ...styles } : NO_STYLES;
+}
+var EMPTY = {};
+function renderValue(value, format, options = EMPTY) {
+  const S = options.styles ? resolveStyles(options.styles) : NO_STYLES;
+  const literal = options.literal || format !== void 0 && format.includes("l");
+  const json = options.json || format !== void 0 && format.includes("j");
+  if (value === null || value === void 0) return S.null("null");
+  switch (typeof value) {
+    case "string":
+      return S.string(literal ? value : JSON.stringify(value));
+    case "number":
+      return S.number(format === void 0 ? String(value) : formatNumber(value, format));
+    case "boolean":
+      return S.boolean(value ? "true" : "false");
+    case "bigint":
+      return S.number(value.toString());
+    default:
+      break;
+  }
+  if (value instanceof Date) {
+    const text = format && !/^[lj]+$/.test(format) ? formatDate(value, format, options.utc) : value.toISOString();
+    return S.string(literal || json ? text : JSON.stringify(text));
+  }
+  if (json) return S.string(toJson(value));
+  const nested = options.literal ? { ...options, literal: false } : options;
+  if (Array.isArray(value)) {
+    let out = S.punctuation("[");
+    for (let i = 0; i < value.length; i++) {
+      if (i) out += S.punctuation(", ");
+      out += renderValue(value[i], void 0, nested);
+    }
+    return out + S.punctuation("]");
+  }
+  if (typeof value === "object") return renderStructure(value, nested, S);
+  return String(value);
+}
+function renderStructure(value, options, S) {
+  const type = value.$type;
+  if (type === "Error" && typeof value.message === "string") {
+    const name = typeof value.name === "string" ? value.name : "Error";
+    return `${S.name(name)}${S.punctuation(":")} ${S.string(value.message)}`;
+  }
+  const tag = typeof type === "string" ? `${S.name(type)} ` : "";
+  let inner = "";
+  for (const key of Object.keys(value)) {
+    if (key === "$type") continue;
+    if (inner) inner += S.punctuation(", ");
+    inner += `${S.name(key)}${S.punctuation(":")} ${renderValue(value[key], void 0, options)}`;
+  }
+  if (!inner) return `${tag}${S.punctuation("{ }")}`;
+  return `${tag}${S.punctuation("{ ")}${inner}${S.punctuation(" }")}`;
+}
+function toJson(value) {
+  try {
+    return JSON.stringify(value) ?? "null";
+  } catch {
+    try {
+      return JSON.stringify(value, jsonReplacer) ?? "null";
+    } catch {
+      return '"[Unserializable]"';
+    }
+  }
+}
+function jsonReplacer(_key, value) {
+  if (typeof value === "bigint") return value.toString();
+  if (typeof value === "number" && !Number.isFinite(value)) return String(value);
+  return value;
+}
+var PLAIN = (value) => String(value);
+var numberFormats = /* @__PURE__ */ new Map();
+function formatNumber(value, format) {
+  if (!format) return String(value);
+  let formatter = numberFormats.get(format);
+  if (!formatter) {
+    formatter = compileNumberFormat(format);
+    if (numberFormats.size > 500) numberFormats.clear();
+    numberFormats.set(format, formatter);
+  }
+  return formatter(value);
+}
+function compileNumberFormat(format) {
+  const f = format.replace(/[lj]/g, "");
+  if (!f) return PLAIN;
+  const fixed = /^[Ff](\d*)$/.exec(f);
+  if (fixed) {
+    const digits = fixed[1] ? Number(fixed[1]) : 2;
+    return (value) => value.toFixed(digits);
+  }
+  const grouped = /^[Nn](\d*)$/.exec(f);
+  if (grouped) {
+    const digits = grouped[1] ? Number(grouped[1]) : 2;
+    const nf = new Intl.NumberFormat("en-US", { minimumFractionDigits: digits, maximumFractionDigits: digits });
+    return (value) => nf.format(value);
+  }
+  const percent = /^[Pp](\d*)$/.exec(f);
+  if (percent) {
+    const digits = percent[1] ? Number(percent[1]) : 2;
+    return (value) => `${(value * 100).toFixed(digits)} %`;
+  }
+  const padded = /^[Dd](\d+)$/.exec(f);
+  if (padded) {
+    const width = Number(padded[1]);
+    return (value) => String(Math.trunc(value)).padStart(width, "0");
+  }
+  if (/^[Xx]\d*$/.test(f)) {
+    const width = Number(f.slice(1) || 0);
+    const upper = f[0] === "X";
+    return (value) => {
+      const hex = Math.trunc(value).toString(16);
+      return (upper ? hex.toUpperCase() : hex).padStart(width, "0");
+    };
+  }
+  const pattern = /^0*(?:\.(0*)(#*))?$/.exec(f);
+  if (pattern) {
+    const min = pattern[1]?.length ?? 0;
+    const max = min + (pattern[2]?.length ?? 0);
+    const hasFraction = pattern[1] !== void 0 || pattern[2] !== void 0;
+    const intMin = f.split(".")[0].length;
+    const optional = max > min;
+    return (value) => {
+      let text = hasFraction ? optional ? trimFraction(value.toFixed(max), min) : value.toFixed(max) : String(Math.round(value));
+      if (intMin > 1) {
+        const [whole, frac] = text.replace("-", "").split(".");
+        text = `${value < 0 ? "-" : ""}${whole.padStart(intMin, "0")}${frac !== void 0 ? `.${frac}` : ""}`;
+      }
+      return text;
+    };
+  }
+  return PLAIN;
+}
+var cachedSecond = Number.NaN;
+var cachedPrefix = "";
+function isoTimestamp(date) {
+  const ms = date.getTime();
+  if (Number.isNaN(ms)) return "Invalid Date";
+  const second = Math.floor(ms / 1e3);
+  if (second !== cachedSecond) {
+    cachedSecond = second;
+    cachedPrefix = new Date(second * 1e3).toISOString().slice(0, 19);
+  }
+  const millis = ms - second * 1e3;
+  return `${cachedPrefix}.${millis < 10 ? "00" : millis < 100 ? "0" : ""}${millis}Z`;
+}
+function trimFraction(text, keep) {
+  if (!text.includes(".")) return text;
+  let [whole, frac] = text.split(".");
+  while (frac.length > keep && frac.endsWith("0")) frac = frac.slice(0, -1);
+  return frac.length ? `${whole}.${frac}` : whole;
+}
+var pad = (n, width = 2) => String(n).padStart(width, "0");
+function formatDate(date, pattern, utc = false) {
+  if (pattern === "o" || pattern === "O") return date.toISOString();
+  const get = utc ? {
+    year: date.getUTCFullYear(),
+    month: date.getUTCMonth() + 1,
+    day: date.getUTCDate(),
+    hours: date.getUTCHours(),
+    minutes: date.getUTCMinutes(),
+    seconds: date.getUTCSeconds(),
+    ms: date.getUTCMilliseconds(),
+    offset: 0
+  } : {
+    year: date.getFullYear(),
+    month: date.getMonth() + 1,
+    day: date.getDate(),
+    hours: date.getHours(),
+    minutes: date.getMinutes(),
+    seconds: date.getSeconds(),
+    ms: date.getMilliseconds(),
+    offset: -date.getTimezoneOffset()
+  };
+  const offsetText = (short) => {
+    const sign = get.offset >= 0 ? "+" : "-";
+    const abs = Math.abs(get.offset);
+    const h = pad(Math.floor(abs / 60));
+    const m = pad(abs % 60);
+    return short ? `${sign}${h}` : `${sign}${h}:${m}`;
+  };
+  let out = "";
+  let i = 0;
+  while (i < pattern.length) {
+    const ch = pattern[i];
+    if (ch === "'" || ch === '"') {
+      const end = pattern.indexOf(ch, i + 1);
+      out += pattern.slice(i + 1, end === -1 ? pattern.length : end);
+      i = end === -1 ? pattern.length : end + 1;
+      continue;
+    }
+    if (ch === "\\") {
+      out += pattern[i + 1] ?? "";
+      i += 2;
+      continue;
+    }
+    let run = 1;
+    while (pattern[i + run] === ch) run++;
+    switch (ch) {
+      case "y":
+        out += run >= 4 ? String(get.year) : pad(get.year % 100);
+        break;
+      case "M":
+        out += run >= 2 ? pad(get.month) : String(get.month);
+        break;
+      case "d":
+        out += run >= 2 ? pad(get.day) : String(get.day);
+        break;
+      case "H":
+        out += run >= 2 ? pad(get.hours) : String(get.hours);
+        break;
+      case "h": {
+        const h = get.hours % 12 || 12;
+        out += run >= 2 ? pad(h) : String(h);
+        break;
+      }
+      case "m":
+        out += run >= 2 ? pad(get.minutes) : String(get.minutes);
+        break;
+      case "s":
+        out += run >= 2 ? pad(get.seconds) : String(get.seconds);
+        break;
+      case "f":
+      case "F": {
+        const frac = pad(get.ms, 3).padEnd(run, "0").slice(0, run);
+        out += ch === "F" ? frac.replace(/0+$/, "") : frac;
+        break;
+      }
+      case "t":
+        out += run >= 2 ? get.hours < 12 ? "AM" : "PM" : get.hours < 12 ? "A" : "P";
+        break;
+      case "z":
+        out += offsetText(run < 3);
+        break;
+      case "K":
+        out += utc || get.offset === 0 ? "Z" : offsetText(false);
+        break;
+      default:
+        out += ch.repeat(run);
+    }
+    i += run;
+  }
+  return out;
+}
+function renderTemplate(template, properties, options = {}, renderings) {
+  let out = "";
+  for (const token of template.tokens) {
+    if (token.kind === "text") {
+      out += token.text;
+      continue;
+    }
+    out += renderHole(token, properties, options, renderings);
+  }
+  return out;
+}
+var hasOwn = Object.prototype.hasOwnProperty;
+function renderHole(hole, properties, options, renderings) {
+  if (!hasOwn.call(properties, hole.name)) {
+    return options.styles?.missing ? options.styles.missing(hole.raw) : hole.raw;
+  }
+  const text = renderValue(properties[hole.name], hole.format, options);
+  if (renderings && hole.format) renderings.push(text);
+  return align(text, hole.alignment);
+}
+
+// src/event.ts
+var LogEvent = class {
+  timestamp;
+  level;
+  template;
+  properties;
+  error;
+  traceId;
+  spanId;
+  #destructuring;
+  #capturedError;
+  #eventId;
+  constructor(init, destructuring) {
+    this.timestamp = init.timestamp ?? /* @__PURE__ */ new Date();
+    this.level = init.level;
+    this.template = init.template;
+    this.properties = init.properties ?? {};
+    this.error = init.error;
+    this.traceId = init.traceId;
+    this.spanId = init.spanId;
+    this.#destructuring = destructuring;
+  }
+  /** The template text, e.g. `"User {UserId} logged in"`. */
+  get messageTemplate() {
+    return this.template.raw;
+  }
+  /** Serilog's `SourceContext` — set by `logger.forSource()`. */
+  get sourceContext() {
+    const value = this.properties.SourceContext;
+    return typeof value === "string" ? value : void 0;
+  }
+  /** Eight hex digits identifying the template (Seq's `@i`). */
+  get eventId() {
+    return this.#eventId ??= templateHash(this.template.raw);
+  }
+  /** The error as a structure (name, message, stack, own properties, cause chain), captured once. */
+  get errorProperties() {
+    if (!this.error) return void 0;
+    return this.#capturedError ??= captureError(this.error, this.#destructuring);
+  }
+  /** Captures and adds `value` under `name` unless the event already has it — the rule enrichers follow. */
+  addPropertyIfAbsent(name, value, destructure = false) {
+    if (Object.prototype.hasOwnProperty.call(this.properties, name)) return;
+    this.properties[name] = captureProperty(name, value, destructure ? "@" : void 0, this.#destructuring);
+  }
+  /** Captures and adds `value` under `name`, replacing any existing value. */
+  addOrUpdateProperty(name, value, destructure = false) {
+    this.properties[name] = captureProperty(name, value, destructure ? "@" : void 0, this.#destructuring);
+  }
+  removeProperty(name) {
+    delete this.properties[name];
+  }
+  hasProperty(name) {
+    return Object.prototype.hasOwnProperty.call(this.properties, name);
+  }
+  /** The template rendered with this event's properties. */
+  renderMessage(options) {
+    return renderTemplate(this.template, this.properties, options);
+  }
+  /** Properties that are not holes in the template — the "extra" context, in Serilog's `{Properties}` sense. */
+  extraProperties() {
+    const out = {};
+    const holes = this.template.holes;
+    for (const key of Object.keys(this.properties)) {
+      if (!holes.some((h) => h.name === key)) out[key] = this.properties[key];
+    }
+    return out;
+  }
+};
+
+// src/context.ts
+var StackStore = class {
+  current;
+  getStore() {
+    return this.current;
+  }
+  run(frame, fn) {
+    const previous = this.current;
+    this.current = frame;
+    try {
+      return fn();
+    } finally {
+      this.current = previous;
+    }
+  }
+  enterWith(frame) {
+    this.current = frame;
+  }
+};
+function detectStore() {
+  try {
+    const proc = globalThis.process;
+    const hooks = proc?.getBuiltinModule?.("node:async_hooks");
+    if (hooks?.AsyncLocalStorage) return new hooks.AsyncLocalStorage();
+  } catch {
+  }
+  try {
+    const req = globalThis.require ?? (typeof __require === "function" ? __require : void 0);
+    const hooks = req?.("node:async_hooks");
+    if (hooks?.AsyncLocalStorage) return new hooks.AsyncLocalStorage();
+  } catch {
+  }
+  return new StackStore();
+}
+var store = detectStore();
+var DISPOSE = Symbol.dispose ?? /* @__PURE__ */ Symbol.for("Symbol.dispose");
+function makeFrame(properties, parent, diagnostics) {
+  return { properties, parent: parent ?? null, diagnostics: diagnostics ?? parent?.diagnostics };
+}
+var LogContext = {
+  /**
+   * Runs `fn` with `properties` added to the ambient context. Async
+   * functions are followed through every `await` when an
+   * AsyncLocalStorage-backed store is active.
+   */
+  run(properties, fn) {
+    return store.run(makeFrame(properties, store.getStore()), fn);
+  },
+  /**
+   * Pushes properties onto the ambient context until the handle is disposed.
+   * Prefer `run()` for async code; `push()` relies on `enterWith`, which
+   * binds the rest of the *current* async scope.
+   */
+  push(properties) {
+    const previous = store.getStore();
+    if (!store.enterWith) throw new Error("logit: this context store has no enterWith(); use LogContext.run() instead");
+    store.enterWith(makeFrame(properties, previous));
+    let disposed = false;
+    const dispose = () => {
+      if (disposed) return;
+      disposed = true;
+      store.enterWith(previous);
+    };
+    return { dispose, [DISPOSE]: dispose };
+  },
+  /** The merged ambient properties, innermost frame winning. */
+  current() {
+    const frame = store.getStore();
+    if (!frame) return {};
+    const frames = [];
+    for (let f = frame; f; f = f.parent) frames.push(f);
+    const out = {};
+    for (let i = frames.length - 1; i >= 0; i--) Object.assign(out, frames[i].properties);
+    return out;
+  },
+  /** The innermost frame, for enrichers that want to walk it themselves. */
+  frame() {
+    return store.getStore();
+  },
+  /**
+   * Starts a request scope: ambient `properties` plus a fresh diagnostic
+   * bag that `diagnosticContext.set()` writes to and the request-completion
+   * event reads. Used by the Next.js and Express integrations.
+   */
+  runScope(properties, fn) {
+    const diagnostics = /* @__PURE__ */ new Map();
+    return store.run(makeFrame(properties, store.getStore(), diagnostics), () => fn(diagnostics));
+  },
+  /** Replaces the backing store — `new AsyncLocalStorage()` on runtimes we cannot detect. */
+  use(next) {
+    store = next;
+  },
+  /** `true` when frames follow async execution (an AsyncLocalStorage-like store is active). */
+  get isAsync() {
+    return !(store instanceof StackStore);
+  }
+};
+var diagnosticContext = {
+  set(name, value) {
+    store.getStore()?.diagnostics?.set(name, value);
+  },
+  /** `true` inside a request scope (so a library can skip the work of computing a value nobody will collect). */
+  get active() {
+    return store.getStore()?.diagnostics !== void 0;
+  }
+};
+
+// src/enrichers.ts
+function withProperty(name, value, destructure = false) {
+  return (event) => event.addPropertyIfAbsent(name, value, destructure);
+}
+function withProperties(properties, destructure = false) {
+  const entries = Object.entries(properties);
+  return (event) => {
+    for (const [name, value] of entries) event.addPropertyIfAbsent(name, value, destructure);
+  };
+}
+function withComputed(name, compute, destructure = false) {
+  return (event) => {
+    if (event.hasProperty(name)) return;
+    event.addPropertyIfAbsent(name, compute(event), destructure);
+  };
+}
+function fromLogContext() {
+  return (event) => {
+    const frame = LogContext.frame();
+    if (!frame) return;
+    for (let f = frame; f; f = f.parent) {
+      for (const name of Object.keys(f.properties)) {
+        const value = f.properties[name];
+        if (name === "traceId") {
+          if (event.traceId === void 0 && typeof value === "string") event.traceId = value;
+          continue;
+        }
+        if (name === "spanId") {
+          if (event.spanId === void 0 && typeof value === "string") event.spanId = value;
+          continue;
+        }
+        event.addPropertyIfAbsent(name, value, true);
+      }
+      if (!f.parent) break;
+    }
+  };
+}
+function withEnvironment(name) {
+  const env = name ?? globalThis.process?.env?.NODE_ENV;
+  return (event) => {
+    if (env) event.addPropertyIfAbsent("Environment", env);
+  };
+}
+function withTraceContext(get) {
+  return (event) => {
+    if (event.traceId !== void 0 && event.spanId !== void 0) return;
+    let ctx;
+    try {
+      ctx = get();
+    } catch {
+      return;
+    }
+    if (!ctx) return;
+    if (event.traceId === void 0 && ctx.traceId) event.traceId = ctx.traceId;
+    if (event.spanId === void 0 && ctx.spanId) event.spanId = ctx.spanId;
+  };
+}
+
+// src/filters.ts
+function byExcluding(predicate) {
+  return (event) => !predicate(event);
+}
+function byIncludingOnly(predicate) {
+  return predicate;
+}
+var Matching = {
+  /** Events whose `SourceContext` is `source` or starts with `source.`. */
+  fromSource(source) {
+    const prefix = `${source}.`;
+    return (event) => {
+      const ctx = event.sourceContext;
+      return ctx !== void 0 && (ctx === source || ctx.startsWith(prefix));
+    };
+  },
+  /** Events that carry `name` — optionally with a value the predicate accepts. */
+  withProperty(name, predicate) {
+    return (event) => event.hasProperty(name) && (predicate ? predicate(event.properties[name]) : true);
+  },
+  /** Events written with exactly this template text. */
+  withTemplate(template) {
+    return (event) => event.messageTemplate === template;
+  },
+  /** Events whose rendered message matches the pattern. */
+  messageMatches(pattern) {
+    return (event) => pattern.test(event.renderMessage({ literal: true }));
+  }
+};
+function sampled(rate, predicate = () => true, random = Math.random) {
+  return (event) => !predicate(event) || random() < rate;
+}
+function rateLimited(max, windowMs, predicate = () => true, now2 = Date.now) {
+  let windowStart = 0;
+  let count = 0;
+  return (event) => {
+    if (!predicate(event)) return true;
+    const t = now2();
+    if (t - windowStart >= windowMs) {
+      windowStart = t;
+      count = 0;
+    }
+    return ++count <= max;
+  };
+}
+
+// src/selflog.ts
+var output = null;
+var selfLog = {
+  /** `'stderr'` writes to `console.error`; a function receives each line. */
+  enable(target) {
+    output = target === "stderr" ? (line) => console.error(line) : target;
+  },
+  disable() {
+    output = null;
+  },
+  get enabled() {
+    return output !== null;
+  },
+  /** Writes one line (prefixed with the time) if enabled; swallows its own errors. */
+  write(message, error) {
+    if (!output) return;
+    try {
+      const detail = error instanceof Error ? ` \u2014 ${error.stack ?? error.message}` : error !== void 0 ? ` \u2014 ${String(error)}` : "";
+      output(`${(/* @__PURE__ */ new Date()).toISOString()} logit: ${message}${detail}`);
+    } catch {
+    }
+  }
+};
+
+// src/format/text.ts
+var DEFAULT_OUTPUT_TEMPLATE = "{Timestamp:yyyy-MM-dd HH:mm:ss.fff zzz} [{Level:u3}] {Message:lj}{NewLine}{Exception}";
+function formatLevel(level, format) {
+  const name = SERILOG_LEVEL_NAMES[level];
+  if (!format) return name;
+  const m = /^([uw])(\d*)$/.exec(format);
+  if (!m) return name;
+  const width = m[2] ? Number(m[2]) : 0;
+  let text = width === 3 ? LEVEL_CODES[level] : width > 0 ? name.slice(0, width) : name;
+  if (width > 0 && text.length < width) text = text.padEnd(width);
+  return m[1] === "u" ? text.toUpperCase() : text.toLowerCase();
+}
+function formatError(error, indent = "") {
+  if (!error) return "";
+  const lines = [];
+  let current = error;
+  let depth = 0;
+  const seen = /* @__PURE__ */ new Set();
+  while (current !== void 0 && current !== null && depth < 10 && !seen.has(current)) {
+    seen.add(current);
+    const prefix = depth === 0 ? indent : `${indent}${"  ".repeat(depth)}caused by: `;
+    if (current instanceof Error) {
+      const body = current.stack && current.stack.includes(current.message) ? current.stack : `${current.name}: ${current.message}${current.stack ? `
+${current.stack}` : ""}`;
+      lines.push(prefix + body.split("\n").join(`
+${indent}${"  ".repeat(depth)}`));
+      if (current instanceof AggregateError && current.errors.length) {
+        current.errors.forEach((inner, i) => {
+          lines.push(`${indent}${"  ".repeat(depth + 1)}[${i}] ${formatError(inner instanceof Error ? inner : new Error(String(inner)), `${indent}${"  ".repeat(depth + 1)}`).trimStart()}`);
+        });
+      }
+      current = current.cause;
+    } else {
+      lines.push(prefix + String(current));
+      current = void 0;
+    }
+    depth++;
+  }
+  return lines.join("\n");
+}
+function textFormatter(options = {}) {
+  const template = parseTemplate(options.outputTemplate ?? DEFAULT_OUTPUT_TEMPLATE);
+  const utc = options.utc ?? false;
+  const styles = options.styles;
+  const tokenStyles = options.tokenStyles ?? {};
+  const usedNames = new Set(template.holes.map((h) => h.name));
+  return (event) => {
+    let out = "";
+    for (const token of template.tokens) {
+      if (token.kind === "text") {
+        out += token.text;
+        continue;
+      }
+      out += align(renderToken(token, event), token.alignment);
+    }
+    return out;
+  };
+  function renderToken(hole, event) {
+    switch (hole.name) {
+      case "Timestamp": {
+        const text = hole.format ? formatDate(event.timestamp, hole.format, utc) : event.timestamp.toISOString();
+        return tokenStyles.Timestamp?.(text, event) ?? text;
+      }
+      case "Level": {
+        const text = formatLevel(event.level, hole.format);
+        return tokenStyles.Level?.(text, event) ?? text;
+      }
+      case "Message": {
+        const renderOptions = { literal: hole.format?.includes("l"), json: hole.format?.includes("j"), utc, styles };
+        const text = renderTemplate(event.template, event.properties, renderOptions);
+        return tokenStyles.Message?.(text, event) ?? text;
+      }
+      case "NewLine":
+        return "\n";
+      case "Exception": {
+        if (!event.error) return "";
+        const text = formatError(event.error);
+        return tokenStyles.Exception?.(text, event) ?? text;
+      }
+      case "Properties": {
+        const extra = {};
+        for (const key of Object.keys(event.properties)) {
+          if (usedNames.has(key) || event.template.holes.some((h) => h.name === key)) continue;
+          extra[key] = event.properties[key];
+        }
+        if (Object.keys(extra).length === 0) return "";
+        const text = hole.format?.includes("j") ? toJson(extra) : renderValue(extra, void 0, { styles });
+        return tokenStyles.Properties?.(text, event) ?? text;
+      }
+      case "TraceId":
+        return event.traceId ?? "";
+      case "SpanId":
+        return event.spanId ?? "";
+      case "EventId":
+        return event.eventId;
+      default: {
+        if (!event.hasProperty(hole.name)) return "";
+        const text = renderValue(event.properties[hole.name], hole.format ?? "l", { utc, styles });
+        return hole.name === "SourceContext" ? tokenStyles.SourceContext?.(text, event) ?? text : text;
+      }
+    }
+  }
+}
+
+// src/format/clef.ts
+var CLEF_MEDIA_TYPE = "application/vnd.serilog.clef";
+function clefFormatter(options = {}) {
+  return (event) => {
+    const out = { "@t": isoTimestamp(event.timestamp) };
+    if (options.renderMessage) out["@m"] = event.renderMessage({ literal: true });
+    out["@mt"] = event.messageTemplate;
+    if (event.level !== "info") out["@l"] = SERILOG_LEVEL_NAMES[event.level];
+    if (event.error) out["@x"] = formatError(event.error);
+    out["@i"] = event.eventId;
+    const renderings = [];
+    renderTemplate(event.template, event.properties, {}, renderings);
+    if (renderings.length) out["@r"] = renderings;
+    if (event.traceId) out["@tr"] = event.traceId;
+    if (event.spanId) out["@sp"] = event.spanId;
+    for (const key of Object.keys(event.properties)) {
+      out[key.startsWith("@") ? `@${key}` : key] = event.properties[key];
+    }
+    return toJson(out);
+  };
+}
+
+// src/format/json.ts
+var DEFAULT_KEYS = {
+  timestamp: "timestamp",
+  level: "level",
+  message: "message",
+  template: "template",
+  source: "source",
+  error: "error",
+  traceId: "traceId",
+  spanId: "spanId",
+  eventId: "eventId"
+};
+var templateJson = /* @__PURE__ */ new WeakMap();
+function jsonFormatter(options = {}) {
+  const keys = { ...DEFAULT_KEYS, ...options.keys };
+  const reserved = Object.values(keys);
+  const levelFormat = options.levelFormat ?? "name";
+  const withMessage = options.message ?? true;
+  const withTemplate = options.template ?? true;
+  const withEventId = options.eventId ?? false;
+  const epoch = options.timestampFormat === "epoch";
+  const key = (name) => `,${JSON.stringify(name)}:`;
+  const timestampKey = `{${JSON.stringify(keys.timestamp)}:`;
+  const levelFragment = {};
+  for (const level of LEVELS) {
+    const value = levelFormat === "number" ? LEVEL_NUMBERS[level] : levelFormat === "serilog" ? SERILOG_LEVEL_NAMES[level] : levelFormat === "upper" ? level.toUpperCase() : level;
+    levelFragment[level] = `${key(keys.level)}${JSON.stringify(value)}`;
+  }
+  const messageKey = key(keys.message);
+  const templateKey = key(keys.template);
+  const eventIdKey = key(keys.eventId);
+  const sourceKey = key(keys.source);
+  const traceKey = key(keys.traceId);
+  const spanKey = key(keys.spanId);
+  const errorKey = key(keys.error);
+  return (event) => {
+    let out = timestampKey + (epoch ? String(event.timestamp.getTime()) : `"${isoTimestamp(event.timestamp)}"`) + levelFragment[event.level];
+    if (withMessage) out += messageKey + JSON.stringify(event.renderMessage({ literal: true }));
+    if (withTemplate) {
+      let cached = templateJson.get(event.template);
+      if (cached === void 0) {
+        cached = JSON.stringify(event.messageTemplate);
+        templateJson.set(event.template, cached);
+      }
+      out += templateKey + cached;
+    }
+    if (withEventId) out += `${eventIdKey}"${event.eventId}"`;
+    const properties = event.properties;
+    const source = properties.SourceContext;
+    if (typeof source === "string") out += sourceKey + JSON.stringify(source);
+    if (event.traceId) out += traceKey + JSON.stringify(event.traceId);
+    if (event.spanId) out += spanKey + JSON.stringify(event.spanId);
+    let rest;
+    let needsCopy = source !== void 0;
+    if (!needsCopy) {
+      for (let i = 0; i < reserved.length; i++) {
+        if (Object.prototype.hasOwnProperty.call(properties, reserved[i])) {
+          needsCopy = true;
+          break;
+        }
+      }
+    }
+    if (needsCopy) {
+      rest = {};
+      for (const name of Object.keys(properties)) {
+        if (name === "SourceContext") continue;
+        rest[reserved.includes(name) ? `${name}_` : name] = properties[name];
+      }
+    } else {
+      rest = properties;
+    }
+    const propsJson = toJson(rest);
+    if (propsJson.length > 2) out += `,${propsJson.slice(1, -1)}`;
+    if (event.error) out += errorKey + toJson(event.errorProperties);
+    return `${out}}`;
+  };
+}
+
+// src/format/pretty.ts
+var ESC = "\x1B[";
+var code = (open, close) => (text) => `${ESC}${open}m${text}${ESC}${close}m`;
+var ansi = {
+  bold: code(1, 22),
+  dim: code(2, 22),
+  italic: code(3, 23),
+  underline: code(4, 24),
+  red: code(31, 39),
+  green: code(32, 39),
+  yellow: code(33, 39),
+  blue: code(34, 39),
+  magenta: code(35, 39),
+  cyan: code(36, 39),
+  white: code(37, 39),
+  gray: code(90, 39),
+  bgRed: code(41, 49)
+};
+var LEVEL_STYLE = {
+  verbose: ansi.gray,
+  debug: ansi.blue,
+  info: ansi.green,
+  warn: ansi.yellow,
+  error: ansi.red,
+  fatal: (text) => ansi.bold(ansi.bgRed(ansi.white(text)))
+};
+function detectColors(stream) {
+  const env = globalThis.process?.env;
+  if (!env) return false;
+  if (env.NO_COLOR !== void 0 && env.NO_COLOR !== "") return false;
+  if (env.FORCE_COLOR !== void 0 && env.FORCE_COLOR !== "0" && env.FORCE_COLOR !== "") return true;
+  if (env.TERM === "dumb") return false;
+  return stream?.isTTY === true;
+}
+function prettyFormatter(options = {}) {
+  const colors = options.colors ?? false;
+  const c = colors ? ansi : identityAnsi;
+  const styles = colors ? {
+    string: ansi.cyan,
+    number: ansi.magenta,
+    boolean: ansi.magenta,
+    null: ansi.gray,
+    name: ansi.white,
+    punctuation: ansi.gray,
+    missing: ansi.gray
+  } : void 0;
+  const timestamp = options.timestamp ?? "HH:mm:ss.fff";
+  const showExtras = options.extras ?? true;
+  const showSource = options.source ?? true;
+  return (event) => {
+    const parts = [];
+    if (timestamp) parts.push(c.dim(formatDate(event.timestamp, timestamp, options.utc)));
+    parts.push(LEVEL_STYLE[event.level] === void 0 || !colors ? formatLevel(event.level, "u3") : LEVEL_STYLE[event.level](formatLevel(event.level, "u3")));
+    const source = showSource ? event.sourceContext : void 0;
+    if (source) parts.push(c.dim(`[${source}]`));
+    parts.push(renderTemplate(event.template, event.properties, { literal: true, styles }));
+    if (showExtras) {
+      const extras = event.extraProperties();
+      const pairs = [];
+      for (const key of Object.keys(extras)) {
+        if (key === "SourceContext") continue;
+        pairs.push(`${key}=${renderValue(extras[key], void 0, { literal: true, json: true })}`);
+      }
+      if (pairs.length) parts.push(c.dim(pairs.join(" ")));
+    }
+    let line = parts.join(" ");
+    if (event.error) {
+      const block = formatError(event.error, "    ");
+      line += `
+${colors ? ansi.red(block) : block}`;
+    }
+    return line;
+  };
+}
+var identityAnsi = Object.fromEntries(Object.keys(ansi).map((key) => [key, (text) => text]));
+
+// src/format/index.ts
+function resolveFormatter(format, defaults = {}, fallback = "json") {
+  if (typeof format === "function") return format;
+  switch (format ?? fallback) {
+    case "pretty":
+      return prettyFormatter({ colors: defaults.colors, utc: defaults.utc });
+    case "text":
+      return textFormatter({ outputTemplate: defaults.outputTemplate, utc: defaults.utc });
+    case "clef":
+      return clefFormatter();
+    case "json":
+    default:
+      return jsonFormatter();
+  }
+}
+
+// src/sinks/basic.ts
+function callbackSink(fn, options = {}) {
+  return { name: "callback", emit: fn, ...options };
+}
+function memorySink(options = {}) {
+  const events = [];
+  const capacity = options.capacity ?? Infinity;
+  return {
+    name: "memory",
+    events,
+    restrictedToMinimumLevel: options.restrictedToMinimumLevel,
+    audit: options.audit,
+    emit(event) {
+      events.push(event);
+      if (events.length > capacity) events.splice(0, events.length - capacity);
+    },
+    clear() {
+      events.length = 0;
+    },
+    messages() {
+      return events.map((e) => e.renderMessage({ literal: true }));
+    }
+  };
+}
+function streamSink(stream, options = {}) {
+  const formatter = resolveFormatter(options.format, {
+    outputTemplate: options.outputTemplate,
+    colors: options.colors ?? detectColors(stream),
+    utc: options.utc
+  });
+  let pendingDrain = null;
+  return {
+    name: "stream",
+    restrictedToMinimumLevel: options.restrictedToMinimumLevel,
+    audit: options.audit,
+    emit(event) {
+      const ok = stream.write(`${formatter(event)}
+`);
+      if (ok === false && stream.once && !pendingDrain) {
+        pendingDrain = new Promise((resolve) => stream.once("drain", () => resolve())).then(() => {
+          pendingDrain = null;
+        });
+      }
+    },
+    async flush() {
+      if (pendingDrain) await pendingDrain;
+    }
+  };
+}
+
+// src/sinks/console.ts
+function nodeProcess() {
+  const proc = globalThis.process;
+  return proc && typeof proc.stdout?.write === "function" ? proc : void 0;
+}
+function consoleSink(options = {}) {
+  const proc = nodeProcess();
+  if (proc?.stdout) {
+    const colors = options.colors ?? detectColors(proc.stdout);
+    const format = options.format ?? (colors || proc.stdout.isTTY ? "pretty" : "json");
+    const out = streamSink(proc.stdout, { ...options, format, colors });
+    if (!options.stderrFrom) return { ...out, name: "console" };
+    const err = streamSink(proc.stderr ?? proc.stdout, { ...options, format, colors: options.colors ?? detectColors(proc.stderr) });
+    const threshold = parseLevel(options.stderrFrom);
+    return {
+      name: "console",
+      restrictedToMinimumLevel: options.restrictedToMinimumLevel,
+      audit: options.audit,
+      emit(event) {
+        (levelAtLeast(event.level, threshold) ? err : out).emit(event);
+      },
+      async flush() {
+        await out.flush?.();
+        await err.flush?.();
+      }
+    };
+  }
+  return browserConsoleSink(options);
+}
+var BROWSER_METHOD = {
+  verbose: "debug",
+  debug: "debug",
+  info: "info",
+  warn: "warn",
+  error: "error",
+  fatal: "error"
+};
+function browserConsoleSink(options) {
+  const isBrowser = typeof globalThis.document !== "undefined";
+  const format = options.format ?? (isBrowser ? "pretty" : "json");
+  const formatter = typeof format === "function" || format !== "pretty" ? resolveFormatter(format, { outputTemplate: options.outputTemplate, colors: false, utc: options.utc }) : null;
+  return {
+    name: "console",
+    restrictedToMinimumLevel: options.restrictedToMinimumLevel,
+    audit: options.audit,
+    emit(event) {
+      const method = BROWSER_METHOD[event.level];
+      if (formatter) {
+        console[method](formatter(event));
+        return;
+      }
+      const extras = event.extraProperties();
+      delete extras.SourceContext;
+      const args = [`${event.sourceContext ? `[${event.sourceContext}] ` : ""}${event.renderMessage({ literal: true })}`];
+      if (Object.keys(extras).length) args.push(extras);
+      if (event.error) args.push(event.error);
+      console[method](...args);
+    }
+  };
+}
+
+// src/sinks/wrappers.ts
+function restricted(sink, level) {
+  return { ...sink, emit: (e) => sink.emit(e), restrictedToMinimumLevel: level };
+}
+function conditional(predicate, sink) {
+  return {
+    name: sink.name ? `conditional(${sink.name})` : "conditional",
+    restrictedToMinimumLevel: sink.restrictedToMinimumLevel,
+    audit: sink.audit,
+    emit(event) {
+      if (predicate(event)) sink.emit(event);
+    },
+    flush: sink.flush ? () => sink.flush() : void 0,
+    close: sink.close ? () => sink.close() : void 0
+  };
+}
+function audit(sink) {
+  return { ...sink, emit: (e) => sink.emit(e), audit: true };
+}
+function mapSink(keyOf, create, options = {}) {
+  const max = options.maxSinks ?? 100;
+  const sinks = /* @__PURE__ */ new Map();
+  const closeQuietly = async (key, sink) => {
+    try {
+      await sink.close?.();
+    } catch (error) {
+      selfLog.write(`mapSink: closing sink for ${String(key)} failed`, error);
+    }
+  };
+  return {
+    name: "map",
+    restrictedToMinimumLevel: options.restrictedToMinimumLevel,
+    emit(event) {
+      const key = keyOf(event);
+      if (key === void 0) return;
+      let sink = sinks.get(key);
+      if (sink) {
+        sinks.delete(key);
+        sinks.set(key, sink);
+      } else {
+        sink = create(key);
+        sinks.set(key, sink);
+        if (sinks.size > max) {
+          const [oldestKey, oldest] = sinks.entries().next().value;
+          sinks.delete(oldestKey);
+          void closeQuietly(oldestKey, oldest);
+        }
+      }
+      sink.emit(event);
+    },
+    async flush() {
+      await Promise.all(Array.from(sinks.values(), (s) => s.flush?.()));
+    },
+    async close() {
+      const entries = Array.from(sinks.entries());
+      sinks.clear();
+      await Promise.all(entries.map(([key, sink]) => closeQuietly(key, sink)));
+    }
+  };
+}
+
+// src/sinks/batching.ts
+function batchingSink(send, options = {}) {
+  const batchSize = options.batchSize ?? 100;
+  const flushInterval = options.flushInterval ?? 2e3;
+  const maxQueue = options.maxQueue ?? 1e4;
+  const retries = Math.max(1, options.retries ?? 3);
+  const retryDelay = options.retryDelay ?? 500;
+  const name = options.name ?? "batching";
+  let queue = [];
+  let timer = null;
+  let inFlight = null;
+  let closed = false;
+  let dropped = 0;
+  const schedule = () => {
+    if (timer || closed) return;
+    timer = setTimeout(() => {
+      timer = null;
+      void drain();
+    }, flushInterval);
+    timer.unref?.();
+  };
+  const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+  async function sendWithRetry(batch) {
+    let delay = retryDelay;
+    for (let attempt = 1; ; attempt++) {
+      try {
+        await send(batch);
+        return;
+      } catch (error) {
+        if (attempt >= retries) {
+          selfLog.write(`${name}: giving up on a batch of ${batch.length} after ${attempt} attempts`, error);
+          options.onError?.(error, batch);
+          return;
+        }
+        await sleep(delay);
+        delay *= 2;
+      }
+    }
+  }
+  async function drain() {
+    if (inFlight) return inFlight;
+    inFlight = (async () => {
+      while (queue.length) {
+        const batch = queue.splice(0, batchSize);
+        await sendWithRetry(batch);
+      }
+    })().finally(() => {
+      inFlight = null;
+    });
+    return inFlight;
+  }
+  return {
+    name,
+    restrictedToMinimumLevel: options.restrictedToMinimumLevel,
+    audit: options.audit,
+    get queued() {
+      return queue.length;
+    },
+    emit(event) {
+      if (closed) return;
+      if (queue.length >= maxQueue) {
+        queue.shift();
+        if (dropped++ % 1e3 === 0) selfLog.write(`${name}: queue full (${maxQueue}), dropping oldest events`);
+      }
+      queue.push(event);
+      if (queue.length >= batchSize) void drain();
+      else schedule();
+    },
+    async flush() {
+      if (timer) {
+        clearTimeout(timer);
+        timer = null;
+      }
+      await drain();
+    },
+    async close() {
+      await this.flush();
+      closed = true;
+      queue = [];
+    }
+  };
+}
+
+// src/sinks/http.ts
+function httpSink(options) {
+  const fetchImpl = options.fetch ?? globalThis.fetch;
+  if (!fetchImpl) throw new Error("logit: httpSink needs fetch \u2014 pass one in options.fetch");
+  const mode = options.body ?? "ndjson";
+  const formatter = options.formatter ?? (mode === "clef" ? clefFormatter() : jsonFormatter());
+  const contentType = options.contentType ?? (mode === "clef" ? CLEF_MEDIA_TYPE : mode === "array" ? "application/json" : "application/x-ndjson");
+  const timeout = options.timeout ?? 1e4;
+  const encode = (events) => {
+    if (typeof mode === "function") return mode(events);
+    const lines = events.map(formatter);
+    return mode === "array" ? `[${lines.join(",")}]` : `${lines.join("\n")}
+`;
+  };
+  const sink = batchingSink(
+    async (events) => {
+      const headers = { "content-type": contentType, ...typeof options.headers === "function" ? options.headers() : options.headers };
+      const controller = typeof AbortController === "function" ? new AbortController() : void 0;
+      const timer = controller ? setTimeout(() => controller.abort(), timeout) : void 0;
+      timer?.unref?.();
+      try {
+        const response = await fetchImpl(options.url, {
+          method: "POST",
+          headers,
+          body: encode(events),
+          signal: controller?.signal,
+          keepalive: true
+        });
+        if (!response.ok) {
+          let detail = "";
+          try {
+            detail = (await response.text()).slice(0, 500);
+          } catch {
+          }
+          throw new Error(`HTTP ${response.status}${detail ? `: ${detail}` : ""}`);
+        }
+      } finally {
+        if (timer) clearTimeout(timer);
+      }
+    },
+    { name: `http(${options.url})`, ...options }
+  );
+  const win = globalThis.document ? globalThis : void 0;
+  win?.addEventListener?.("pagehide", () => {
+    void sink.flush();
+  });
+  return sink;
+}
+function seqSink(options) {
+  const { serverUrl, apiKey, headers, ...rest } = options;
+  const base = serverUrl.replace(/\/$/, "");
+  return httpSink({
+    ...rest,
+    url: `${base}/ingest/clef`,
+    body: "clef",
+    headers: () => ({
+      ...typeof headers === "function" ? headers() : headers,
+      ...apiKey ? { "X-Seq-ApiKey": apiKey } : {}
+    }),
+    name: `seq(${base})`
+  });
+}
+
+// src/logger.ts
+function envLevel() {
+  const raw = globalThis.process?.env?.LOGIT_LEVEL;
+  if (!raw) return void 0;
+  try {
+    return parseLevel(raw);
+  } catch (error) {
+    selfLog.write(`ignoring LOGIT_LEVEL="${raw}"`, error);
+    return void 0;
+  }
+}
+function envOverrides() {
+  const raw = globalThis.process?.env?.LOGIT_OVERRIDES;
+  if (!raw) return void 0;
+  const out = {};
+  for (const pair of raw.split(",")) {
+    const [source, level] = pair.split("=").map((s) => s.trim());
+    if (!source || !level) continue;
+    try {
+      out[source] = parseLevel(level);
+    } catch (error) {
+      selfLog.write(`ignoring LOGIT_OVERRIDES entry "${pair}"`, error);
+    }
+  }
+  return out;
+}
+function buildPipeline(options) {
+  const overrides = Object.entries({ ...envOverrides(), ...options.overrides }).map(([prefix, level]) => ({ prefix, level: level instanceof LevelSwitch ? level : parseLevel(level) })).sort((a, b) => b.prefix.length - a.prefix.length);
+  const enrichers = [];
+  if (options.logContext ?? true) enrichers.push(fromLogContext());
+  if (options.properties) enrichers.push(withProperties(options.properties));
+  enrichers.push(...options.enrichers ?? []);
+  const sinks = [...options.sinks ?? [], ...(options.auditSinks ?? []).map((sink) => ({ ...sink, emit: (e) => sink.emit(e), audit: true }))];
+  const minimumLevel = options.minimumLevel ?? envLevel() ?? "info";
+  return {
+    minimumLevel: minimumLevel instanceof LevelSwitch ? minimumLevel : parseLevel(minimumLevel),
+    overrides,
+    sinks,
+    enrichers,
+    filters: [...options.filters ?? []],
+    destructuring: resolveDestructuring(options.destructuring),
+    onSinkError: options.onSinkError
+  };
+}
+function matchOverride(overrides, source) {
+  for (const o of overrides) {
+    if (source === o.prefix || source.startsWith(`${o.prefix}.`)) return o.level;
+  }
+  return void 0;
+}
+function escapeTemplate(text) {
+  return text.replace(/{/g, "{{").replace(/}/g, "}}");
+}
+var Operation = class {
+  #logger;
+  #template;
+  #args;
+  #options;
+  #start;
+  #done = false;
+  #extra = {};
+  constructor(logger, template, args, options = {}) {
+    this.#logger = logger;
+    this.#template = template;
+    this.#args = args;
+    this.#options = options;
+    this.#start = now();
+  }
+  /** Milliseconds since the operation began. */
+  get elapsed() {
+    return now() - this.#start;
+  }
+  /** Adds a property to the completion event. */
+  enrich(name, value, destructure = false) {
+    this.#extra[name] = destructure ? { __destructure: value } : value;
+    return this;
+  }
+  complete(name, value) {
+    if (name !== void 0) this.enrich(name, value);
+    this.#finish("completed", void 0);
+  }
+  abandon(error) {
+    this.#finish("abandoned", error);
+  }
+  /** Ends the operation without logging anything. */
+  cancel() {
+    this.#done = true;
+  }
+  [Symbol.dispose]() {
+    if (!this.#done) this.abandon();
+  }
+  #finish(outcome, error) {
+    if (this.#done) return;
+    this.#done = true;
+    const elapsed = this.elapsed;
+    let level = outcome === "completed" ? this.#options.completeLevel ?? "info" : this.#options.abandonLevel ?? "warn";
+    if (outcome === "completed" && this.#options.warnAfter !== void 0 && elapsed > this.#options.warnAfter && levelAtLeast("warn", level)) level = "warn";
+    const props = {};
+    for (const [key, value] of Object.entries(this.#extra)) {
+      props[key] = value && typeof value === "object" && "__destructure" in value ? value.__destructure : value;
+    }
+    const logger = Object.keys(props).length ? this.#logger.forContext(props) : this.#logger;
+    const template = `${this.#template} {Outcome:l} in {Elapsed:0.0} ms`;
+    const args = [...this.#args, outcome, elapsed];
+    if (error) logger.write(level, error, template, ...args);
+    else logger.write(level, template, ...args);
+  }
+};
+function now() {
+  const perf = globalThis.performance;
+  return perf ? perf.now() : Date.now();
+}
+var Logger = class _Logger {
+  #ref;
+  #context;
+  #source;
+  #overrideFor = null;
+  #override;
+  /** @internal */
+  constructor(ref, context = null, source) {
+    this.#ref = ref;
+    this.#context = context;
+    this.#source = source;
+  }
+  name = "logger";
+  /** The `SourceContext` this logger is bound to, if any. */
+  get source() {
+    return this.#source;
+  }
+  /** The current minimum level for this logger's source. */
+  get minimumLevel() {
+    return resolveLevel(this.#effectiveMinimum());
+  }
+  #effectiveMinimum() {
+    const pipeline = this.#ref.current;
+    if (this.#source === void 0) return pipeline.minimumLevel;
+    if (this.#overrideFor !== pipeline) {
+      this.#overrideFor = pipeline;
+      this.#override = matchOverride(pipeline.overrides, this.#source);
+    }
+    return this.#override ?? pipeline.minimumLevel;
+  }
+  /** Cheap check before building anything expensive to log. */
+  isEnabled(level) {
+    return levelAtLeast(level, resolveLevel(this.#effectiveMinimum()));
+  }
+  verbose = (...args) => this.write("verbose", ...args);
+  debug = (...args) => this.write("debug", ...args);
+  info = (...args) => this.write("info", ...args);
+  warn = (...args) => this.write("warn", ...args);
+  error = (...args) => this.write("error", ...args);
+  fatal = (...args) => this.write("fatal", ...args);
+  /**
+   * Writes an event at `level`. Argument shapes:
+   *   `(template, ...args)`
+   *   `(error, template?, ...args)`
+   *   `(properties, template?, ...args)` — one-off properties on this event
+   */
+  write(level, ...args) {
+    if (!this.isEnabled(level)) return;
+    const pipeline = this.#ref.current;
+    let i = 0;
+    let error;
+    let extra;
+    if (args[0] instanceof Error) {
+      error = args[0];
+      i = 1;
+    } else if (args[0] !== null && typeof args[0] === "object" && !Array.isArray(args[0])) {
+      extra = args[0];
+      i = 1;
+    }
+    const head = args[i];
+    let raw;
+    if (typeof head === "string") raw = head;
+    else if (head === void 0) raw = error ? escapeTemplate(error.message || error.name) : "";
+    else raw = escapeTemplate(String(head));
+    const template = parseTemplate(raw);
+    const properties = {};
+    if (template.holes.length) captureArguments(template.holes, template.positional, args.slice(i + 1), pipeline.destructuring, properties);
+    const event = new LogEvent({ level, template, properties, error }, pipeline.destructuring);
+    if (extra) for (const key of Object.keys(extra)) event.addPropertyIfAbsent(key, extra[key], true);
+    this.#dispatch(event, pipeline);
+  }
+  /** Sink entry point: an event from another logger, re-dispatched through this one's level, context, enrichers, filters and sinks. */
+  emit(event) {
+    if (!this.isEnabled(event.level)) return;
+    this.#dispatch(event, this.#ref.current);
+  }
+  #dispatch(event, pipeline) {
+    if (this.#context) {
+      for (const key of Object.keys(this.#context)) {
+        if (!event.hasProperty(key)) event.properties[key] = this.#context[key];
+      }
+    }
+    if (this.#source !== void 0 && !event.hasProperty("SourceContext")) event.properties.SourceContext = this.#source;
+    for (const enricher of pipeline.enrichers) {
+      try {
+        enricher(event);
+      } catch (error) {
+        selfLog.write("an enricher threw", error);
+      }
+    }
+    for (const filter of pipeline.filters) {
+      if (!filter(event)) return;
+    }
+    for (const sink of pipeline.sinks) {
+      if (sink.restrictedToMinimumLevel !== void 0 && !levelAtLeast(event.level, resolveLevel(sink.restrictedToMinimumLevel))) continue;
+      try {
+        sink.emit(event);
+      } catch (error) {
+        if (sink.audit) throw error;
+        if (pipeline.onSinkError) pipeline.onSinkError(error, sink, event);
+        else selfLog.write(`sink ${sink.name ?? "(anonymous)"} threw`, error);
+      }
+    }
+  }
+  forContext(nameOrProps, valueOrDestructure, destructure = false) {
+    const options = this.#ref.current.destructuring;
+    const context = { ...this.#context };
+    if (typeof nameOrProps === "string") {
+      context[nameOrProps] = captureProperty(nameOrProps, valueOrDestructure, destructure ? "@" : void 0, options);
+    } else {
+      const d = valueOrDestructure === true;
+      for (const key of Object.keys(nameOrProps)) context[key] = captureProperty(key, nameOrProps[key], d ? "@" : void 0, options);
+    }
+    return new _Logger(this.#ref, context, this.#source);
+  }
+  /** A logger whose events carry `SourceContext` — the name level overrides match on. Dotted names nest: `'app.db'`. */
+  forSource(source) {
+    return new _Logger(this.#ref, this.#context, source);
+  }
+  /** pino / bunyan spelling of `forContext`. */
+  child(properties, destructure = false) {
+    return this.forContext(properties, destructure);
+  }
+  /** Starts a timed operation; `complete()` / `abandon()` log one event with `Outcome` and `Elapsed`. */
+  beginOperation(template, ...args) {
+    return new Operation(this, template, args);
+  }
+  /** `beginOperation` with options (levels, `warnAfter`). */
+  operation(options, template, ...args) {
+    return new Operation(this, template, args, options);
+  }
+  /**
+   * Runs `fn` as a timed operation: completes when it returns (or its
+   * promise resolves), abandons with the error when it throws (or rejects),
+   * then rethrows.
+   */
+  timed(template, fn, ...args) {
+    const op = new Operation(this, template, args);
+    let result;
+    try {
+      result = fn(op);
+    } catch (error) {
+      op.abandon(error instanceof Error ? error : void 0);
+      throw error;
+    }
+    if (result instanceof Promise) {
+      return result.then(
+        (value) => {
+          op.complete();
+          return value;
+        },
+        (error) => {
+          op.abandon(error instanceof Error ? error : void 0);
+          throw error;
+        }
+      );
+    }
+    op.complete();
+    return result;
+  }
+  /** Waits for every sink that buffers to send what it holds. */
+  async flush() {
+    await Promise.all(this.#ref.current.sinks.map((sink) => safely(() => sink.flush?.(), sink, "flush")));
+  }
+  /** Flushes, then closes the sinks — call once, before the process exits (Serilog's `CloseAndFlush`). */
+  async close() {
+    await this.flush();
+    await Promise.all(this.#ref.current.sinks.map((sink) => safely(() => sink.close?.(), sink, "close")));
+  }
+  /** The sinks this logger writes to. */
+  get sinks() {
+    return this.#ref.current.sinks;
+  }
+  /** @internal — swaps the pipeline for every logger sharing this ref. */
+  _replace(options) {
+    this.#ref.current = buildPipeline(options);
+  }
+};
+async function safely(fn, sink, what) {
+  try {
+    await fn();
+  } catch (error) {
+    if (sink.audit) throw error;
+    selfLog.write(`sink ${sink.name ?? "(anonymous)"} failed to ${what}`, error);
+  }
+}
+function createLogger(options = {}) {
+  const withDefaults = options.sinks || options.auditSinks ? options : { ...options, sinks: [consoleSink()] };
+  return new Logger({ current: buildPipeline(withDefaults) });
+}
+var LoggerConfiguration = class _LoggerConfiguration {
+  #options = {
+    sinks: [],
+    auditSinks: [],
+    enrichers: [],
+    filters: [],
+    overrides: {},
+    destructuring: { policies: [], redact: [] }
+  };
+  minimumLevel = {
+    verbose: () => this.minimumLevel.is("verbose"),
+    debug: () => this.minimumLevel.is("debug"),
+    info: () => this.minimumLevel.is("info"),
+    information: () => this.minimumLevel.is("info"),
+    warn: () => this.minimumLevel.is("warn"),
+    warning: () => this.minimumLevel.is("warn"),
+    error: () => this.minimumLevel.is("error"),
+    fatal: () => this.minimumLevel.is("fatal"),
+    is: (level) => {
+      this.#options.minimumLevel = level;
+      return this;
+    },
+    controlledBy: (levelSwitch) => {
+      this.#options.minimumLevel = levelSwitch;
+      return this;
+    },
+    override: (source, level) => {
+      this.#options.overrides[source] = level;
+      return this;
+    }
+  };
+  writeTo = {
+    sink: (...sinks) => {
+      this.#options.sinks.push(...sinks);
+      return this;
+    },
+    console: (options) => this.writeTo.sink(consoleSink(options)),
+    stream: (stream, options) => this.writeTo.sink(streamSink(stream, options)),
+    http: (options) => this.writeTo.sink(httpSink(options)),
+    seq: (options) => this.writeTo.sink(seqSink(options)),
+    /** A sub-logger with its own filters, enrichers and sinks (Serilog's `WriteTo.Logger`). */
+    logger: (configure2, restrictedToMinimumLevel) => {
+      const child = new _LoggerConfiguration();
+      configure2(child);
+      const sink = child.createLogger();
+      return this.writeTo.sink(restrictedToMinimumLevel ? { ...sink, emit: (e) => sink.emit(e), restrictedToMinimumLevel, flush: () => sink.flush(), close: () => sink.close() } : sink);
+    }
+  };
+  auditTo = {
+    sink: (...sinks) => {
+      this.#options.auditSinks.push(...sinks);
+      return this;
+    }
+  };
+  enrich = {
+    with: (...enrichers) => {
+      this.#options.enrichers.push(...enrichers);
+      return this;
+    },
+    fromLogContext: () => {
+      this.#options.logContext = true;
+      return this;
+    },
+    withProperty: (name, value, destructure = false) => this.enrich.with(withProperty(name, value, destructure)),
+    withProperties: (properties, destructure = false) => this.enrich.with(withProperties(properties, destructure))
+  };
+  filter = {
+    with: (...filters) => {
+      this.#options.filters.push(...filters);
+      return this;
+    },
+    byExcluding: (predicate) => this.filter.with(byExcluding(predicate)),
+    byIncludingOnly: (predicate) => this.filter.with(byIncludingOnly(predicate))
+  };
+  destructure = {
+    toMaximumDepth: (depth) => {
+      this.#options.destructuring.maxDepth = depth;
+      return this;
+    },
+    toMaximumStringLength: (length) => {
+      this.#options.destructuring.maxStringLength = length;
+      return this;
+    },
+    toMaximumCollectionCount: (count) => {
+      this.#options.destructuring.maxCollectionCount = count;
+      return this;
+    },
+    with: (...policies) => {
+      this.#options.destructuring.policies.push(...policies);
+      return this;
+    },
+    byTransforming: (type, transform) => this.destructure.with(byTransforming(type, transform)),
+    /** Keys (or dotted paths) whose values are replaced by `[Redacted]`. */
+    redact: (...keys) => {
+      this.#options.destructuring.redact.push(...keys);
+      return this;
+    }
+  };
+  readFrom = {
+    /** `LOGIT_LEVEL` and `LOGIT_OVERRIDES` from the environment (they are read by default; this makes it explicit). */
+    env: () => this
+  };
+  /** Disables the automatic `LogContext` enricher. */
+  withoutLogContext() {
+    this.#options.logContext = false;
+    return this;
+  }
+  /** The options as a plain object, for `createLogger()` or `configure()`. */
+  toOptions() {
+    return { ...this.#options };
+  }
+  createLogger() {
+    return createLogger(this.toOptions());
+  }
+};
+var globalRef = { current: buildPipeline({ sinks: [consoleSink()] }) };
+var log = new Logger(globalRef);
+function configure(options = {}) {
+  const opts = options instanceof LoggerConfiguration ? options.toOptions() : options;
+  log._replace(opts.sinks || opts.auditSinks ? opts : { ...opts, sinks: [consoleSink()] });
+  return log;
+}
+function closeAndFlush() {
+  return log.close();
+}
+
+export {
+  LEVELS,
+  LEVEL_ORDER,
+  SERILOG_LEVEL_NAMES,
+  LEVEL_CODES,
+  LEVEL_NUMBERS,
+  parseLevel,
+  isLevel,
+  levelAtLeast,
+  LevelSwitch,
+  resolveLevel,
+  parseTemplate,
+  templateHash,
+  DEFAULT_DESTRUCTURING,
+  byTransforming,
+  captureValue,
+  captureProperty,
+  captureError,
+  resolveStyles,
+  renderValue,
+  toJson,
+  jsonReplacer,
+  formatNumber,
+  isoTimestamp,
+  formatDate,
+  renderTemplate,
+  LogEvent,
+  LogContext,
+  diagnosticContext,
+  withProperty,
+  withProperties,
+  withComputed,
+  fromLogContext,
+  withEnvironment,
+  withTraceContext,
+  byExcluding,
+  byIncludingOnly,
+  Matching,
+  sampled,
+  rateLimited,
+  selfLog,
+  DEFAULT_OUTPUT_TEMPLATE,
+  formatLevel,
+  formatError,
+  textFormatter,
+  CLEF_MEDIA_TYPE,
+  clefFormatter,
+  jsonFormatter,
+  ansi,
+  detectColors,
+  prettyFormatter,
+  resolveFormatter,
+  callbackSink,
+  memorySink,
+  streamSink,
+  consoleSink,
+  restricted,
+  conditional,
+  audit,
+  mapSink,
+  batchingSink,
+  httpSink,
+  seqSink,
+  Operation,
+  Logger,
+  createLogger,
+  LoggerConfiguration,
+  log,
+  configure,
+  closeAndFlush
+};
+//# sourceMappingURL=chunk-GW7WQELF.js.map