@autter/runtime-node 1.8.0 → 1.9.1

package/dist/{chunk-37W7YYXO.cjs → chunk-FV64SIRQ.cjs}

@@ -1,8 +1,8 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class;
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class; var _class2;
 
 
 
-var _chunkMOZOUEMAcjs = require('./chunk-MOZOUEMA.cjs');
+var _chunk3P573RHAcjs = require('./chunk-3P573RHA.cjs');
 
 // ../runtime-core/dist/index.js
 var SENSITIVE_KEY_PATTERNS = [
@@ -132,8 +132,8 @@ function redactArray(value, r, state, depth) {
     state.ancestors.delete(value);
     return r.mask;
   }
-  const limit = Math.min(length, MAX_COLLECTION_ENTRIES);
-  for (let i = 0; i < limit; i += 1) {
+  const limit2 = Math.min(length, MAX_COLLECTION_ENTRIES);
+  for (let i = 0; i < limit2; i += 1) {
     let item;
     try {
       item = value[i];
@@ -143,7 +143,7 @@ function redactArray(value, r, state, depth) {
     }
     out.push(redactValue(item, r, state, depth + 1));
   }
-  if (length > limit) {
+  if (length > limit2) {
     out.push(r.mask);
   }
   state.ancestors.delete(value);
@@ -392,6 +392,53 @@ function toSpanAttributes(context) {
     ])
   );
 }
+var DEBUG_IDS_ATTRIBUTE = "autter.debug_ids";
+var REGISTRY = "_autterDebugIds";
+var pathOfKey = /* @__PURE__ */ new Map();
+function withoutPosition(location) {
+  const match = /^(.*?):\d+:\d+$/.exec(location.trim());
+  return _optionalChain([match, 'optionalAccess', _6 => _6[1]]) ? match[1] : null;
+}
+function firstFramePath(stack) {
+  for (const raw of stack.split("\n")) {
+    const line = raw.trim();
+    if (line.startsWith("at ")) {
+      const body = line.slice(3).trim();
+      const withFn = /^(.*?)\s+\((.*)\)$/.exec(body);
+      const path = withoutPosition(withFn ? withFn[2] : body.replace(/^async /, ""));
+      if (path) return path;
+      continue;
+    }
+    const at = line.lastIndexOf("@");
+    if (at >= 0) {
+      const path = withoutPosition(line.slice(at + 1));
+      if (path) return path;
+    }
+  }
+  return null;
+}
+function debugIdsForStacks(stacks) {
+  try {
+    const registry = globalThis[REGISTRY];
+    if (!registry || typeof registry !== "object") return void 0;
+    const texts = stacks.filter((stack) => typeof stack === "string" && stack !== "");
+    if (texts.length === 0) return void 0;
+    let found;
+    for (const key of Object.keys(registry)) {
+      const id = registry[key];
+      if (typeof id !== "string" || !id) continue;
+      let path = pathOfKey.get(key);
+      if (path === void 0) {
+        path = firstFramePath(key);
+        pathOfKey.set(key, path);
+      }
+      if (path && texts.some((stack) => stack.includes(path))) (found ??= {})[path] = id;
+    }
+    return found;
+  } catch (e9) {
+    return void 0;
+  }
+}
 var CODE_PATTERN = /^[a-z][a-z0-9_]*(\.[a-z0-9_]+){0,3}$/;
 var CODE_MAX_LENGTH = 80;
 var WHY_MAX = 1e3;
@@ -410,7 +457,7 @@ function warnInvalidCode(code) {
     console.warn(
       `[autter-runtime] error code ${JSON.stringify(key)} does not match ${CODE_PATTERN} (max ${CODE_MAX_LENGTH} chars); it is dropped and the error groups by message`
     );
-  } catch (e9) {
+  } catch (e10) {
   }
 }
 var RuntimeError = class extends Error {
@@ -459,13 +506,13 @@ function defineRuntimeErrors(namespace, catalog) {
     const build = (definition, extras) => {
       const error = new RuntimeError({
         ...definition,
-        ..._optionalChain([extras, 'optionalAccess', _6 => _6.message]) !== void 0 ? { message: extras.message } : {},
+        ..._optionalChain([extras, 'optionalAccess', _7 => _7.message]) !== void 0 ? { message: extras.message } : {},
         ...valid ? { code } : {},
-        ..._optionalChain([extras, 'optionalAccess', _7 => _7.cause]) !== void 0 ? { cause: extras.cause } : {},
-        ..._optionalChain([extras, 'optionalAccess', _8 => _8.internal]) !== void 0 ? { internal: extras.internal } : {}
+        ..._optionalChain([extras, 'optionalAccess', _8 => _8.cause]) !== void 0 ? { cause: extras.cause } : {},
+        ..._optionalChain([extras, 'optionalAccess', _9 => _9.internal]) !== void 0 ? { internal: extras.internal } : {}
       });
       const captureStackTrace = Error.captureStackTrace;
-      _optionalChain([captureStackTrace, 'optionalCall', _9 => _9(error, factory)]);
+      _optionalChain([captureStackTrace, 'optionalCall', _10 => _10(error, factory)]);
       return error;
     };
     const factory = typeof entry === "function" ? (args, extras) => build(entry(args), extras) : (extras) => build(entry, extras);
@@ -481,7 +528,7 @@ function isError(value) {
     const native = Error.isError;
     if (typeof native === "function") return native(value) === true;
     return Object.prototype.toString.call(value) === "[object Error]";
-  } catch (e10) {
+  } catch (e11) {
     return false;
   }
 }
@@ -495,7 +542,7 @@ function field(err, key) {
   if (!err || typeof err !== "object") return void 0;
   try {
     return err[key];
-  } catch (e11) {
+  } catch (e12) {
     return void 0;
   }
 }
@@ -514,6 +561,13 @@ function errorStatusOf(err) {
 function isExpectedError(err) {
   return field(err, "expected") === true;
 }
+var STACK_ATTRIBUTE_RE = /^exception\.cause\.\d+\.stacktrace$|^autter\.debug_ids$/;
+function stackAttributesLast(attributes) {
+  const head = {};
+  const tail = {};
+  for (const [key, value] of Object.entries(attributes)) (STACK_ATTRIBUTE_RE.test(key) ? tail : head)[key] = value;
+  return { ...head, ...tail };
+}
 function errorAttributes(err, options = {}) {
   const out = {};
   if (!err || typeof err !== "object") return out;
@@ -530,21 +584,33 @@ function errorAttributes(err, options = {}) {
   const expected = field(err, "expected");
   if (typeof expected === "boolean") out["autter.error.expected"] = expected;
   if (options.causes !== false) {
+    const stacks = options.stacks !== false;
+    const ownStack = field(err, "stack");
+    const allStacks = typeof ownStack === "string" && ownStack ? [ownStack] : [];
     let cause = field(err, "cause");
     const seen = /* @__PURE__ */ new Set([err]);
     for (let n = 1; n <= CAUSE_DEPTH && cause !== void 0 && cause !== null; n++) {
       if (seen.has(cause)) break;
       seen.add(cause);
       const isError2 = typeof cause === "object";
-      const type = isError2 ? String(_nullishCoalesce(_nullishCoalesce(field(cause, "name"), () => ( _optionalChain([cause, 'access', _10 => _10.constructor, 'optionalAccess', _11 => _11.name]))), () => ( "Error"))) : typeof cause;
+      const type = isError2 ? String(_nullishCoalesce(_nullishCoalesce(field(cause, "name"), () => ( _optionalChain([cause, 'access', _11 => _11.constructor, 'optionalAccess', _12 => _12.name]))), () => ( "Error"))) : typeof cause;
       const message = isError2 ? field(cause, "message") : cause;
       out[`exception.cause.${n}.type`] = type.slice(0, 200);
       out[`exception.cause.${n}.message`] = String(_nullishCoalesce(message, () => ( ""))).slice(0, 1e3);
       const causeCode = field(cause, "code");
       if (typeof causeCode === "string" && causeCode)
         out[`exception.cause.${n}.code`] = causeCode.slice(0, CODE_MAX_LENGTH);
+      const causeStack = isError2 ? field(cause, "stack") : void 0;
+      if (stacks && typeof causeStack === "string" && causeStack) {
+        out[`exception.cause.${n}.stacktrace`] = causeStack;
+        allStacks.push(causeStack);
+      }
       cause = isError2 ? field(cause, "cause") : void 0;
     }
+    if (stacks) {
+      const ids = debugIdsForStacks(allStacks);
+      if (ids) out[DEBUG_IDS_ATTRIBUTE] = JSON.stringify(ids);
+    }
   }
   return out;
 }
@@ -712,7 +778,7 @@ var REQUEST_ID_PATTERN = /^[\w.-]{8,128}$/;
 var DEFAULT_REQUEST_ID_HEADER = "x-request-id";
 function randomId() {
   const c = globalThis.crypto;
-  if (_optionalChain([c, 'optionalAccess', _12 => _12.randomUUID])) return c.randomUUID();
+  if (_optionalChain([c, 'optionalAccess', _13 => _13.randomUUID])) return c.randomUUID();
   return "10000000-1000-4000-8000-100000000000".replace(
     /[018]/g,
     (d) => (Number(d) ^ Math.random() * 16 >> Number(d) / 4).toString(16)
@@ -758,6 +824,7 @@ function requestOutcome(input) {
   if (input.error !== void 0 && isExpectedError(input.error)) return "degraded";
   if (input.thrown || input.status !== void 0 && input.status >= 500)
     return "failed";
+  if (input.degraded) return "degraded";
   if (input.aborted) return "cancelled";
   return "succeeded";
 }
@@ -791,7 +858,7 @@ function parseCarrier(input) {
     if (value.length > 1024) return null;
     try {
       value = JSON.parse(value);
-    } catch (e12) {
+    } catch (e13) {
       return null;
     }
   }
@@ -900,7 +967,7 @@ function normalizeBreadcrumb(input, redact3, options = {}) {
       message: scrubber(redact3)(message, MAX_MESSAGE),
       ...data ? { data } : {}
     };
-  } catch (e13) {
+  } catch (e14) {
     return null;
   }
 }
@@ -913,7 +980,7 @@ function sanitizeBreadcrumbs(raw, redact3) {
       const crumb = normalizeBreadcrumb(raw[i], redact3, { requireAt: true });
       if (crumb) out.push(crumb);
     }
-  } catch (e14) {
+  } catch (e15) {
   }
   return out.length ? out.reverse() : void 0;
 }
@@ -974,6 +1041,132 @@ function splitFingerprint(attributes) {
   const { fingerprint, ...rest } = attributes;
   return { attributes: rest, fingerprint };
 }
+var HANDLED_ATTRIBUTE = "autter.handled";
+var HANDLING_ATTRIBUTE = "autter.handling";
+var LOG_SOURCE_ATTRIBUTE = "autter.log.source";
+var LOG_MESSAGE_ATTRIBUTE = "autter.log.message";
+var DEGRADED_REASON_ATTRIBUTE = "autter.degraded.reason";
+var CAUGHT_DROPPED_ATTRIBUTE = "autter.caught.dropped";
+var LOG_MESSAGE_MAX = 1e3;
+var DEGRADED_REASON_MAX = 500;
+var CAUGHT_BURST = 10;
+var CAUGHT_REFILL_MS = 1e4;
+var SOURCES = ["console", "pino", "winston", "bunyan", "runtimeLogger"];
+function loggedErrorSources(option) {
+  const out = {};
+  for (const source of SOURCES)
+    out[source] = option === false ? false : option === void 0 || option === true || typeof option !== "object" ? true : option[source] !== false;
+  return out;
+}
+function handledErrorKind(error) {
+  let type = "Error";
+  let site = "";
+  try {
+    if (isError(error)) {
+      type = String(error.name || "Error").slice(0, 200);
+      const lines = String(_nullishCoalesce(error.stack, () => ( ""))).split("\n");
+      site = (_nullishCoalesce(_nullishCoalesce(lines.find((line) => /^\s*at\s/.test(line)), () => ( lines[1])), () => ( ""))).trim().slice(0, 300);
+    }
+  } catch (e16) {
+  }
+  return { key: `${type}
+${site}`, type };
+}
+function caughtErrorAttributes(source, message, dropped = 0) {
+  return {
+    [HANDLED_ATTRIBUTE]: true,
+    [HANDLING_ATTRIBUTE]: "caught",
+    [LOG_SOURCE_ATTRIBUTE]: source,
+    ...message ? { [LOG_MESSAGE_ATTRIBUTE]: message.slice(0, LOG_MESSAGE_MAX) } : {},
+    ...dropped > 0 ? { [CAUGHT_DROPPED_ATTRIBUTE]: dropped } : {}
+  };
+}
+function degradedAttributes(reason, dropped = 0) {
+  let text = "";
+  try {
+    text = String(_nullishCoalesce(reason, () => ( "")));
+  } catch (e17) {
+  }
+  return {
+    [HANDLED_ATTRIBUTE]: true,
+    [HANDLING_ATTRIBUTE]: "deliberate",
+    [DEGRADED_REASON_ATTRIBUTE]: text.slice(0, DEGRADED_REASON_MAX) || "degraded",
+    ...dropped > 0 ? { [CAUGHT_DROPPED_ATTRIBUTE]: dropped } : {}
+  };
+}
+var BurstLimiter = (_class2 = class {
+  constructor(burst = CAUGHT_BURST, refillMs = CAUGHT_REFILL_MS, maxKeys = 1e3) {;_class2.prototype.__init2.call(this);_class2.prototype.__init3.call(this);
+    this.burst = burst;
+    this.refillMs = refillMs;
+    this.maxKeys = maxKeys;
+  }
+  
+  
+  
+  __init2() {this.buckets = /* @__PURE__ */ new Map()}
+  __init3() {this.evicted = []}
+  /**
+   * -1 when the record is left out (and counted). Otherwise it is sent,
+   * and the number of its kind left out since the last one sent is
+   * returned, to report with it.
+   */
+  take(key, type, now = Date.now()) {
+    const bucket = _nullishCoalesce(this.buckets.get(key), () => ( { tokens: this.burst, at: now, dropped: 0, type }));
+    this.buckets.delete(key);
+    this.buckets.set(key, bucket);
+    this.refill(bucket, now);
+    let result;
+    if (bucket.tokens < 1) {
+      bucket.dropped += 1;
+      result = -1;
+    } else {
+      bucket.tokens -= 1;
+      result = bucket.dropped;
+      bucket.dropped = 0;
+    }
+    while (this.buckets.size > this.maxKeys) {
+      const oldest = this.buckets.keys().next().value;
+      const gone = this.buckets.get(oldest);
+      this.buckets.delete(oldest);
+      if (gone.dropped > 0) this.evicted.push({ key: oldest, type: gone.type, dropped: gone.dropped });
+    }
+    return result;
+  }
+  /**
+   * Counts no sent record carried: kinds that have a token again (nothing
+   * of theirs came along to carry the count) or, with `all`, every kind
+   * with a count. The counts returned are reset.
+   */
+  drain(now = Date.now(), all = false) {
+    const out = this.evicted;
+    this.evicted = [];
+    for (const [key, bucket] of this.buckets) {
+      if (bucket.dropped === 0) continue;
+      this.refill(bucket, now);
+      if (!all && bucket.tokens < 1) continue;
+      out.push({ key, type: bucket.type, dropped: bucket.dropped });
+      bucket.dropped = 0;
+    }
+    return out;
+  }
+  /** When the next uncarried count can be drained, or null when none is pending. */
+  nextDrainAt() {
+    if (this.evicted.length) return 0;
+    let next = null;
+    for (const bucket of this.buckets.values()) {
+      if (bucket.dropped === 0) continue;
+      const at = bucket.at + Math.max(0, 1 - bucket.tokens) * this.refillMs;
+      if (next === null || at < next) next = at;
+    }
+    return next;
+  }
+  refill(bucket, now) {
+    if (now > bucket.at) {
+      bucket.tokens = Math.min(this.burst, bucket.tokens + (now - bucket.at) / this.refillMs);
+      bucket.at = now;
+    }
+  }
+}, _class2);
 function testPattern(pattern, type, message) {
   if (typeof pattern === "string") {
     return pattern !== "" && (message.includes(pattern) || type.includes(pattern));
@@ -983,11 +1176,11 @@ function testPattern(pattern, type, message) {
   return re.test(message) || type !== "" && (re.test(type) || re.test(`${type}: ${message}`));
 }
 function isIgnoredError(patterns, type, message) {
-  if (!_optionalChain([patterns, 'optionalAccess', _13 => _13.length])) return false;
+  if (!_optionalChain([patterns, 'optionalAccess', _14 => _14.length])) return false;
   for (const pattern of patterns) {
     try {
       if (testPattern(pattern, type, message)) return true;
-    } catch (e15) {
+    } catch (e18) {
     }
   }
   return false;
@@ -1006,7 +1199,7 @@ function createErrorFilter(options = {}, random = Math.random) {
       const severity = _nullishCoalesce(input.severity, () => ( "error"));
       if (severity !== "error") return true;
       return random() < rate;
-    } catch (e16) {
+    } catch (e19) {
       return true;
     }
   };
@@ -1022,6 +1215,267 @@ var _crypto = require('crypto');
 
 
 
+// src/caught-errors.ts
+var _module = require('module');
+var _path = require('path');
+var _util = require('util');
+var _requireinthemiddle = require('require-in-the-middle');
+
+// src/captured.ts
+var CAPTURED = _chunk3P573RHAcjs.sharedSlot.call(void 0, "requests", () => ({ captured: /* @__PURE__ */ new WeakSet() })).captured;
+function markCaptured(error) {
+  if (error && typeof error === "object") CAPTURED.add(error);
+}
+function isCaptured(error) {
+  return !!error && typeof error === "object" && CAPTURED.has(error);
+}
+
+// src/caught-errors.ts
+var S = _chunk3P573RHAcjs.sharedSlot.call(void 0, "handled", () => ({
+  sources: null,
+  capture: null,
+  tail: null,
+  limiter: new BurstLimiter(),
+  decided: /* @__PURE__ */ new WeakSet(),
+  timer: null,
+  hooked: false
+}));
+var PATCHED = /* @__PURE__ */ Symbol.for("autter.runtime.logged-errors");
+function setHandledCapture(capture) {
+  S.capture = capture;
+}
+function setHandledTail(tail) {
+  S.tail = tail;
+}
+function scheduleTail() {
+  if (S.timer) return;
+  const at = S.limiter.nextDrainAt();
+  if (at === null) return;
+  S.timer = setTimeout(() => sendTails(false), Math.max(0, at - Date.now()) + 5);
+  _optionalChain([S, 'access', _15 => _15.timer, 'access', _16 => _16.unref, 'optionalCall', _17 => _17()]);
+}
+function sendTails(all) {
+  if (S.timer) clearTimeout(S.timer);
+  S.timer = null;
+  for (const tail of S.limiter.drain(Date.now(), all)) {
+    try {
+      _optionalChain([S, 'access', _18 => _18.tail, 'optionalCall', _19 => _19(tail.type, tail.dropped)]);
+    } catch (e20) {
+    }
+  }
+  if (!all) scheduleTail();
+}
+function limit(prefix, error) {
+  const kind = handledErrorKind(error);
+  const dropped = S.limiter.take(`${prefix}
+${kind.key}`, kind.type);
+  if (dropped < 0) scheduleTail();
+  return dropped;
+}
+function reportLoggedError(error, source, message, attributes) {
+  if (!_optionalChain([S, 'access', _20 => _20.sources, 'optionalAccess', _21 => _21[source]]) || !isError(error)) return;
+  if (S.decided.has(error) || isCaptured(error)) return;
+  S.decided.add(error);
+  const run = () => {
+    try {
+      if (isCaptured(error) || !S.capture || !S.sources) return;
+      const dropped = limit("caught", error);
+      if (dropped < 0) return;
+      markCaptured(error);
+      S.capture(error, { ...attributes, ...caughtErrorAttributes(source, message, dropped) }, "error");
+    } catch (e21) {
+    }
+  };
+  try {
+    setImmediate(run);
+  } catch (e22) {
+  }
+}
+function reportDegraded(error, reason, attributes) {
+  if (!S.capture) return;
+  if (error && typeof error === "object") S.decided.add(error);
+  const dropped = limit("deliberate", error);
+  if (dropped < 0) return;
+  markCaptured(error);
+  S.capture(error, { ...attributes, ...degradedAttributes(reason, dropped) }, "warning");
+}
+function onConsoleError(args) {
+  if (!_optionalChain([S, 'access', _22 => _22.sources, 'optionalAccess', _23 => _23.console])) return;
+  if (typeof args[0] === "string" && args[0].startsWith("[autter")) return;
+  for (const arg of args) {
+    if (!isError(arg)) continue;
+    let message = "";
+    try {
+      message = _util.format.call(void 0, ...args.filter((other) => other !== arg));
+    } catch (e23) {
+    }
+    reportLoggedError(arg, "console", message);
+  }
+}
+function patchConsole() {
+  const target = console;
+  try {
+    if (target[PATCHED]) return;
+    const original = target.error;
+    if (typeof original !== "function") return;
+    target.error = function(...args) {
+      try {
+        onConsoleError(args);
+      } catch (e24) {
+      }
+      return original.apply(this, args);
+    };
+    Object.defineProperty(target, PATCHED, { value: true });
+  } catch (e25) {
+  }
+}
+function errorField(value) {
+  if (!value || typeof value !== "object") return void 0;
+  const record = value;
+  for (const key of ["err", "error"]) if (isError(record[key])) return record[key];
+  let seen = 0;
+  for (const key of Object.keys(record)) {
+    if (++seen > 20) break;
+    if (isError(record[key])) return record[key];
+  }
+  return void 0;
+}
+function wrapMethod(target, key, inspect) {
+  const original = target[key];
+  if (typeof original !== "function") return;
+  target[key] = function(...args) {
+    try {
+      inspect(this, args);
+    } catch (e26) {
+    }
+    return original.apply(this, args);
+  };
+}
+function markPatched(target) {
+  const record = target;
+  if (record[PATCHED]) return false;
+  try {
+    Object.defineProperty(target, PATCHED, { value: true });
+    return true;
+  } catch (e27) {
+    return false;
+  }
+}
+function patchPino(protoFactory) {
+  if (typeof protoFactory !== "function") return;
+  const proto = Object.getPrototypeOf(protoFactory());
+  if (!proto) return;
+  const write = Object.getOwnPropertySymbols(proto).find((symbol) => symbol.description === "pino.write");
+  if (!write || typeof proto[write] !== "function" || !markPatched(proto)) return;
+  wrapMethod(proto, write, (_self, [obj, msg, level]) => {
+    if (!_optionalChain([S, 'access', _24 => _24.sources, 'optionalAccess', _25 => _25.pino]) || typeof level !== "number" || level < 50) return;
+    const error = isError(obj) ? obj : errorField(obj);
+    if (error) reportLoggedError(error, "pino", typeof msg === "string" ? msg : void 0);
+  });
+}
+var WINSTON_ERROR_LEVELS = /^(?:error|fatal|crit|alert|emerg)$/;
+function winstonErrorLevel(logger, level) {
+  if (typeof level !== "string") return false;
+  const levels = _optionalChain([logger, 'optionalAccess', _26 => _26.levels]);
+  if (levels && typeof levels[level] === "number" && typeof levels.error === "number")
+    return levels[level] <= levels.error;
+  return WINSTON_ERROR_LEVELS.test(level);
+}
+function patchWinston(Logger) {
+  const proto = _optionalChain([Logger, 'optionalAccess', _27 => _27.prototype]);
+  if (!proto || typeof proto.log !== "function" || !markPatched(proto)) return;
+  wrapMethod(proto, "log", (self, [level, msg, ...meta]) => {
+    if (!_optionalChain([S, 'access', _28 => _28.sources, 'optionalAccess', _29 => _29.winston]) || !winstonErrorLevel(self, level)) return;
+    for (const arg of [msg, ...meta]) {
+      const error = isError(arg) ? arg : errorField(arg);
+      if (error) reportLoggedError(error, "winston", typeof msg === "string" ? msg : void 0);
+    }
+  });
+  wrapMethod(proto, "_addDefaultMeta", (self, [info]) => {
+    if (!_optionalChain([S, 'access', _30 => _30.sources, 'optionalAccess', _31 => _31.winston]) || !info || typeof info !== "object") return;
+    if (!winstonErrorLevel(self, info.level)) return;
+    if (isError(info)) reportLoggedError(info, "winston");
+    else {
+      const error = errorField(info);
+      const message = info.message;
+      if (error) reportLoggedError(error, "winston", typeof message === "string" ? message : void 0);
+    }
+  });
+}
+function patchBunyan(Logger) {
+  const proto = _optionalChain([Logger, 'optionalAccess', _32 => _32.prototype]);
+  if (!proto || typeof proto.error !== "function" || !markPatched(proto)) return;
+  for (const [method, level] of [["error", 50], ["fatal", 60]]) {
+    wrapMethod(proto, method, (self, args) => {
+      if (!_optionalChain([S, 'access', _33 => _33.sources, 'optionalAccess', _34 => _34.bunyan]) || args.length === 0) return;
+      const min = _optionalChain([self, 'optionalAccess', _35 => _35._level]);
+      if (typeof min === "number" && min > level) return;
+      const error = isError(args[0]) ? args[0] : errorField(args[0]);
+      if (!error) return;
+      let message = "";
+      try {
+        message = _util.format.call(void 0, ...args.slice(1));
+      } catch (e28) {
+      }
+      reportLoggedError(error, "bunyan", message);
+    });
+  }
+}
+var TARGETS = [
+  { file: "pino/lib/proto.js", patch: patchPino },
+  { file: "winston/lib/winston/logger.js", patch: patchWinston },
+  { file: "bunyan/lib/bunyan.js", patch: patchBunyan }
+];
+function patchModule(file, exports) {
+  const target = TARGETS.find((entry) => entry.file === file);
+  if (!target) return;
+  try {
+    target.patch(exports);
+  } catch (e29) {
+  }
+}
+function scanModuleCache() {
+  try {
+    const cache = _module.createRequire.call(void 0, _path.join.call(void 0, process.cwd(), "autter-runtime-loggers.cjs")).cache;
+    for (const [key, entry] of Object.entries(cache)) {
+      const path = key.replace(/\\/g, "/");
+      for (const target of TARGETS)
+        if (path.endsWith(`/node_modules/${target.file}`)) patchModule(target.file, _optionalChain([entry, 'optionalAccess', _36 => _36.exports]));
+    }
+  } catch (e30) {
+  }
+}
+function hookLaterLoads() {
+  if (S.hooked) return;
+  S.hooked = true;
+  try {
+    new (0, _requireinthemiddle.Hook)(["pino", "winston", "bunyan"], { internals: true }, (exports, name) => {
+      const file = name.replace(/\\/g, "/");
+      patchModule(file === "bunyan" ? "bunyan/lib/bunyan.js" : file, exports);
+      return exports;
+    });
+  } catch (e31) {
+  }
+  for (const delay of [0, 1e3, 1e4]) {
+    const timer = setTimeout(scanModuleCache, delay);
+    _optionalChain([timer, 'access', _37 => _37.unref, 'optionalCall', _38 => _38()]);
+  }
+}
+function startLoggedErrorCapture(option) {
+  const sources = loggedErrorSources(option);
+  S.sources = sources;
+  if (!Object.values(sources).some(Boolean)) return;
+  if (sources.console) patchConsole();
+  if (sources.pino || sources.winston || sources.bunyan) {
+    scanModuleCache();
+    hookLaterLoads();
+  }
+}
+function stopLoggedErrorCapture() {
+  S.sources = null;
+  sendTails(true);
+}
+
 // src/sinks.ts
 
 
@@ -1030,8 +1484,8 @@ var _crypto = require('crypto');
 
 
 var _fs = require('fs');
-var _path = require('path');
-var sinkStats = _chunkMOZOUEMAcjs.sharedSlot.call(void 0, "sinks", () => ({ dropped: 0 }));
+
+var sinkStats = _chunk3P573RHAcjs.sharedSlot.call(void 0, "sinks", () => ({ dropped: 0 }));
 function otlpSink(options = {}) {
   let context = null;
   let queue = [];
@@ -1042,6 +1496,7 @@ function otlpSink(options = {}) {
   let flushing = null;
   let stopping = false;
   let failureStreak = 0;
+  let nextFlushAfter = 0;
   const scheduleFlush = () => {
     if (!timer && context && !stopping && queue.length) {
       timer = setTimeout(
@@ -1050,7 +1505,7 @@ function otlpSink(options = {}) {
           void flush().catch(() => {
           });
         },
-        Math.min(3e4, 2e3 * 2 ** Math.min(failureStreak, 4))
+        Math.max(nextFlushAfter, Math.min(3e4, 2e3 * 2 ** Math.min(failureStreak, 4)))
       );
       timer.unref();
     }
@@ -1093,6 +1548,7 @@ function otlpSink(options = {}) {
         );
         let failure;
         for (let attempt = 0; attempt < 3; attempt++) {
+          let retryAfter = null;
           try {
             if (Date.now() >= deadline)
               throw new Error("Runtime log flush exceeded 10 seconds");
@@ -1107,14 +1563,23 @@ function otlpSink(options = {}) {
                 Math.max(1, Math.min(3e3, deadline - Date.now()))
               )
             });
-            _chunkMOZOUEMAcjs.observeIngesterResponse.call(void 0, { status: response.status, headers: response.headers, route: "/v1/logs" });
-            if (!response.ok)
-              throw new Error(`Runtime log export failed (${response.status})`);
-            failure = void 0;
-            break;
+            _chunk3P573RHAcjs.observeIngesterResponse.call(void 0, { status: response.status, headers: response.headers, route: "/v1/logs" });
+            if (!response.ok) {
+              failure = new Error(`Runtime log export failed (${response.status})`);
+              if (response.status !== 429 && response.status < 500) break;
+              retryAfter = response.headers.get("retry-after");
+            } else {
+              failure = void 0;
+              break;
+            }
           } catch (error) {
             failure = error;
           }
+          const seconds = Number(retryAfter);
+          const wait = seconds > 0 ? Math.min(seconds * 1e3, 3e5) : 500 * 2 ** attempt;
+          nextFlushAfter = Math.max(nextFlushAfter, wait);
+          if (attempt >= 2 || Date.now() + wait >= deadline) break;
+          await new Promise((resolve2) => setTimeout(resolve2, wait));
         }
         inFlight = 0;
         if (failure) {
@@ -1126,6 +1591,7 @@ function otlpSink(options = {}) {
         }
         inFlightBytes = 0;
         failureStreak = 0;
+        nextFlushAfter = 0;
       }
     })().finally(() => {
       flushing = null;
@@ -1157,7 +1623,7 @@ function otlpSink(options = {}) {
       }
       queue.push({ record, bytes });
       queueBytes += bytes;
-      _chunkMOZOUEMAcjs.noteCompatFeature.call(void 0, "operation_logging");
+      _chunk3P573RHAcjs.noteCompatFeature.call(void 0, "operation_logging");
       scheduleFlush();
     },
     flush,
@@ -1284,14 +1750,14 @@ function formatPretty(event, color = false) {
   return lines.join("\n");
 }
 function consoleSink(options = {}) {
-  const format = _nullishCoalesce(options.format, () => ( (process.env.NODE_ENV === "production" ? "json" : "pretty")));
-  const color = _nullishCoalesce(options.color, () => ( (_optionalChain([process, 'access', _14 => _14.stdout, 'optionalAccess', _15 => _15.isTTY]) === true && !process.env.NO_COLOR)));
+  const format2 = _nullishCoalesce(options.format, () => ( (process.env.NODE_ENV === "production" ? "json" : "pretty")));
+  const color = _nullishCoalesce(options.color, () => ( (_optionalChain([process, 'access', _39 => _39.stdout, 'optionalAccess', _40 => _40.isTTY]) === true && !process.env.NO_COLOR)));
   const write = _nullishCoalesce(options.write, () => ( ((line) => console.log(line))));
   return {
     name: "console",
     write(event) {
       write(
-        format === "json" ? JSON.stringify({
+        format2 === "json" ? JSON.stringify({
           ...event.attributes,
           level: event.level,
           message: event.message
@@ -1330,14 +1796,14 @@ function fileSink(options = {}) {
     index = sameDay.length ? sameDay[sameDay.length - 1].index : 0;
     try {
       currentBytes = _fs.statSync.call(void 0, _path.join.call(void 0, dir, fileName(day, index))).size;
-    } catch (e17) {
+    } catch (e32) {
       currentBytes = 0;
     }
     prune();
   };
   const disable = (error) => {
     disabled = true;
-    const code = _nullishCoalesce(_optionalChain([error, 'optionalAccess', _16 => _16.code]), () => ( "error"));
+    const code = _nullishCoalesce(_optionalChain([error, 'optionalAccess', _41 => _41.code]), () => ( "error"));
     console.warn(
       `[autter-runtime] local runtime files disabled (${code} writing ${dir}); set logging.file: false to silence`
     );
@@ -1400,7 +1866,7 @@ function memorySink() {
 }
 
 // src/logger.ts
-var shared = _chunkMOZOUEMAcjs.sharedSlot.call(void 0, "logger", () => ({
+var shared = _chunk3P573RHAcjs.sharedSlot.call(void 0, "logger", () => ({
   local: new (0, _async_hooks.AsyncLocalStorage)(),
   config: null,
   sinks: [],
@@ -1410,7 +1876,7 @@ var local = shared.local;
 var extraSinks = shared.extraSinks;
 var fallbackConsole = null;
 function redact(attributes) {
-  return _nullishCoalesce(_optionalChain([shared, 'access', _17 => _17.config, 'optionalAccess', _18 => _18.redact, 'call', _19 => _19(attributes)]), () => ( redactAttributes(attributes)));
+  return _nullishCoalesce(_optionalChain([shared, 'access', _42 => _42.config, 'optionalAccess', _43 => _43.redact, 'call', _44 => _44(attributes)]), () => ( redactAttributes(attributes)));
 }
 var safe = (attributes = {}) => boundContext(attributes, redact);
 var merge = (current, next) => mergeContext(current, next, redact);
@@ -1449,12 +1915,12 @@ function traceAttributes(state) {
 }
 function emit(level, message, attributes, extra = {}, options = {}) {
   const state = options.state !== void 0 ? _nullishCoalesce(options.state, () => ( void 0)) : local.getStore();
-  if (_optionalChain([state, 'optionalAccess', _20 => _20.sealed])) return;
+  if (_optionalChain([state, 'optionalAccess', _45 => _45.sealed])) return;
   const summary = extra["autter.event.type"] === "operation";
   if (!summary) recordLogBreadcrumb(level, message, attributes, state);
-  if (!summary && LEVEL_SEVERITY[level] < LEVEL_SEVERITY[_nullishCoalesce(_optionalChain([shared, 'access', _21 => _21.config, 'optionalAccess', _22 => _22.options, 'optionalAccess', _23 => _23.minLevel]), () => ( "debug"))])
+  if (!summary && LEVEL_SEVERITY[level] < LEVEL_SEVERITY[_nullishCoalesce(_optionalChain([shared, 'access', _46 => _46.config, 'optionalAccess', _47 => _47.options, 'optionalAccess', _48 => _48.minLevel]), () => ( "debug"))])
     return;
-  if (!summary && state && _optionalChain([shared, 'access', _24 => _24.config, 'optionalAccess', _25 => _25.options, 'optionalAccess', _26 => _26.inline]) !== false) {
+  if (!summary && state && _optionalChain([shared, 'access', _49 => _49.config, 'optionalAccess', _50 => _50.options, 'optionalAccess', _51 => _51.inline]) !== false) {
     const { "exception.stacktrace": _stack, ...inlineAttrs } = userContext(
       attributes,
       redact
@@ -1462,20 +1928,20 @@ function emit(level, message, attributes, extra = {}, options = {}) {
     appendInlineLog(state.inline, level, message, inlineAttrs, redact);
     if (level === "debug" || level === "info") return;
   }
-  const span = _nullishCoalesce(options.span, () => ( _optionalChain([_api.trace, 'access', _27 => _27.getActiveSpan, 'call', _28 => _28(), 'optionalAccess', _29 => _29.spanContext, 'call', _30 => _30()])));
-  const user = merge(_nullishCoalesce(_optionalChain([state, 'optionalAccess', _31 => _31.attributes]), () => ( {})), attributes);
+  const span = _nullishCoalesce(options.span, () => ( _optionalChain([_api.trace, 'access', _52 => _52.getActiveSpan, 'call', _53 => _53(), 'optionalAccess', _54 => _54.spanContext, 'call', _55 => _55()])));
+  const user = merge(_nullishCoalesce(_optionalChain([state, 'optionalAccess', _56 => _56.attributes]), () => ( {})), attributes);
   const exceptions = Object.fromEntries(
     Object.entries(user).filter(([key]) => key.startsWith("exception."))
   );
-  const raw = {
+  const raw = stackAttributesLast({
     "autter.event.id": _crypto.randomUUID.call(void 0, ),
     ...extra,
     ...exceptions,
     ...operationAttributes(state),
     ...user
-  };
-  const enrichers = _optionalChain([shared, 'access', _32 => _32.config, 'optionalAccess', _33 => _33.options, 'optionalAccess', _34 => _34.enrich]);
-  if (summary && state && _optionalChain([enrichers, 'optionalAccess', _35 => _35.length])) {
+  });
+  const enrichers = _optionalChain([shared, 'access', _57 => _57.config, 'optionalAccess', _58 => _58.options, 'optionalAccess', _59 => _59.enrich]);
+  if (summary && state && _optionalChain([enrichers, 'optionalAccess', _60 => _60.length])) {
     const event2 = { level, message, attributes: raw };
     for (const enrich of enrichers) {
       try {
@@ -1484,7 +1950,7 @@ function emit(level, message, attributes, extra = {}, options = {}) {
           res: state.res,
           operation: { id: state.id, name: state.name, kind: state.kind }
         });
-      } catch (e18) {
+      } catch (e33) {
       }
     }
   }
@@ -1497,7 +1963,7 @@ function emit(level, message, attributes, extra = {}, options = {}) {
   for (const sink of activeSinks()) {
     try {
       sink.write(event);
-    } catch (e19) {
+    } catch (e34) {
     }
   }
 }
@@ -1506,7 +1972,7 @@ function configureRuntimeLogger(next) {
   shared.sinks = defaultSinks(next);
   for (const sink of shared.sinks) {
     try {
-      _optionalChain([sink, 'access', _36 => _36.start, 'optionalCall', _37 => _37({
+      _optionalChain([sink, 'access', _61 => _61.start, 'optionalCall', _62 => _62({
         endpoint: next.endpoint,
         apiKey: next.apiKey,
         service: next.service,
@@ -1514,7 +1980,7 @@ function configureRuntimeLogger(next) {
         ...next.release ? { release: next.release } : {},
         ...next.distro ? { distro: next.distro } : {}
       })]);
-    } catch (e20) {
+    } catch (e35) {
     }
   }
 }
@@ -1535,25 +2001,25 @@ function notifyException(error, attributes = {}) {
     type: isError(error) ? error.name : "Error",
     attributes: { ...attributes, ...errorAttributes(error) },
     ...state ? { operationId: state.id } : {},
-    ..._optionalChain([state, 'optionalAccess', _38 => _38.requestId]) ? { requestId: state.requestId } : {}
+    ..._optionalChain([state, 'optionalAccess', _63 => _63.requestId]) ? { requestId: state.requestId } : {}
   };
   for (const sink of [...shared.sinks, ...extraSinks]) {
     try {
-      _optionalChain([sink, 'access', _39 => _39.exception, 'optionalCall', _40 => _40(record)]);
-    } catch (e21) {
+      _optionalChain([sink, 'access', _64 => _64.exception, 'optionalCall', _65 => _65(record)]);
+    } catch (e36) {
     }
   }
 }
 function runtimeLogStats() {
   return {
-    buffered: shared.sinks.reduce((sum, sink) => sum + (_nullishCoalesce(_optionalChain([sink, 'access', _41 => _41.buffered, 'optionalCall', _42 => _42()]), () => ( 0))), 0),
+    buffered: shared.sinks.reduce((sum, sink) => sum + (_nullishCoalesce(_optionalChain([sink, 'access', _66 => _66.buffered, 'optionalCall', _67 => _67()]), () => ( 0))), 0),
     dropped: sinkStats.dropped
   };
 }
 async function flushRuntimeLogs() {
   if (!shared.config) return;
   const results = await Promise.allSettled(
-    shared.sinks.map((sink) => Promise.resolve().then(() => _optionalChain([sink, 'access', _43 => _43.flush, 'optionalCall', _44 => _44()])))
+    shared.sinks.map((sink) => Promise.resolve().then(() => _optionalChain([sink, 'access', _68 => _68.flush, 'optionalCall', _69 => _69()])))
   );
   const failed = results.find((result) => result.status === "rejected");
   if (failed) throw failed.reason;
@@ -1561,7 +2027,7 @@ async function flushRuntimeLogs() {
 async function shutdownRuntimeLogger() {
   const active = shared.sinks;
   const results = await Promise.allSettled(
-    active.map((sink) => Promise.resolve().then(() => _optionalChain([sink, 'access', _45 => _45.shutdown, 'optionalCall', _46 => _46()])))
+    active.map((sink) => Promise.resolve().then(() => _optionalChain([sink, 'access', _70 => _70.shutdown, 'optionalCall', _71 => _71()])))
   );
   shared.config = null;
   shared.sinks = [];
@@ -1583,29 +2049,32 @@ function createRuntimeLogger(attributes = {}) {
     debug: (message, extra) => emit("debug", message, merge(attrs, extra)),
     info: (message, extra) => emit("info", message, merge(attrs, extra)),
     warn: (message, extra) => emit("warning", message, merge(attrs, extra)),
-    error: (error, extra) => emit(
-      "error",
-      isError(error) ? error.message : String(error),
-      {
-        ...attrs,
-        ...extra,
-        ...isError(error) ? {
-          "exception.type": error.name,
-          "exception.stacktrace": _nullishCoalesce(error.stack, () => ( ""))
-        } : {}
-      },
-      errorAttributes(error)
-    )
+    error: (error, extra) => {
+      emit(
+        "error",
+        isError(error) ? error.message : String(error),
+        {
+          ...attrs,
+          ...extra,
+          ...isError(error) ? {
+            "exception.type": error.name,
+            "exception.stacktrace": _nullishCoalesce(error.stack, () => ( ""))
+          } : {}
+        },
+        errorAttributes(error)
+      );
+      if (isError(error)) reportLoggedError(error, "runtimeLogger", void 0, toSpanAttributes(merge(attrs, extra)));
+    }
   };
 }
 var runtimeLogger = createRuntimeLogger();
-function captureExceptionAsLog(error, attributes = {}) {
+function captureExceptionAsLog(error, attributes = {}, level = "error") {
   const isErr = isError(error);
   const message = isErr ? error.message : String(error);
-  const stack = isErr && error.stack ? error.stack : _nullishCoalesce(_optionalChain([new Error(), 'access', _47 => _47.stack, 'optionalAccess', _48 => _48.split, 'call', _49 => _49("\n"), 'access', _50 => _50.filter, 'call', _51 => _51((line, i) => i === 0 || !/captureException/.test(line)), 'access', _52 => _52.join, 'call', _53 => _53("\n")]), () => ( ""));
-  noteOperationError(error);
+  const stack = isErr && error.stack ? error.stack : _nullishCoalesce(_optionalChain([new Error(), 'access', _72 => _72.stack, 'optionalAccess', _73 => _73.split, 'call', _74 => _74("\n"), 'access', _75 => _75.filter, 'call', _76 => _76((line, i) => i === 0 || !/captureException/.test(line)), 'access', _77 => _77.join, 'call', _78 => _78("\n")]), () => ( ""));
+  if (level === "error") noteOperationError(error);
   emit(
-    "error",
+    level,
     message,
     {
       ...attributes,
@@ -1656,7 +2125,7 @@ function operationHandle(state) {
     setContext: (attrs) => {
       if (!state.sealed) {
         state.attributes = merge(state.attributes, attrs);
-        _optionalChain([_api.trace, 'access', _54 => _54.getActiveSpan, 'call', _55 => _55(), 'optionalAccess', _56 => _56.setAttributes, 'call', _57 => _57(traceAttributes(state))]);
+        _optionalChain([_api.trace, 'access', _79 => _79.getActiveSpan, 'call', _80 => _80(), 'optionalAccess', _81 => _81.setAttributes, 'call', _82 => _82(traceAttributes(state))]);
       }
     },
     outcome: (status, message) => setOutcome(state, status, message),
@@ -1690,13 +2159,15 @@ function summaryExtra(state, level, http = {}) {
     "autter.operation.level": maxLevel(state.inline.level, level),
     ...state.ai ? { "autter.operation.ai": state.ai } : {},
     ...http,
-    ...err !== void 0 ? errorAttributes(err) : {},
+    // A summary is no occurrence: no cause stacks or debug ids.
+    ...err !== void 0 ? errorAttributes(err, { stacks: false }) : {},
     ...state.inline.logsTruncated ? { "autter.operation.logs_truncated": true } : {},
     ...state.inline.logs.length ? { "autter.operation.logs": state.inline.logs } : {}
   };
 }
 function emitSummary(state, options = {}) {
   if (state.sealed) return;
+  settleDegraded(state);
   const err = state.error;
   const level = state.outcome === "failed" ? "error" : "info";
   emit(
@@ -1714,9 +2185,13 @@ function emitSummary(state, options = {}) {
   );
   state.sealed = true;
 }
+function settleDegraded(state) {
+  if (state.degraded && state.outcome === "succeeded" && !state.explicitOutcome)
+    state.outcome = "degraded";
+}
 function reportExplicitFailure(state) {
   if (state.outcome === "failed" && state.explicitOutcome && !state.errorThrown)
-    _optionalChain([shared, 'access', _58 => _58.config, 'optionalAccess', _59 => _59.reportOutcome, 'call', _60 => _60(state.name, _nullishCoalesce(state.message, () => ( "Operation failed")), {
+    _optionalChain([shared, 'access', _83 => _83.config, 'optionalAccess', _84 => _84.reportOutcome, 'call', _85 => _85(state.name, _nullishCoalesce(state.message, () => ( "Operation failed")), {
       ...traceAttributes(state),
       "autter.outcome.stack": _nullishCoalesce(state.reportingStack, () => ( ""))
     })]);
@@ -1724,7 +2199,7 @@ function reportExplicitFailure(state) {
 function startOperation(name, fn, attributes, options, internal = {}) {
   const parent = _nullishCoalesce(internal.forkParent, () => ( local.getStore()));
   const carrier = options.from ? parseCarrier(options.from) : null;
-  const traceparent = _optionalChain([carrier, 'optionalAccess', _61 => _61.traceparent]) ? parseTraceparent(carrier.traceparent) : null;
+  const traceparent = _optionalChain([carrier, 'optionalAccess', _86 => _86.traceparent]) ? parseTraceparent(carrier.traceparent) : null;
   const linked = internal.forkParent !== void 0 || parent && !parent.sealed;
   const state = newState(
     name,
@@ -1736,7 +2211,7 @@ function startOperation(name, fn, attributes, options, internal = {}) {
       ...traceparent ? { parentTraceId: traceparent.traceId } : {}
     } : {
       ...linked && parent ? { parentId: parent.id, base: parent.attributes } : {},
-      ..._optionalChain([parent, 'optionalAccess', _62 => _62.requestId]) ? { requestId: parent.requestId } : {}
+      ..._optionalChain([parent, 'optionalAccess', _87 => _87.requestId]) ? { requestId: parent.requestId } : {}
     }
   );
   if (linked && parent) state.breadcrumbs = parent.breadcrumbs ??= new BreadcrumbTrail();
@@ -1750,16 +2225,17 @@ function startOperation(name, fn, attributes, options, internal = {}) {
       thrown = error;
       noteOperationError(error, true, state);
       rememberThrownBreadcrumbs(error, state);
-      _optionalChain([shared, 'access', _63 => _63.config, 'optionalAccess', _64 => _64.captureThrown, 'optionalCall', _65 => _65(error)]);
+      _optionalChain([shared, 'access', _88 => _88.config, 'optionalAccess', _89 => _89.captureThrown, 'optionalCall', _90 => _90(error)]);
       throw error;
     } finally {
-      _optionalChain([_api.trace, 'access', _66 => _66.getActiveSpan, 'call', _67 => _67(), 'optionalAccess', _68 => _68.setAttributes, 'call', _69 => _69({
+      settleDegraded(state);
+      _optionalChain([_api.trace, 'access', _91 => _91.getActiveSpan, 'call', _92 => _92(), 'optionalAccess', _93 => _93.setAttributes, 'call', _94 => _94({
         ...traceAttributes(state),
         "autter.operation.outcome": state.outcome,
         "autter.operation.kind": state.kind
       })]);
       if (state.outcome === "failed" && !thrown)
-        _optionalChain([shared, 'access', _70 => _70.config, 'optionalAccess', _71 => _71.reportOutcome, 'call', _72 => _72(
+        _optionalChain([shared, 'access', _95 => _95.config, 'optionalAccess', _96 => _96.reportOutcome, 'call', _97 => _97(
           state.name,
           _nullishCoalesce(state.message, () => ( "Operation failed")),
           {
@@ -1780,14 +2256,14 @@ function startOperation(name, fn, attributes, options, internal = {}) {
       }
     }
   ] : [];
-  const promise = _optionalChain([shared, 'access', _73 => _73.config, 'optionalAccess', _74 => _74.run]) ? shared.config.run(state.name, run, traceAttributes(state), links) : run();
+  const promise = _optionalChain([shared, 'access', _98 => _98.config, 'optionalAccess', _99 => _99.run]) ? shared.config.run(state.name, run, traceAttributes(state), links) : run();
   if (!options.waitUntil) return promise;
   const waitUntil = options.waitUntil;
   return promise.finally(() => {
     try {
       waitUntil(flushRuntimeLogs().catch(() => {
       }));
-    } catch (e22) {
+    } catch (e37) {
     }
   });
 }
@@ -1803,7 +2279,7 @@ var runtimeContext = {
     const state = currentOperation();
     if (!state) return;
     state.attributes = merge(state.attributes, attributes);
-    _optionalChain([_api.trace, 'access', _75 => _75.getActiveSpan, 'call', _76 => _76(), 'optionalAccess', _77 => _77.setAttributes, 'call', _78 => _78(traceAttributes(state))]);
+    _optionalChain([_api.trace, 'access', _100 => _100.getActiveSpan, 'call', _101 => _101(), 'optionalAccess', _102 => _102.setAttributes, 'call', _103 => _103(traceAttributes(state))]);
   },
   /** Set the outcome explicitly (wins over status/thrown-error rules). */
   outcome(status, message) {
@@ -1824,13 +2300,37 @@ var runtimeContext = {
     noteOperationError(error);
     runtimeLogger.error(error, attributes);
   },
+  /**
+   * The app caught `error` and chose to continue on a fallback (RF-02):
+   *
+   *   } catch (err) {
+   *     runtimeContext.degraded(err, "pricing service down, using cached prices");
+   *   }
+   *
+   * Recorded as an occurrence at `warning` severity, marked
+   * `autter.handling = "deliberate"` with the reason (grouped by its code
+   * when the error has one), never an incident. The current request or
+   * operation ends "degraded" unless it failed or set its outcome.
+   */
+  degraded(error, reason, attributes) {
+    try {
+      const state = currentOperation();
+      if (state) {
+        state.degraded = true;
+        noteOperationError(error, false, state);
+        appendInlineLog(state.inline, "warning", `degraded: ${String(reason)}`, void 0, redact);
+      }
+      reportDegraded(error, reason, toSpanAttributes(userContext(attributes, redact)));
+    } catch (e38) {
+    }
+  },
   /** Current operation id. */
   get id() {
-    return _optionalChain([local, 'access', _79 => _79.getStore, 'call', _80 => _80(), 'optionalAccess', _81 => _81.id]);
+    return _optionalChain([local, 'access', _104 => _104.getStore, 'call', _105 => _105(), 'optionalAccess', _106 => _106.id]);
   },
   /** Current request id (inherited by child operations and forks). */
   get requestId() {
-    return _optionalChain([local, 'access', _82 => _82.getStore, 'call', _83 => _83(), 'optionalAccess', _84 => _84.requestId]);
+    return _optionalChain([local, 'access', _107 => _107.getStore, 'call', _108 => _108(), 'optionalAccess', _109 => _109.requestId]);
   },
   /**
    * Run `fn` as a child operation whose parent link is captured NOW, so it
@@ -1844,7 +2344,7 @@ var runtimeContext = {
   carrier() {
     const state = local.getStore();
     if (!state) return void 0;
-    const span = _optionalChain([_api.trace, 'access', _85 => _85.getActiveSpan, 'call', _86 => _86(), 'optionalAccess', _87 => _87.spanContext, 'call', _88 => _88()]);
+    const span = _optionalChain([_api.trace, 'access', _110 => _110.getActiveSpan, 'call', _111 => _111(), 'optionalAccess', _112 => _112.spanContext, 'call', _113 => _113()]);
     const traceparent = span ? formatTraceparent(span.traceId, span.spanId, (span.traceFlags & 1) === 1) : void 0;
     return createCarrier({
       op: state.id,
@@ -1853,11 +2353,20 @@ var runtimeContext = {
     });
   }
 };
+setHandledTail(
+  (type, dropped) => emit(
+    "warning",
+    `${dropped} caught ${type} error(s) left out by the burst limit`,
+    { "autter.caught.dropped": dropped, "autter.caught.type": type },
+    {},
+    { state: null }
+  )
+);
 
 // src/breadcrumbs.ts
 var INVALID_TRACE_ID = "00000000000000000000000000000000";
 var MAX_TRACE_TRAILS = 200;
-var trails = _chunkMOZOUEMAcjs.sharedSlot.call(void 0, "breadcrumbs", () => ({
+var trails = _chunk3P573RHAcjs.sharedSlot.call(void 0, "breadcrumbs", () => ({
   byTrace: /* @__PURE__ */ new Map(),
   process: new BreadcrumbTrail(),
   thrown: /* @__PURE__ */ new WeakMap()
@@ -1866,14 +2375,14 @@ var byTrace = trails.byTrace;
 var processTrail = trails.process;
 var thrownTrails = trails.thrown;
 function redact2(attributes) {
-  return _nullishCoalesce(_optionalChain([loggerConfigured, 'call', _89 => _89(), 'optionalAccess', _90 => _90.redact, 'call', _91 => _91(attributes)]), () => ( redactAttributes(attributes)));
+  return _nullishCoalesce(_optionalChain([loggerConfigured, 'call', _114 => _114(), 'optionalAccess', _115 => _115.redact, 'call', _116 => _116(attributes)]), () => ( redactAttributes(attributes)));
 }
 function trailFor(create, state = local.getStore()) {
   if (state) {
     if (!state.breadcrumbs && create) state.breadcrumbs = new BreadcrumbTrail();
     return state.breadcrumbs;
   }
-  const traceId = _optionalChain([_api.trace, 'access', _92 => _92.getActiveSpan, 'call', _93 => _93(), 'optionalAccess', _94 => _94.spanContext, 'call', _95 => _95(), 'access', _96 => _96.traceId]);
+  const traceId = _optionalChain([_api.trace, 'access', _117 => _117.getActiveSpan, 'call', _118 => _118(), 'optionalAccess', _119 => _119.spanContext, 'call', _120 => _120(), 'access', _121 => _121.traceId]);
   if (traceId && traceId !== INVALID_TRACE_ID) {
     let trail = byTrace.get(traceId);
     if (!trail && create) {
@@ -1892,9 +2401,9 @@ function addBreadcrumb(input) {
   try {
     const crumb = normalizeBreadcrumb(input, redact2);
     if (!crumb) return;
-    _optionalChain([trailFor, 'call', _97 => _97(true), 'optionalAccess', _98 => _98.add, 'call', _99 => _99(crumb)]);
-    _chunkMOZOUEMAcjs.noteCompatFeature.call(void 0, "breadcrumbs");
-  } catch (e23) {
+    _optionalChain([trailFor, 'call', _122 => _122(true), 'optionalAccess', _123 => _123.add, 'call', _124 => _124(crumb)]);
+    _chunk3P573RHAcjs.noteCompatFeature.call(void 0, "breadcrumbs");
+  } catch (e39) {
   }
 }
 function recordLogBreadcrumb(level, message, attributes, state) {
@@ -1910,15 +2419,15 @@ function recordLogBreadcrumb(level, message, attributes, state) {
       }
     }
     const crumb = normalizeBreadcrumb({ type: "log", level, message, data }, redact2);
-    if (crumb) _optionalChain([trailFor, 'call', _100 => _100(true, state), 'optionalAccess', _101 => _101.add, 'call', _102 => _102(crumb)]);
-  } catch (e24) {
+    if (crumb) _optionalChain([trailFor, 'call', _125 => _125(true, state), 'optionalAccess', _126 => _126.add, 'call', _127 => _127(crumb)]);
+  } catch (e40) {
   }
 }
 function attributeBudget() {
-  const limit = Number(
+  const limit2 = Number(
     _nullishCoalesce(process.env.OTEL_SPAN_ATTRIBUTE_VALUE_LENGTH_LIMIT, () => ( process.env.OTEL_ATTRIBUTE_VALUE_LENGTH_LIMIT))
   );
-  return Number.isFinite(limit) && limit > 0 ? Math.min(BREADCRUMBS_ATTRIBUTE_MAX_CHARS, limit) : BREADCRUMBS_ATTRIBUTE_MAX_CHARS;
+  return Number.isFinite(limit2) && limit2 > 0 ? Math.min(BREADCRUMBS_ATTRIBUTE_MAX_CHARS, limit2) : BREADCRUMBS_ATTRIBUTE_MAX_CHARS;
 }
 function rememberThrownBreadcrumbs(error, state) {
   if (state.breadcrumbs && error !== null && (typeof error === "object" || typeof error === "function"))
@@ -1928,10 +2437,10 @@ function breadcrumbEventAttributes(scrub, error) {
   try {
     const thrown = error !== null && typeof error === "object" ? thrownTrails.get(error) : void 0;
     const trail = _nullishCoalesce(thrown, () => ( trailFor(false)));
-    if (!_optionalChain([trail, 'optionalAccess', _103 => _103.size])) return {};
+    if (!_optionalChain([trail, 'optionalAccess', _128 => _128.size])) return {};
     const json = breadcrumbsAttribute(trail.list(), scrub, attributeBudget());
     return json ? { [BREADCRUMBS_ATTRIBUTE]: json } : {};
-  } catch (e25) {
+  } catch (e41) {
     return {};
   }
 }
@@ -1987,4 +2496,9 @@ function breadcrumbEventAttributes(scrub, error) {
 
 
 
-exports.redactAttributes = redactAttributes; exports.redactText = redactText; exports.makeRedactor = makeRedactor; exports.CODE_PATTERN = CODE_PATTERN; exports.RuntimeError = RuntimeError; exports.defineRuntimeErrors = defineRuntimeErrors; exports.isError = isError; exports.isRuntimeErrorLike = isRuntimeErrorLike; exports.errorCodeOf = errorCodeOf; exports.errorAttributes = errorAttributes; exports.errorInternal = errorInternal; exports.toClientError = toClientError; exports.responseStatusOf = responseStatusOf; exports.isSummary = isSummary; exports.DEFAULT_REQUEST_ID_HEADER = DEFAULT_REQUEST_ID_HEADER; exports.resolveRequestId = resolveRequestId; exports.normalizeRoutePath = normalizeRoutePath; exports.compileIgnore = compileIgnore; exports.requestOutcome = requestOutcome; exports.parseUserAgent = parseUserAgent; exports.sanitizeBreadcrumbs = sanitizeBreadcrumbs; exports.fingerprintValues = fingerprintValues; exports.fingerprintEventAttributes = fingerprintEventAttributes; exports.splitFingerprint = splitFingerprint; exports.createErrorFilter = createErrorFilter; exports.addBreadcrumb = addBreadcrumb; exports.breadcrumbEventAttributes = breadcrumbEventAttributes; exports.otlpSink = otlpSink; exports.consoleSink = consoleSink; exports.fileSink = fileSink; exports.memorySink = memorySink; exports.local = local; exports.currentOperation = currentOperation; exports.configureRuntimeLogger = configureRuntimeLogger; exports.addRuntimeSink = addRuntimeSink; exports.notifyException = notifyException; exports.runtimeLogStats = runtimeLogStats; exports.flushRuntimeLogs = flushRuntimeLogs; exports.shutdownRuntimeLogger = shutdownRuntimeLogger; exports.noteOperationError = noteOperationError; exports.recordOperationAiUsage = recordOperationAiUsage; exports.createRuntimeLogger = createRuntimeLogger; exports.runtimeLogger = runtimeLogger; exports.captureExceptionAsLog = captureExceptionAsLog; exports.createRequestState = createRequestState; exports.emitSummary = emitSummary; exports.reportExplicitFailure = reportExplicitFailure; exports.withRuntimeOperation = withRuntimeOperation; exports.runInBackground = runInBackground; exports.runtimeContext = runtimeContext;
+
+
+
+
+
+exports.redactAttributes = redactAttributes; exports.redactText = redactText; exports.makeRedactor = makeRedactor; exports.CODE_PATTERN = CODE_PATTERN; exports.RuntimeError = RuntimeError; exports.defineRuntimeErrors = defineRuntimeErrors; exports.isError = isError; exports.isRuntimeErrorLike = isRuntimeErrorLike; exports.errorCodeOf = errorCodeOf; exports.errorAttributes = errorAttributes; exports.errorInternal = errorInternal; exports.toClientError = toClientError; exports.responseStatusOf = responseStatusOf; exports.isSummary = isSummary; exports.DEFAULT_REQUEST_ID_HEADER = DEFAULT_REQUEST_ID_HEADER; exports.resolveRequestId = resolveRequestId; exports.normalizeRoutePath = normalizeRoutePath; exports.compileIgnore = compileIgnore; exports.requestOutcome = requestOutcome; exports.parseUserAgent = parseUserAgent; exports.sanitizeBreadcrumbs = sanitizeBreadcrumbs; exports.fingerprintValues = fingerprintValues; exports.fingerprintEventAttributes = fingerprintEventAttributes; exports.splitFingerprint = splitFingerprint; exports.createErrorFilter = createErrorFilter; exports.addBreadcrumb = addBreadcrumb; exports.breadcrumbEventAttributes = breadcrumbEventAttributes; exports.markCaptured = markCaptured; exports.isCaptured = isCaptured; exports.setHandledCapture = setHandledCapture; exports.startLoggedErrorCapture = startLoggedErrorCapture; exports.stopLoggedErrorCapture = stopLoggedErrorCapture; exports.otlpSink = otlpSink; exports.consoleSink = consoleSink; exports.fileSink = fileSink; exports.memorySink = memorySink; exports.local = local; exports.currentOperation = currentOperation; exports.configureRuntimeLogger = configureRuntimeLogger; exports.addRuntimeSink = addRuntimeSink; exports.notifyException = notifyException; exports.runtimeLogStats = runtimeLogStats; exports.flushRuntimeLogs = flushRuntimeLogs; exports.shutdownRuntimeLogger = shutdownRuntimeLogger; exports.noteOperationError = noteOperationError; exports.recordOperationAiUsage = recordOperationAiUsage; exports.createRuntimeLogger = createRuntimeLogger; exports.runtimeLogger = runtimeLogger; exports.captureExceptionAsLog = captureExceptionAsLog; exports.createRequestState = createRequestState; exports.emitSummary = emitSummary; exports.reportExplicitFailure = reportExplicitFailure; exports.withRuntimeOperation = withRuntimeOperation; exports.runInBackground = runInBackground; exports.runtimeContext = runtimeContext;