@autter/runtime-node 1.5.0 → 1.6.1

package/dist/{chunk-3TJHUCZ6.js → chunk-5KISVAVB.js}

@@ -1,7 +1,8 @@
 import {
   noteCompatFeature,
-  observeIngesterResponse
-} from "./chunk-L7HWKMCZ.js";
+  observeIngesterResponse,
+  sharedSlot
+} from "./chunk-HRDELHZP.js";
 
 // ../runtime-core/dist/index.js
 var SENSITIVE_KEY_PATTERNS = [
@@ -327,8 +328,8 @@ function priority(key) {
   if (/^(?:exception|autter\.error)\./.test(key)) return 1;
   return 0;
 }
-function boundContext(attributes = {}, redact2) {
-  const redacted = redact2 ? redact2(attributes) : redactAttributes(attributes);
+function boundContext(attributes = {}, redact3) {
+  const redacted = redact3 ? redact3(attributes) : redactAttributes(attributes);
   let budget = 512;
   let characters = 16384;
   let truncated = false;
@@ -365,14 +366,14 @@ function boundContext(attributes = {}, redact2) {
   if (truncated) result["autter.context.truncated"] = true;
   return result;
 }
-function userContext(attributes = {}, redact2) {
+function userContext(attributes = {}, redact3) {
   return Object.fromEntries(
-    Object.entries(boundContext(attributes, redact2)).filter(
+    Object.entries(boundContext(attributes, redact3)).filter(
       ([key]) => !RESERVED_KEY.test(key)
     )
   );
 }
-function mergeContext(current, next = {}, redact2) {
+function mergeContext(current, next = {}, redact3) {
   const merge2 = (left, right, depth) => {
     const result = { ...left };
     for (const [key, value] of Object.entries(right)) {
@@ -381,7 +382,7 @@ function mergeContext(current, next = {}, redact2) {
     }
     return result;
   };
-  return userContext(merge2(current, userContext(next, redact2), 0), redact2);
+  return userContext(merge2(current, userContext(next, redact3), 0), redact3);
 }
 function toSpanAttributes(context) {
   return Object.fromEntries(
@@ -473,6 +474,17 @@ function defineRuntimeErrors(namespace, catalog) {
   }
   return out;
 }
+function isError(value) {
+  if (!value || typeof value !== "object") return false;
+  try {
+    if (value instanceof Error) return true;
+    const native = Error.isError;
+    if (typeof native === "function") return native(value) === true;
+    return Object.prototype.toString.call(value) === "[object Error]";
+  } catch {
+    return false;
+  }
+}
 function isRuntimeErrorLike(err) {
   if (err instanceof RuntimeError) return true;
   if (!err || typeof err !== "object") return false;
@@ -523,15 +535,15 @@ function errorAttributes(err, options = {}) {
     for (let n = 1; n <= CAUSE_DEPTH && cause !== void 0 && cause !== null; n++) {
       if (seen.has(cause)) break;
       seen.add(cause);
-      const isError = typeof cause === "object";
-      const type = isError ? String(field(cause, "name") ?? cause.constructor?.name ?? "Error") : typeof cause;
-      const message = isError ? field(cause, "message") : cause;
+      const isError2 = typeof cause === "object";
+      const type = isError2 ? String(field(cause, "name") ?? cause.constructor?.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(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);
-      cause = isError ? field(cause, "cause") : void 0;
+      cause = isError2 ? field(cause, "cause") : void 0;
     }
   }
   return out;
@@ -577,19 +589,19 @@ function createInlineLogState(startedAt) {
     level: "info"
   };
 }
-function appendInlineLog(state, level, message, attrs, redact2, now = Date.now()) {
+function appendInlineLog(state, level, message, attrs, redact3, now = Date.now()) {
   state.level = maxLevel(state.level, level);
   if (state.logs.length >= INLINE_LOG_LIMIT) {
     state.logsTruncated = true;
     return;
   }
-  const text = String(boundContext({ message }, redact2).message ?? "").slice(
+  const text = String(boundContext({ message }, redact3).message ?? "").slice(
     0,
     INLINE_MESSAGE_MAX
   );
   let small;
   if (attrs && Object.keys(attrs).length) {
-    small = boundContext(attrs, redact2);
+    small = boundContext(attrs, redact3);
     const encoded = JSON.stringify(small);
     if (encoded.length > 1e3) small = { "autter.context.truncated": true };
   }
@@ -806,6 +818,172 @@ function parseUserAgent(ua) {
   const device = !value ? "unknown" : bot ? "bot" : /iPad|Tablet/.test(value) || /Android/.test(value) && !/Mobile/.test(value) ? "tablet" : /Mobi|iPhone|iPod|Android/.test(value) ? "mobile" : "desktop";
   return { browser, os, device, bot };
 }
+var BREADCRUMBS_ATTRIBUTE = "autter.breadcrumbs";
+var MAX_BREADCRUMBS = 30;
+var MAX_MESSAGE = 500;
+var MAX_DATA_KEYS = 10;
+var MAX_DATA_STRING = 200;
+var BREADCRUMBS_ATTRIBUTE_MAX_CHARS = 16 * 1024;
+var MASK = "[redacted]";
+var TYPES = /* @__PURE__ */ new Set(["console", "request", "navigation", "click", "log", "custom"]);
+var LEVELS = {
+  debug: "debug",
+  trace: "debug",
+  info: "info",
+  log: "info",
+  warning: "warning",
+  warn: "warning",
+  error: "error",
+  fatal: "error"
+};
+var UNSAFE_KEY = /^(?:__proto__|constructor|prototype)$/;
+function scrubber(redact3) {
+  return (value, max) => {
+    const scrubbed = redact3({ message: value.slice(0, max + 512) }).message;
+    return stripUrlQueries(typeof scrubbed === "string" ? scrubbed : "").slice(0, max);
+  };
+}
+function cleanData(raw, redact3) {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return void 0;
+  const picked = {};
+  let count = 0;
+  for (const key of Object.keys(raw).slice(0, 64)) {
+    if (count >= MAX_DATA_KEYS) break;
+    if (!key || UNSAFE_KEY.test(key)) continue;
+    const value = raw[key];
+    const name = key.slice(0, 100);
+    if (typeof value === "string") {
+      const text = /(?:url|path|route|target)$/i.test(name) ? value.split(/[?#]/)[0] : value;
+      picked[name] = text.slice(0, MAX_DATA_STRING + 512);
+    } else if (typeof value === "number") {
+      if (!Number.isFinite(value)) continue;
+      picked[name] = value;
+    } else if (typeof value === "boolean" || value === null) {
+      picked[name] = value;
+    } else {
+      continue;
+    }
+    count++;
+  }
+  if (count === 0) return void 0;
+  const redacted = redact3(picked);
+  const out = {};
+  for (const key of Object.keys(picked)) {
+    const value = key in redacted ? redacted[key] : picked[key];
+    out[key] = typeof value === "string" ? stripUrlQueries(value).slice(0, MAX_DATA_STRING) : value;
+  }
+  return out;
+}
+function timestamp(value) {
+  if (value === void 0) return (/* @__PURE__ */ new Date()).toISOString();
+  if (typeof value !== "string" && typeof value !== "number" && !(value instanceof Date)) return null;
+  const at = new Date(value);
+  return Number.isNaN(at.getTime()) ? null : at.toISOString();
+}
+function normalizeBreadcrumb(input, redact3, options = {}) {
+  try {
+    if (!input || typeof input !== "object" || Array.isArray(input)) return null;
+    const raw = input;
+    if (options.requireAt && raw.at === void 0) return null;
+    const at = timestamp(raw.at);
+    if (!at) return null;
+    const rawMessage = raw.message;
+    const message = typeof rawMessage === "string" ? rawMessage : typeof rawMessage === "number" || typeof rawMessage === "boolean" ? String(rawMessage) : "";
+    const data = cleanData(raw.data, redact3);
+    if (!message && !data) return null;
+    const type = typeof raw.type === "string" && TYPES.has(raw.type) ? raw.type : "custom";
+    const level = typeof raw.level === "string" ? LEVELS[raw.level.toLowerCase()] : void 0;
+    return {
+      type,
+      at,
+      ...level ? { level } : {},
+      message: scrubber(redact3)(message, MAX_MESSAGE),
+      ...data ? { data } : {}
+    };
+  } catch {
+    return null;
+  }
+}
+function sanitizeBreadcrumbs(raw, redact3) {
+  const out = [];
+  try {
+    if (!Array.isArray(raw)) return void 0;
+    const first = Math.max(0, raw.length - 200);
+    for (let i = raw.length - 1; i >= first && out.length < MAX_BREADCRUMBS; i--) {
+      const crumb = normalizeBreadcrumb(raw[i], redact3, { requireAt: true });
+      if (crumb) out.push(crumb);
+    }
+  } catch {
+  }
+  return out.length ? out.reverse() : void 0;
+}
+var BreadcrumbTrail = class {
+  constructor(max = MAX_BREADCRUMBS) {
+    this.max = max;
+  }
+  max;
+  items = [];
+  add(crumb) {
+    this.items.push(crumb);
+    if (this.items.length > this.max) this.items.splice(0, this.items.length - this.max);
+  }
+  /** Copies, oldest first. */
+  list() {
+    return this.items.map((crumb) => ({ ...crumb, ...crumb.data ? { data: { ...crumb.data } } : {} }));
+  }
+  get size() {
+    return this.items.length;
+  }
+  clear() {
+    this.items = [];
+  }
+};
+function breadcrumbsAttribute(list, scrub, maxChars = BREADCRUMBS_ATTRIBUTE_MAX_CHARS) {
+  const parts = [];
+  let chars = 2;
+  for (let i = list.length - 1; i >= 0 && parts.length < MAX_BREADCRUMBS; i--) {
+    const crumb = list[i];
+    let json = JSON.stringify(crumb);
+    if (scrub(json) !== json) {
+      json = JSON.stringify({ type: crumb.type, at: crumb.at, ...crumb.level ? { level: crumb.level } : {}, message: MASK });
+    }
+    if (chars + json.length + 1 > maxChars) break;
+    chars += json.length + 1;
+    parts.push(json);
+  }
+  if (parts.length === 0) return void 0;
+  const out = `[${parts.reverse().join(",")}]`;
+  return scrub(out) === out ? out : void 0;
+}
+var FINGERPRINT_ATTRIBUTE = "autter.fingerprint";
+var FINGERPRINT_MAX_VALUES = 10;
+var FINGERPRINT_MAX_LENGTH = 200;
+function fingerprintValues(value, scrub = (text) => text) {
+  const list = Array.isArray(value) ? value : [value];
+  const values = list.filter((item) => typeof item === "string" && item !== "").slice(0, FINGERPRINT_MAX_VALUES).map((item) => scrub(item.slice(0, FINGERPRINT_MAX_LENGTH + 512)).slice(0, FINGERPRINT_MAX_LENGTH)).filter((item) => item !== "");
+  return values.length > 0 ? values : void 0;
+}
+function fingerprintEventAttributes(value, scrub) {
+  const values = fingerprintValues(value, scrub);
+  return values ? { [FINGERPRINT_ATTRIBUTE]: JSON.stringify(values) } : {};
+}
+function splitFingerprint(attributes) {
+  if (!attributes || typeof attributes !== "object" || !("fingerprint" in attributes)) {
+    return { attributes: attributes ?? void 0, fingerprint: void 0 };
+  }
+  const { fingerprint, ...rest } = attributes;
+  return { attributes: rest, fingerprint };
+}
+
+// src/breadcrumbs.ts
+import { trace as trace2 } from "@opentelemetry/api";
+
+// src/logger.ts
+import { AsyncLocalStorage } from "async_hooks";
+import { randomUUID } from "crypto";
+import {
+  trace
+} from "@opentelemetry/api";
 
 // src/sinks.ts
 import {
@@ -816,7 +994,7 @@ import {
   unlinkSync
 } from "fs";
 import { join, resolve } from "path";
-var sinkStats = { dropped: 0 };
+var sinkStats = sharedSlot("sinks", () => ({ dropped: 0 }));
 function otlpSink(options = {}) {
   let context = null;
   let queue = [];
@@ -1185,23 +1363,22 @@ function memorySink() {
 }
 
 // src/logger.ts
-import { AsyncLocalStorage } from "async_hooks";
-import { randomUUID } from "crypto";
-import {
-  trace
-} from "@opentelemetry/api";
-var local = new AsyncLocalStorage();
-var config = null;
-var sinks = [];
-var extraSinks = /* @__PURE__ */ new Set();
+var shared = sharedSlot("logger", () => ({
+  local: new AsyncLocalStorage(),
+  config: null,
+  sinks: [],
+  extraSinks: /* @__PURE__ */ new Set()
+}));
+var local = shared.local;
+var extraSinks = shared.extraSinks;
 var fallbackConsole = null;
 function redact(attributes) {
-  return config?.redact(attributes) ?? redactAttributes(attributes);
+  return shared.config?.redact(attributes) ?? redactAttributes(attributes);
 }
 var safe = (attributes = {}) => boundContext(attributes, redact);
 var merge = (current, next) => mergeContext(current, next, redact);
 function activeSinks() {
-  if (config) return extraSinks.size ? [...sinks, ...extraSinks] : sinks;
+  if (shared.config) return extraSinks.size ? [...shared.sinks, ...extraSinks] : shared.sinks;
   if (extraSinks.size) return [...extraSinks];
   fallbackConsole ??= consoleSink();
   return [fallbackConsole];
@@ -1237,9 +1414,10 @@ function emit(level, message, attributes, extra = {}, options = {}) {
   const state = options.state !== void 0 ? options.state ?? void 0 : local.getStore();
   if (state?.sealed) return;
   const summary = extra["autter.event.type"] === "operation";
-  if (!summary && LEVEL_SEVERITY[level] < LEVEL_SEVERITY[config?.options?.minLevel ?? "debug"])
+  if (!summary) recordLogBreadcrumb(level, message, attributes, state);
+  if (!summary && LEVEL_SEVERITY[level] < LEVEL_SEVERITY[shared.config?.options?.minLevel ?? "debug"])
     return;
-  if (!summary && state && config?.options?.inline !== false) {
+  if (!summary && state && shared.config?.options?.inline !== false) {
     const { "exception.stacktrace": _stack, ...inlineAttrs } = userContext(
       attributes,
       redact
@@ -1259,7 +1437,7 @@ function emit(level, message, attributes, extra = {}, options = {}) {
     ...operationAttributes(state),
     ...user
   };
-  const enrichers = config?.options?.enrich;
+  const enrichers = shared.config?.options?.enrich;
   if (summary && state && enrichers?.length) {
     const event2 = { level, message, attributes: raw };
     for (const enrich of enrichers) {
@@ -1287,9 +1465,9 @@ function emit(level, message, attributes, extra = {}, options = {}) {
   }
 }
 function configureRuntimeLogger(next) {
-  config = next;
-  sinks = defaultSinks(next);
-  for (const sink of sinks) {
+  shared.config = next;
+  shared.sinks = defaultSinks(next);
+  for (const sink of shared.sinks) {
     try {
       sink.start?.({
         endpoint: next.endpoint,
@@ -1303,23 +1481,26 @@ function configureRuntimeLogger(next) {
     }
   }
 }
+function loggerConfigured() {
+  return shared.config;
+}
 function addRuntimeSink(sink) {
   extraSinks.add(sink);
   return () => extraSinks.delete(sink);
 }
 function notifyException(error, attributes = {}) {
-  if (!extraSinks.size && !sinks.some((sink) => sink.exception)) return;
+  if (!extraSinks.size && !shared.sinks.some((sink) => sink.exception)) return;
   const state = local.getStore();
   const record = {
     time: Date.now(),
     error,
-    message: error instanceof Error ? error.message : String(error),
-    type: error instanceof Error ? error.name : "Error",
+    message: isError(error) ? error.message : String(error),
+    type: isError(error) ? error.name : "Error",
     attributes: { ...attributes, ...errorAttributes(error) },
     ...state ? { operationId: state.id } : {},
     ...state?.requestId ? { requestId: state.requestId } : {}
   };
-  for (const sink of [...sinks, ...extraSinks]) {
+  for (const sink of [...shared.sinks, ...extraSinks]) {
     try {
       sink.exception?.(record);
     } catch {
@@ -1328,25 +1509,25 @@ function notifyException(error, attributes = {}) {
 }
 function runtimeLogStats() {
   return {
-    buffered: sinks.reduce((sum, sink) => sum + (sink.buffered?.() ?? 0), 0),
+    buffered: shared.sinks.reduce((sum, sink) => sum + (sink.buffered?.() ?? 0), 0),
     dropped: sinkStats.dropped
   };
 }
 async function flushRuntimeLogs() {
-  if (!config) return;
+  if (!shared.config) return;
   const results = await Promise.allSettled(
-    sinks.map((sink) => Promise.resolve().then(() => sink.flush?.()))
+    shared.sinks.map((sink) => Promise.resolve().then(() => sink.flush?.()))
   );
   const failed = results.find((result) => result.status === "rejected");
   if (failed) throw failed.reason;
 }
 async function shutdownRuntimeLogger() {
-  const active = sinks;
+  const active = shared.sinks;
   const results = await Promise.allSettled(
     active.map((sink) => Promise.resolve().then(() => sink.shutdown?.()))
   );
-  config = null;
-  sinks = [];
+  shared.config = null;
+  shared.sinks = [];
   const failed = results.find((result) => result.status === "rejected");
   if (failed) throw failed.reason;
 }
@@ -1367,11 +1548,11 @@ function createRuntimeLogger(attributes = {}) {
     warn: (message, extra) => emit("warning", message, merge(attrs, extra)),
     error: (error, extra) => emit(
       "error",
-      error instanceof Error ? error.message : String(error),
+      isError(error) ? error.message : String(error),
       {
         ...attrs,
         ...extra,
-        ...error instanceof Error ? {
+        ...isError(error) ? {
           "exception.type": error.name,
           "exception.stacktrace": error.stack ?? ""
         } : {}
@@ -1382,16 +1563,16 @@ function createRuntimeLogger(attributes = {}) {
 }
 var runtimeLogger = createRuntimeLogger();
 function captureExceptionAsLog(error, attributes = {}) {
-  const isError = error instanceof Error;
-  const message = isError ? error.message : String(error);
-  const stack = isError && error.stack ? error.stack : new Error().stack?.split("\n").filter((line, i) => i === 0 || !/captureException/.test(line)).join("\n") ?? "";
+  const isErr = isError(error);
+  const message = isErr ? error.message : String(error);
+  const stack = isErr && error.stack ? error.stack : new Error().stack?.split("\n").filter((line, i) => i === 0 || !/captureException/.test(line)).join("\n") ?? "";
   noteOperationError(error);
   emit(
     "error",
     message,
     {
       ...attributes,
-      "exception.type": isError ? error.name : "Error",
+      "exception.type": isErr ? error.name : "Error",
       "exception.message": message,
       "exception.stacktrace": stack
     },
@@ -1486,7 +1667,7 @@ function emitSummary(state, options = {}) {
     state.message ?? `${state.name}: ${state.outcome}`,
     {
       ...operationAttributes(state),
-      ...err instanceof Error ? {
+      ...isError(err) ? {
         "exception.type": err.name,
         "exception.stacktrace": err.stack ?? ""
       } : {}
@@ -1498,7 +1679,7 @@ function emitSummary(state, options = {}) {
 }
 function reportExplicitFailure(state) {
   if (state.outcome === "failed" && state.explicitOutcome && !state.errorThrown)
-    config?.reportOutcome(state.name, state.message ?? "Operation failed", {
+    shared.config?.reportOutcome(state.name, state.message ?? "Operation failed", {
       ...traceAttributes(state),
       "autter.outcome.stack": state.reportingStack ?? ""
     });
@@ -1521,6 +1702,7 @@ function startOperation(name, fn, attributes, options, internal = {}) {
       ...parent?.requestId ? { requestId: parent.requestId } : {}
     }
   );
+  if (linked && parent) state.breadcrumbs = parent.breadcrumbs ??= new BreadcrumbTrail();
   const operation = operationHandle(state);
   const run = () => local.run(state, async () => {
     let thrown;
@@ -1530,7 +1712,8 @@ function startOperation(name, fn, attributes, options, internal = {}) {
       state.outcome = "failed";
       thrown = error;
       noteOperationError(error, true, state);
-      config?.captureThrown?.(error);
+      rememberThrownBreadcrumbs(error, state);
+      shared.config?.captureThrown?.(error);
       throw error;
     } finally {
       trace.getActiveSpan()?.setAttributes({
@@ -1539,7 +1722,7 @@ function startOperation(name, fn, attributes, options, internal = {}) {
         "autter.operation.kind": state.kind
       });
       if (state.outcome === "failed" && !thrown)
-        config?.reportOutcome(
+        shared.config?.reportOutcome(
           state.name,
           state.message ?? "Operation failed",
           {
@@ -1560,7 +1743,7 @@ function startOperation(name, fn, attributes, options, internal = {}) {
       }
     }
   ] : [];
-  const promise = config?.run ? config.run(state.name, run, traceAttributes(state), links) : run();
+  const promise = shared.config?.run ? shared.config.run(state.name, run, traceAttributes(state), links) : run();
   if (!options.waitUntil) return promise;
   const waitUntil = options.waitUntil;
   return promise.finally(() => {
@@ -1634,6 +1817,88 @@ var runtimeContext = {
   }
 };
 
+// src/breadcrumbs.ts
+var INVALID_TRACE_ID = "00000000000000000000000000000000";
+var MAX_TRACE_TRAILS = 200;
+var trails = sharedSlot("breadcrumbs", () => ({
+  byTrace: /* @__PURE__ */ new Map(),
+  process: new BreadcrumbTrail(),
+  thrown: /* @__PURE__ */ new WeakMap()
+}));
+var byTrace = trails.byTrace;
+var processTrail = trails.process;
+var thrownTrails = trails.thrown;
+function redact2(attributes) {
+  return loggerConfigured()?.redact(attributes) ?? redactAttributes(attributes);
+}
+function trailFor(create, state = local.getStore()) {
+  if (state) {
+    if (!state.breadcrumbs && create) state.breadcrumbs = new BreadcrumbTrail();
+    return state.breadcrumbs;
+  }
+  const traceId = trace2.getActiveSpan()?.spanContext().traceId;
+  if (traceId && traceId !== INVALID_TRACE_ID) {
+    let trail = byTrace.get(traceId);
+    if (!trail && create) {
+      trail = new BreadcrumbTrail();
+      byTrace.set(traceId, trail);
+      if (byTrace.size > MAX_TRACE_TRAILS) {
+        const oldest = byTrace.keys().next().value;
+        if (oldest !== void 0) byTrace.delete(oldest);
+      }
+    }
+    return trail;
+  }
+  return processTrail;
+}
+function addBreadcrumb(input) {
+  try {
+    const crumb = normalizeBreadcrumb(input, redact2);
+    if (!crumb) return;
+    trailFor(true)?.add(crumb);
+    noteCompatFeature("breadcrumbs");
+  } catch {
+  }
+}
+function recordLogBreadcrumb(level, message, attributes, state) {
+  try {
+    const data = {};
+    let count = 0;
+    for (const [key, value] of Object.entries(attributes)) {
+      if (count >= 10) break;
+      if (/^(?:exception|autter)\./.test(key)) continue;
+      if (value === null || ["string", "number", "boolean"].includes(typeof value)) {
+        data[key] = value;
+        count++;
+      }
+    }
+    const crumb = normalizeBreadcrumb({ type: "log", level, message, data }, redact2);
+    if (crumb) trailFor(true, state)?.add(crumb);
+  } catch {
+  }
+}
+function attributeBudget() {
+  const limit = Number(
+    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;
+}
+function rememberThrownBreadcrumbs(error, state) {
+  if (state.breadcrumbs && error !== null && (typeof error === "object" || typeof error === "function"))
+    thrownTrails.set(error, state.breadcrumbs);
+}
+function breadcrumbEventAttributes(scrub, error) {
+  try {
+    const thrown = error !== null && typeof error === "object" ? thrownTrails.get(error) : void 0;
+    const trail = thrown ?? trailFor(false);
+    if (!trail?.size) return {};
+    const json = breadcrumbsAttribute(trail.list(), scrub, attributeBudget());
+    return json ? { [BREADCRUMBS_ATTRIBUTE]: json } : {};
+  } catch {
+    return {};
+  }
+}
+
 export {
   redactAttributes,
   redactText,
@@ -1641,6 +1906,7 @@ export {
   CODE_PATTERN,
   RuntimeError,
   defineRuntimeErrors,
+  isError,
   isRuntimeErrorLike,
   errorCodeOf,
   errorAttributes,
@@ -1654,6 +1920,12 @@ export {
   compileIgnore,
   requestOutcome,
   parseUserAgent,
+  sanitizeBreadcrumbs,
+  fingerprintValues,
+  fingerprintEventAttributes,
+  splitFingerprint,
+  addBreadcrumb,
+  breadcrumbEventAttributes,
   otlpSink,
   consoleSink,
   fileSink,

package/dist/{chunk-L6SRL65J.cjs → chunk-7OTD2YPT.cjs}

@@ -5,7 +5,7 @@
 
 
 
-var _chunkGI47WGRRcjs = require('./chunk-GI47WGRR.cjs');
+var _chunk4MVWIRBIcjs = require('./chunk-4MVWIRBI.cjs');
 
 // src/doctor.ts
 var _fs = require('fs');
@@ -30,19 +30,19 @@ function installedSdks(cwd) {
     }
     if (_path.dirname.call(void 0, dir) === dir) break;
   }
-  if (!found.has(_chunkGI47WGRRcjs.SDK_IDENTITY.name)) found.set(_chunkGI47WGRRcjs.SDK_IDENTITY.name, _chunkGI47WGRRcjs.SDK_IDENTITY.version);
+  if (!found.has(_chunk4MVWIRBIcjs.SDK_IDENTITY.name)) found.set(_chunk4MVWIRBIcjs.SDK_IDENTITY.name, _chunk4MVWIRBIcjs.SDK_IDENTITY.version);
   return [...found].map(([name, version]) => ({ name, version }));
 }
 function featuresInUse(sdks) {
-  return _chunkGI47WGRRcjs.COMPAT_MANIFEST.features.filter(
+  return _chunk4MVWIRBIcjs.COMPAT_MANIFEST.features.filter(
     (feature) => sdks.some((sdk) => {
       const min = feature.sdks[sdk.name];
-      return min !== void 0 && _chunkGI47WGRRcjs.versionAtLeast.call(void 0, sdk.version, min) === true;
+      return min !== void 0 && _chunk4MVWIRBIcjs.versionAtLeast.call(void 0, sdk.version, min) === true;
     })
   ).map((feature) => feature.id);
 }
 async function checkKey(endpoint, key, timeoutMs) {
-  const res = await _chunkGI47WGRRcjs.compatRequest.call(void 0, "POST", `${endpoint}/v1/traces`, {
+  const res = await _chunk4MVWIRBIcjs.compatRequest.call(void 0, "POST", `${endpoint}/v1/traces`, {
     body: JSON.stringify({ resourceSpans: [] }),
     headers: { authorization: `Bearer ${key}` },
     unref: false,
@@ -62,10 +62,10 @@ async function runDoctor(options = {}) {
   const features = _optionalChain([options, 'access', _ => _.features, 'optionalAccess', _2 => _2.length]) ? options.features : featuresInUse(sdks);
   const routes = [
     ...new Set(
-      features.map((id) => _optionalChain([_chunkGI47WGRRcjs.COMPAT_MANIFEST, 'access', _3 => _3.features, 'access', _4 => _4.find, 'call', _5 => _5((f) => f.id === id), 'optionalAccess', _6 => _6.route])).filter((route) => Boolean(route))
+      features.map((id) => _optionalChain([_chunk4MVWIRBIcjs.COMPAT_MANIFEST, 'access', _3 => _3.features, 'access', _4 => _4.find, 'call', _5 => _5((f) => f.id === id), 'optionalAccess', _6 => _6.route])).filter((route) => Boolean(route))
     )
   ];
-  const { info, error } = await _chunkGI47WGRRcjs.fetchIngesterCompat.call(void 0, endpoint, { probeRoutes: routes, unref: false, timeoutMs });
+  const { info, error } = await _chunk4MVWIRBIcjs.fetchIngesterCompat.call(void 0, endpoint, { probeRoutes: routes, unref: false, timeoutMs });
   const issues = [];
   const seen = /* @__PURE__ */ new Set();
   const add = (issue) => {
@@ -75,15 +75,15 @@ async function runDoctor(options = {}) {
       issues.push(issue);
     }
   };
-  _chunkGI47WGRRcjs.evaluateCompat.call(void 0, { features, ingester: info }).forEach(add);
+  _chunk4MVWIRBIcjs.evaluateCompat.call(void 0, { features, ingester: info }).forEach(add);
   for (const sdk of sdks) {
     if (_optionalChain([options, 'access', _7 => _7.features, 'optionalAccess', _8 => _8.length])) {
-      _chunkGI47WGRRcjs.evaluateCompat.call(void 0, { features: options.features, ingester: null, sdk }).forEach(add);
+      _chunk4MVWIRBIcjs.evaluateCompat.call(void 0, { features: options.features, ingester: null, sdk }).forEach(add);
     }
   }
   const key = options.key ? await checkKey(endpoint, options.key, timeoutMs) : void 0;
   const featureRows = features.flatMap((id) => {
-    const feature = _chunkGI47WGRRcjs.COMPAT_MANIFEST.features.find((f) => f.id === id);
+    const feature = _chunk4MVWIRBIcjs.COMPAT_MANIFEST.features.find((f) => f.id === id);
     if (!feature) return [];
     const bad = issues.some((issue) => issue.feature === id);
     const known = _optionalChain([info, 'optionalAccess', _9 => _9.version]) != null || feature.route !== void 0 && _optionalChain([info, 'optionalAccess', _10 => _10.routes, 'optionalAccess', _11 => _11[feature.route]]) !== void 0;
@@ -153,7 +153,7 @@ Checks that your Autter SDKs, ingester and ClickHouse schema versions match.
 Options:
   --endpoint <url>    Ingester base URL (default: $AUTTER_ENDPOINT, $OTEL_EXPORTER_OTLP_ENDPOINT, or ${DEFAULT_ENDPOINT})
   --key <key>         Also verify an ingest key (default: $AUTTER_RUNTIME_KEY)
-  --features <a,b>    Only check these features (${_chunkGI47WGRRcjs.COMPAT_MANIFEST.features.map((f) => f.id).join(", ")})
+  --features <a,b>    Only check these features (${_chunk4MVWIRBIcjs.COMPAT_MANIFEST.features.map((f) => f.id).join(", ")})
   --json              Machine-readable output
   --timeout <ms>      Per-request timeout (default 5000)