crumbtrail-core 0.1.0

package/dist/index.cjs

@@ -0,0 +1,4867 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/widget/styles.ts
+var WIDGET_CSS;
+var init_styles = __esm({
+  "src/widget/styles.ts"() {
+    "use strict";
+    WIDGET_CSS = `
+  :host {
+    all: initial;
+    font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+    font-size: 14px;
+    color: #e0e0e0;
+  }
+
+  .bl-trigger {
+    position: fixed;
+    bottom: 20px;
+    right: 20px;
+    width: 48px;
+    height: 48px;
+    border-radius: 50%;
+    background: #dc2626;
+    border: none;
+    cursor: pointer;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    box-shadow: 0 2px 8px rgba(0,0,0,0.3);
+    z-index: 2147483647;
+    transition: transform 0.15s ease, background 0.15s ease;
+  }
+  .bl-trigger:hover {
+    transform: scale(1.1);
+    background: #ef4444;
+  }
+  .bl-trigger svg {
+    width: 24px;
+    height: 24px;
+    fill: white;
+  }
+
+  .bl-popover {
+    position: fixed;
+    bottom: 80px;
+    right: 20px;
+    width: 320px;
+    background: #1e1e1e;
+    border: 1px solid #333;
+    border-radius: 12px;
+    box-shadow: 0 8px 32px rgba(0,0,0,0.4);
+    z-index: 2147483647;
+    padding: 16px;
+    display: none;
+  }
+  .bl-popover.open {
+    display: block;
+  }
+
+  .bl-popover h3 {
+    margin: 0 0 12px;
+    font-size: 15px;
+    font-weight: 600;
+    color: #f5f5f5;
+  }
+
+  .bl-note {
+    width: 100%;
+    min-height: 60px;
+    background: #2a2a2a;
+    border: 1px solid #444;
+    border-radius: 8px;
+    color: #e0e0e0;
+    padding: 8px 10px;
+    font-size: 13px;
+    font-family: inherit;
+    resize: vertical;
+    box-sizing: border-box;
+  }
+  .bl-note::placeholder {
+    color: #777;
+  }
+  .bl-note:focus {
+    outline: none;
+    border-color: #dc2626;
+  }
+
+  .bl-actions {
+    display: flex;
+    gap: 8px;
+    margin-top: 12px;
+    align-items: center;
+  }
+
+  .bl-btn {
+    padding: 8px 16px;
+    border-radius: 8px;
+    border: none;
+    cursor: pointer;
+    font-size: 13px;
+    font-weight: 500;
+    transition: background 0.15s ease;
+  }
+  .bl-submit {
+    background: #dc2626;
+    color: white;
+    flex: 1;
+  }
+  .bl-submit:hover {
+    background: #ef4444;
+  }
+  .bl-submit:disabled {
+    opacity: 0.5;
+    cursor: not-allowed;
+  }
+
+  .bl-status {
+    font-size: 11px;
+    color: #777;
+    margin-top: 8px;
+  }
+
+  .bl-hint {
+    font-size: 11px;
+    color: #555;
+    margin-top: 8px;
+    text-align: center;
+  }
+`;
+  }
+});
+
+// src/widget/bug-widget.ts
+var bug_widget_exports = {};
+__export(bug_widget_exports, {
+  mountWidget: () => mountWidget
+});
+function mountWidget(logger) {
+  const host = document.createElement("div");
+  host.id = "crumbtrail-widget";
+  const shadow = host.attachShadow({ mode: "closed" });
+  const style = document.createElement("style");
+  style.textContent = WIDGET_CSS;
+  shadow.appendChild(style);
+  const trigger = document.createElement("button");
+  trigger.className = "bl-trigger";
+  trigger.innerHTML = BUG_SVG;
+  trigger.title = "Flag a bug (Ctrl+Shift+B)";
+  shadow.appendChild(trigger);
+  const popover = document.createElement("div");
+  popover.className = "bl-popover";
+  popover.innerHTML = `
+    <h3>Flag a Bug</h3>
+    <textarea class="bl-note" placeholder="What went wrong? (optional)"></textarea>
+    <div class="bl-actions">
+      <button class="bl-btn bl-submit">Send Bug Report</button>
+    </div>
+    <div class="bl-status"></div>
+    <div class="bl-hint">Ctrl+Shift+B to toggle</div>
+  `;
+  shadow.appendChild(popover);
+  const noteInput = popover.querySelector(".bl-note");
+  const submitBtn = popover.querySelector(".bl-submit");
+  const statusEl = popover.querySelector(".bl-status");
+  let isOpen = false;
+  function toggle() {
+    isOpen = !isOpen;
+    popover.classList.toggle("open", isOpen);
+    if (isOpen) {
+      noteInput.focus();
+    } else {
+      reset();
+    }
+  }
+  function reset() {
+    noteInput.value = "";
+    statusEl.textContent = "";
+  }
+  trigger.addEventListener("click", toggle);
+  submitBtn.addEventListener("click", async () => {
+    submitBtn.disabled = true;
+    statusEl.textContent = "Sending...";
+    try {
+      const { bugId } = await logger.flagBug({
+        note: noteInput.value || void 0
+      });
+      statusEl.textContent = `Saved: ${bugId}`;
+      setTimeout(() => {
+        toggle();
+        submitBtn.disabled = false;
+      }, 1500);
+    } catch {
+      statusEl.textContent = "Failed to send";
+      submitBtn.disabled = false;
+    }
+  });
+  function onKeyDown(e) {
+    if (e.ctrlKey && e.shiftKey && e.key === "B") {
+      e.preventDefault();
+      toggle();
+    }
+  }
+  document.addEventListener("keydown", onKeyDown);
+  document.body.appendChild(host);
+  return () => {
+    document.removeEventListener("keydown", onKeyDown);
+    host.remove();
+  };
+}
+var BUG_SVG;
+var init_bug_widget = __esm({
+  "src/widget/bug-widget.ts"() {
+    "use strict";
+    init_styles();
+    BUG_SVG = `<svg viewBox="0 0 24 24"><path d="M20 8h-2.81a5.985 5.985 0 0 0-1.82-1.96L17 4.41 15.59 3l-2.17 2.17C12.96 5.06 12.49 5 12 5s-.96.06-1.41.17L8.41 3 7 4.41l1.62 1.63C7.88 6.55 7.26 7.22 6.81 8H4v2h2.09c-.05.33-.09.66-.09 1v1H4v2h2v1c0 .34.04.67.09 1H4v2h2.81c1.04 1.79 2.97 3 5.19 3s4.15-1.21 5.19-3H20v-2h-2.09c.05-.33.09-.66.09-1v-1h2v-2h-2v-1c0-.34-.04-.67-.09-1H20V8zm-6 8h-4v-2h4v2zm0-4h-4v-2h4v2z"/></svg>`;
+  }
+});
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  BROWSER_REDACTION_POLICY: () => BROWSER_REDACTION_POLICY,
+  CRUMBTRAIL_EVENT_KINDS: () => CRUMBTRAIL_EVENT_KINDS,
+  CRUMBTRAIL_REQUEST_HEADER: () => CRUMBTRAIL_REQUEST_HEADER,
+  CRUMBTRAIL_REQUEST_HEADER_LOWER: () => CRUMBTRAIL_REQUEST_HEADER_LOWER,
+  CRUMBTRAIL_REQUEST_ID_MAX_LENGTH: () => CRUMBTRAIL_REQUEST_ID_MAX_LENGTH,
+  CRUMBTRAIL_SCHEMA_VERSION: () => CRUMBTRAIL_SCHEMA_VERSION,
+  CRUMBTRAIL_SESSION_HEADER: () => CRUMBTRAIL_SESSION_HEADER,
+  CRUMBTRAIL_SESSION_HEADER_LOWER: () => CRUMBTRAIL_SESSION_HEADER_LOWER,
+  Crumbtrail: () => Crumbtrail,
+  DB_DIFF_BULK_EVENT_KIND: () => DB_DIFF_BULK_EVENT_KIND,
+  DB_DIFF_EVENT_KIND: () => DB_DIFF_EVENT_KIND,
+  DB_READ_BULK_EVENT_KIND: () => DB_READ_BULK_EVENT_KIND,
+  DB_READ_EVENT_KIND: () => DB_READ_EVENT_KIND,
+  DEFAULT_CONFIG: () => DEFAULT_CONFIG,
+  DEFAULT_SESSION_STORAGE_KEY: () => DEFAULT_SESSION_STORAGE_KEY,
+  EVIDENCE_SCHEMA_VERSION: () => EVIDENCE_SCHEMA_VERSION,
+  EVIDENCE_SOURCE_SCHEMA_VERSION: () => EVIDENCE_SOURCE_SCHEMA_VERSION,
+  EventBus: () => EventBus,
+  FUSION_SCHEMA_VERSION: () => FUSION_SCHEMA_VERSION,
+  HttpTransport: () => HttpTransport,
+  PRESET_FULL: () => PRESET_FULL,
+  PRESET_LIGHT: () => PRESET_LIGHT,
+  PRESET_PASSIVE: () => PRESET_PASSIVE,
+  REDACTED_STORAGE_KEY: () => REDACTED_STORAGE_KEY,
+  REDACTED_VALUE: () => REDACTED_VALUE,
+  RingBuffer: () => RingBuffer,
+  W3C_TRACEPARENT_HEADER: () => W3C_TRACEPARENT_HEADER,
+  WebTargetDescriptorResolver: () => WebTargetDescriptorResolver,
+  abandonedFlowDetector: () => abandonedFlowDetector,
+  assembleBundle: () => assembleBundle,
+  attachRedactionMetadata: () => attachRedactionMetadata,
+  buildEnvDelta: () => buildEnvDelta,
+  buildEnvSnapshot: () => buildEnvSnapshot,
+  canInjectCorrelationHeaders: () => canInjectCorrelationHeaders,
+  computeElementPath: () => computeElementPath,
+  computeElementSignature: () => computeElementSignature,
+  createAutoFlagController: () => createAutoFlagController,
+  createCrumbtrailRequestHeaders: () => createCrumbtrailRequestHeaders,
+  createWebSessionStore: () => createWebSessionStore,
+  environmentCollector: () => environmentCollector,
+  errorDetector: () => errorDetector,
+  errorSignature: () => errorSignature,
+  formatTraceparent: () => formatTraceparent,
+  generateRequestId: () => generateRequestId,
+  generateSpanId: () => generateSpanId,
+  generateTraceContext: () => generateTraceContext,
+  generateTraceId: () => generateTraceId,
+  hashString: () => hashString,
+  inferIntent: () => inferIntent,
+  mergeRedactionMetadata: () => mergeRedactionMetadata,
+  parseTraceparent: () => parseTraceparent,
+  rageClickDetector: () => rageClickDetector,
+  redactCookieMap: () => redactCookieMap,
+  redactCookieName: () => redactCookieName,
+  redactCookieValue: () => redactCookieValue,
+  redactHeaders: () => redactHeaders,
+  redactInputValue: () => redactInputValue,
+  redactNetworkTextBody: () => redactNetworkTextBody,
+  redactStorageKey: () => redactStorageKey,
+  redactStoredValue: () => redactStoredValue,
+  redactTokenLikeString: () => redactTokenLikeString,
+  redactUrl: () => redactUrl,
+  redactUrlsInText: () => redactUrlsInText,
+  redactValue: () => redactValue,
+  resolveOutboundCorrelation: () => resolveOutboundCorrelation,
+  retryStormDetector: () => retryStormDetector,
+  slowResponseDetector: () => slowResponseDetector,
+  summarizeBinaryPayload: () => summarizeBinaryPayload,
+  summarizeOmittedPayload: () => summarizeOmittedPayload,
+  webTargetDescriptorResolver: () => webTargetDescriptorResolver
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/event-bus.ts
+var EventBus = class {
+  listeners = [];
+  taps = [];
+  buffer = [];
+  flushTimer = null;
+  paused = false;
+  flushBufferSize = 100;
+  emit(event) {
+    for (const tap of this.taps) {
+      try {
+        tap(event);
+      } catch {
+      }
+    }
+    this.buffer.push(event);
+    if (!this.paused && this.buffer.length >= this.flushBufferSize) {
+      this.flush();
+    }
+  }
+  /**
+   * Observe every event synchronously at emit time, before batching. Unlike `subscribe`,
+   * taps see events immediately (triggers can't wait out a flush interval) and never
+   * receive batches.
+   */
+  tap(fn) {
+    this.taps.push(fn);
+    return () => {
+      const idx = this.taps.indexOf(fn);
+      if (idx !== -1) this.taps.splice(idx, 1);
+    };
+  }
+  subscribe(fn) {
+    this.listeners.push(fn);
+    return () => {
+      const idx = this.listeners.indexOf(fn);
+      if (idx !== -1) this.listeners.splice(idx, 1);
+    };
+  }
+  flush() {
+    if (this.buffer.length === 0) return;
+    const batch = this.buffer;
+    this.buffer = [];
+    for (const listener of this.listeners) {
+      listener(batch);
+    }
+  }
+  start(flushIntervalMs, flushBufferSize) {
+    this.flushBufferSize = flushBufferSize;
+    this.flushTimer = setInterval(() => {
+      if (!this.paused) this.flush();
+    }, flushIntervalMs);
+  }
+  stop() {
+    if (this.flushTimer !== null) {
+      clearInterval(this.flushTimer);
+      this.flushTimer = null;
+    }
+    this.flush();
+  }
+  pause() {
+    this.paused = true;
+  }
+  resume() {
+    this.paused = false;
+    this.flush();
+  }
+};
+
+// src/ring-buffer.ts
+var RingBuffer = class {
+  events = [];
+  maxMs;
+  maxEvents;
+  constructor(maxMs = 3e5, maxEvents = 5e4) {
+    this.maxMs = maxMs;
+    this.maxEvents = maxEvents;
+  }
+  push(event) {
+    this.events.push(event);
+    this.evict(event.t);
+  }
+  pushBatch(events) {
+    for (const event of events) {
+      this.events.push(event);
+    }
+    if (events.length > 0) {
+      this.evict(events[events.length - 1].t);
+    }
+  }
+  snapshot(windowMs) {
+    const now2 = this.events.length > 0 ? this.events[this.events.length - 1].t : Date.now();
+    const cutoff = now2 - (windowMs ?? this.maxMs);
+    return this.events.filter((e) => e.t >= cutoff);
+  }
+  clear() {
+    this.events = [];
+  }
+  get size() {
+    return this.events.length;
+  }
+  evict(now2) {
+    const cutoff = now2 - this.maxMs;
+    while (this.events.length > 0 && this.events[0].t < cutoff) {
+      this.events.shift();
+    }
+    while (this.events.length > this.maxEvents) {
+      this.events.shift();
+    }
+  }
+};
+
+// src/types.ts
+var CRUMBTRAIL_SCHEMA_VERSION = 1;
+var CRUMBTRAIL_EVENT_KINDS = {
+  navigation: "navigation",
+  appLifecycle: "app-lifecycle",
+  nativeCrash: "native-crash",
+  viewSnapshot: "view-snapshot"
+};
+var DB_DIFF_EVENT_KIND = "db.diff";
+var DB_DIFF_BULK_EVENT_KIND = "db.diff.bulk";
+var DB_READ_EVENT_KIND = "db.read";
+var DB_READ_BULK_EVENT_KIND = "db.read.bulk";
+var DEFAULT_CONFIG = {
+  console: true,
+  network: true,
+  interactions: true,
+  keystrokes: true,
+  scroll: true,
+  visibility: true,
+  clipboard: true,
+  errors: true,
+  performance: true,
+  cookies: true,
+  storage: true,
+  video: false,
+  audio: false,
+  networkMaxBodySize: 51200,
+  networkExcludeUrls: [],
+  networkCaptureHeaders: true,
+  networkCorrelationHeaders: true,
+  networkCorrelationAllowedOrigins: [],
+  maskInputTypes: ["password", "email", "tel", "number", "search", "url"],
+  ignoreSelectors: [],
+  keystrokeThrottleMs: 0,
+  scrollThrottleMs: 500,
+  scrollElements: [],
+  clipboardMaxLength: 500,
+  captureRawClipboard: false,
+  cookiePollIntervalMs: 2e3,
+  cookieMaskNames: [],
+  cookieValueMaxLength: 500,
+  storageValueMaxLength: 500,
+  storageExcludeKeys: [],
+  captureIdb: true,
+  captureCacheApi: true,
+  videoBitsPerSecond: 1e6,
+  audioBitsPerSecond: 64e3,
+  mediaChunkIntervalMs: 1e4,
+  ringBufferMs: 3e5,
+  ringBufferMaxEvents: 5e4,
+  heartbeat: true,
+  environment: true,
+  widget: false,
+  stateMaxBytes: 32768,
+  captureRawState: false,
+  autoFlagOnError: false,
+  autoFlagDebounceMs: 2e3,
+  autoFlagMaxPerSession: 10,
+  autoFlagOnSignals: false,
+  rageClickThreshold: 4,
+  rageClickWindowMs: 1500,
+  retryStormThreshold: 4,
+  retryStormWindowMs: 5e3,
+  retryStormFailThreshold: 2,
+  slowRequestMs: 3e3,
+  slowRequestCount: 3,
+  slowRequestWindowMs: 1e4,
+  abandonedFlowWindowMs: 3e4,
+  abandonedFlowMinInputs: 2,
+  domSnapshot: true,
+  domSnapshotMaxBytes: 262144,
+  captureRawConsole: false,
+  captureRawErrors: false,
+  transport: "auto",
+  httpEndpoint: "http://localhost:9898",
+  httpAuthToken: "",
+  flushIntervalMs: 5e3,
+  flushBufferSize: 100,
+  sessionPersistence: "session",
+  sessionIdleMs: 18e5
+  // 30 minutes
+};
+var PRESET_FULL = {
+  widget: true,
+  autoFlagOnError: true,
+  autoFlagOnSignals: true
+};
+var PRESET_LIGHT = {
+  keystrokes: false,
+  video: false,
+  audio: false,
+  clipboard: false,
+  cookies: false,
+  storage: false,
+  performance: false
+};
+var PRESET_PASSIVE = {
+  autoFlagOnError: true,
+  autoFlagOnSignals: true
+};
+
+// src/correlation.ts
+var CRUMBTRAIL_SESSION_HEADER = "X-Crumbtrail-Session-Id";
+var CRUMBTRAIL_REQUEST_HEADER = "X-Crumbtrail-Request-Id";
+var CRUMBTRAIL_SESSION_HEADER_LOWER = CRUMBTRAIL_SESSION_HEADER.toLowerCase();
+var CRUMBTRAIL_REQUEST_HEADER_LOWER = CRUMBTRAIL_REQUEST_HEADER.toLowerCase();
+var REQUEST_ID_PREFIX = "req";
+var REQUEST_ID_RANDOM_LENGTH = 12;
+var CRUMBTRAIL_REQUEST_ID_MAX_LENGTH = 64;
+function randomBase36(length) {
+  let value = "";
+  while (value.length < length) {
+    value += Math.random().toString(36).slice(2);
+  }
+  return value.slice(0, length);
+}
+function generateRequestId() {
+  return `${REQUEST_ID_PREFIX}_${Date.now().toString(36)}_${randomBase36(REQUEST_ID_RANDOM_LENGTH)}`.slice(
+    0,
+    CRUMBTRAIL_REQUEST_ID_MAX_LENGTH
+  );
+}
+function normalizeRequestId(requestId) {
+  if (requestId && requestId.length <= CRUMBTRAIL_REQUEST_ID_MAX_LENGTH)
+    return requestId;
+  return generateRequestId();
+}
+function createCrumbtrailRequestHeaders(sessionId, requestId) {
+  return {
+    [CRUMBTRAIL_SESSION_HEADER]: sessionId,
+    [CRUMBTRAIL_REQUEST_HEADER]: normalizeRequestId(requestId)
+  };
+}
+var W3C_TRACEPARENT_HEADER = "traceparent";
+var TRACE_ID_RE = /^[0-9a-f]{32}$/;
+var SPAN_ID_RE = /^[0-9a-f]{16}$/;
+var FLAGS_RE = /^[0-9a-f]{2}$/;
+function parseTraceparent(value) {
+  if (!value) return void 0;
+  const parts = value.trim().split("-");
+  if (parts.length !== 4) return void 0;
+  const [version, traceId, spanId, flags] = parts;
+  if (version !== "00") return void 0;
+  if (!TRACE_ID_RE.test(traceId) || traceId === "0".repeat(32))
+    return void 0;
+  if (!SPAN_ID_RE.test(spanId) || spanId === "0".repeat(16)) return void 0;
+  if (!FLAGS_RE.test(flags)) return void 0;
+  return { traceId, spanId, flags: Number.parseInt(flags, 16) };
+}
+function formatTraceparent(ctx) {
+  const flags = (ctx.flags & 255).toString(16).padStart(2, "0");
+  return `00-${ctx.traceId}-${ctx.spanId}-${flags}`;
+}
+var TRACE_FLAG_SAMPLED = 1;
+function randomHex(bytes) {
+  const buf = new Uint8Array(bytes);
+  const c = globalThis.crypto;
+  if (c?.getRandomValues) {
+    c.getRandomValues(buf);
+  } else {
+    for (let i = 0; i < bytes; i++) buf[i] = Math.floor(Math.random() * 256);
+  }
+  let out = "";
+  for (let i = 0; i < bytes; i++) out += buf[i].toString(16).padStart(2, "0");
+  return out;
+}
+function generateTraceId() {
+  let id = randomHex(16);
+  if (id === "0".repeat(32)) id = id.slice(0, 31) + "1";
+  return id;
+}
+function generateSpanId() {
+  let id = randomHex(8);
+  if (id === "0".repeat(16)) id = id.slice(0, 15) + "1";
+  return id;
+}
+function generateTraceContext() {
+  return {
+    traceId: generateTraceId(),
+    spanId: generateSpanId(),
+    flags: TRACE_FLAG_SAMPLED
+  };
+}
+function runtimeOrigin() {
+  try {
+    const origin = globalThis.location?.origin;
+    if (!origin || origin === "null") return void 0;
+    return origin;
+  } catch {
+    return void 0;
+  }
+}
+function urlOrigin(value, baseOrigin) {
+  try {
+    return new URL(value, baseOrigin).origin;
+  } catch {
+    return void 0;
+  }
+}
+function normalizeAllowedOrigin(value) {
+  const trimmed = value.trim();
+  if (!trimmed) return void 0;
+  if (trimmed === "self") return runtimeOrigin();
+  return urlOrigin(trimmed);
+}
+function canInjectCorrelationHeaders(requestUrl, allowedOrigins = []) {
+  const currentOrigin = runtimeOrigin();
+  const requestOrigin = urlOrigin(requestUrl, currentOrigin);
+  if (!requestOrigin) return false;
+  if (currentOrigin && requestOrigin === currentOrigin) return true;
+  return allowedOrigins.some(
+    (origin) => normalizeAllowedOrigin(origin) === requestOrigin
+  );
+}
+function resolveOutboundCorrelation(input) {
+  const existing = parseTraceparent(input.existingTraceparent);
+  const ctx = existing ?? generateTraceContext();
+  const requestId = normalizeRequestId(input.existingRequestId ?? ctx.traceId);
+  return {
+    sessionId: input.sessionId,
+    requestId,
+    traceId: ctx.traceId,
+    spanId: ctx.spanId,
+    traceparent: formatTraceparent(ctx)
+  };
+}
+
+// src/signature.ts
+var STABLE_ID_ATTRS = ["data-bug-id", "data-testid", "data-test", "id"];
+function stableAttr(el) {
+  for (const attr of STABLE_ID_ATTRS) {
+    const value = el.getAttribute?.(attr);
+    if (value) return `${attr}=${value}`;
+  }
+  return void 0;
+}
+function segment(el) {
+  const tag = el.tagName.toLowerCase();
+  const attr = stableAttr(el);
+  if (attr) return `${tag}[${attr}]`;
+  const parent = el.parentElement;
+  if (!parent) return tag;
+  let index = 1;
+  for (const sibling of Array.from(parent.children)) {
+    if (sibling === el) break;
+    if (sibling.tagName === el.tagName) index++;
+  }
+  return `${tag}:nth-of-type(${index})`;
+}
+function computeElementPath(el) {
+  const parts = [];
+  let current = el;
+  let guard = 0;
+  while (current && guard++ < 50) {
+    const seg = segment(current);
+    parts.unshift(seg);
+    if (seg.includes("[")) break;
+    current = current.parentElement;
+  }
+  return parts.join(">");
+}
+function hashString(input) {
+  let hash = 2166136261;
+  for (let i = 0; i < input.length; i++) {
+    hash ^= input.charCodeAt(i);
+    hash = Math.imul(hash, 16777619);
+  }
+  return (hash >>> 0).toString(36);
+}
+function computeElementSignature(el) {
+  const path = computeElementPath(el);
+  return { path, sig: hashString(path) };
+}
+
+// src/signals.ts
+var SIGNATURE_STACK_LINES = 3;
+function errorSignature(event) {
+  const msg = typeof event.d.msg === "string" ? event.d.msg : "";
+  const stk = typeof event.d.stk === "string" ? event.d.stk : "";
+  const frames = stk.split("\n").slice(0, SIGNATURE_STACK_LINES).join("\n");
+  return hashString(`${event.k}|${msg}|${frames}`);
+}
+function errorDetector() {
+  return {
+    inspect(event) {
+      if (event.k !== "err" && event.k !== "rej") return null;
+      const msg = typeof event.d.msg === "string" ? event.d.msg : void 0;
+      return {
+        tag: "auto:error",
+        key: `err:${errorSignature(event)}`,
+        note: msg ? `Auto-captured after error: ${msg}` : "Auto-captured after error"
+      };
+    }
+  };
+}
+function slide(bucket, ts, windowMs) {
+  const arr = (bucket ?? []).filter((t) => ts - t < windowMs);
+  arr.push(ts);
+  return arr;
+}
+function targetKey(el) {
+  if (el && typeof el === "object") {
+    const r = el;
+    for (const field of [
+      "sig",
+      "ancestryHash",
+      "testID",
+      "testId",
+      "id",
+      "path"
+    ]) {
+      const v = r[field];
+      if (typeof v === "string" && v) return `${field}:${v}`;
+    }
+    const tag = typeof r.tag === "string" ? r.tag : "?";
+    const txt = typeof r.txt === "string" ? r.txt : typeof r.label === "string" ? r.label : "";
+    return `el:${tag}:${txt}`;
+  }
+  return "el:unknown";
+}
+function rageClickDetector(opts) {
+  const hits = /* @__PURE__ */ new Map();
+  return {
+    inspect(event) {
+      if (event.k !== "clk") return null;
+      const key = targetKey(event.d.el ?? event.target);
+      const arr = slide(hits.get(key), event.t, opts.windowMs);
+      if (arr.length >= opts.threshold) {
+        hits.set(key, []);
+        const label = key.replace(/^[a-zA-Z]+:/, "") || "an element";
+        return {
+          tag: "auto:rage-click",
+          key: `rage:${key}`,
+          note: `Auto-captured after ${arr.length} rapid clicks on ${label}`
+        };
+      }
+      hits.set(key, arr);
+      return null;
+    }
+  };
+}
+function endpointKey(method, url) {
+  const m = typeof method === "string" ? method.toUpperCase() : "GET";
+  let u = typeof url === "string" ? url : "";
+  const q = u.indexOf("?");
+  if (q >= 0) u = u.slice(0, q);
+  return `${m} ${u}`;
+}
+var MAX_TRACKED_REQUESTS = 1024;
+function retryStormDetector(opts) {
+  const failThreshold = opts.failThreshold ?? 2;
+  const endpointOf = /* @__PURE__ */ new Map();
+  const reqHits = /* @__PURE__ */ new Map();
+  const failHits = /* @__PURE__ */ new Map();
+  const tripped = (key, count) => ({
+    tag: "auto:retry-storm",
+    key: `retry:${key}`,
+    note: `Auto-captured after ${count} rapid requests to ${key}`
+  });
+  return {
+    inspect(event) {
+      if (event.k === "net.req") {
+        const key = endpointKey(event.d.method, event.d.url);
+        if (typeof event.d.id === "number") {
+          endpointOf.set(event.d.id, key);
+          if (endpointOf.size > MAX_TRACKED_REQUESTS) {
+            const oldest = endpointOf.keys().next().value;
+            if (oldest !== void 0) endpointOf.delete(oldest);
+          }
+        }
+        const arr = slide(reqHits.get(key), event.t, opts.windowMs);
+        if (arr.length >= opts.threshold) {
+          reqHits.set(key, []);
+          return tripped(key, arr.length);
+        }
+        reqHits.set(key, arr);
+        return null;
+      }
+      if (event.k === "net.res") {
+        const id = typeof event.d.id === "number" ? event.d.id : void 0;
+        const key = id !== void 0 ? endpointOf.get(id) : void 0;
+        if (id !== void 0) endpointOf.delete(id);
+        const st = typeof event.d.st === "number" ? event.d.st : 0;
+        if (st < 400) return null;
+        if (!key) return null;
+        const arr = slide(failHits.get(key), event.t, opts.windowMs);
+        if (arr.length >= failThreshold) {
+          failHits.set(key, []);
+          return tripped(key, arr.length);
+        }
+        failHits.set(key, arr);
+        return null;
+      }
+      return null;
+    }
+  };
+}
+function slowResponseDetector(opts) {
+  let hits = [];
+  return {
+    inspect(event) {
+      if (event.k !== "net.res") return null;
+      const dur = typeof event.d.dur === "number" ? event.d.dur : 0;
+      if (dur < opts.thresholdMs) return null;
+      hits = slide(hits, event.t, opts.windowMs);
+      if (hits.length >= opts.count) {
+        hits = [];
+        return {
+          tag: "auto:slow-responses",
+          key: "slow:session",
+          note: `Auto-captured after ${opts.count}+ responses slower than ${opts.thresholdMs}ms`
+        };
+      }
+      return null;
+    }
+  };
+}
+var MUTATING_METHODS = /* @__PURE__ */ new Set(["POST", "PUT", "PATCH", "DELETE"]);
+function abandonedFlowDetector(opts) {
+  let inputCount = 0;
+  let lastInputAt = -Infinity;
+  const reset = () => {
+    inputCount = 0;
+    lastInputAt = -Infinity;
+  };
+  return {
+    inspect(event) {
+      if (event.k === "inp") {
+        inputCount += 1;
+        lastInputAt = event.t;
+        return null;
+      }
+      if (event.k === "net.req") {
+        const method = typeof event.d.method === "string" ? event.d.method.toUpperCase() : "GET";
+        if (MUTATING_METHODS.has(method)) reset();
+        return null;
+      }
+      if (event.k === "vis" && event.d.state === "hidden") {
+        if (inputCount >= opts.minInputs && event.t - lastInputAt <= opts.windowMs) {
+          const count = inputCount;
+          reset();
+          return {
+            tag: "auto:abandoned-flow",
+            key: "abandoned:flow",
+            note: `Auto-captured after the page was hidden with ${count} unsubmitted input(s)`
+          };
+        }
+        return null;
+      }
+      return null;
+    }
+  };
+}
+
+// src/auto-flag.ts
+function createAutoFlagController(options) {
+  const detectors = options.detectors ?? [errorDetector()];
+  const seen = /* @__PURE__ */ new Set();
+  let flaggedCount = 0;
+  let timer = null;
+  let pending;
+  let disposed = false;
+  const fire = () => {
+    timer = null;
+    const signal = pending;
+    pending = void 0;
+    if (!signal) return;
+    flaggedCount++;
+    options.flag({ tags: [signal.tag], note: signal.note }).catch(() => {
+    });
+  };
+  return {
+    handleEvent(event) {
+      if (disposed) return;
+      if (flaggedCount >= options.maxPerSession) return;
+      for (const detector of detectors) {
+        const signal = detector.inspect(event);
+        if (!signal) continue;
+        if (seen.has(signal.key)) continue;
+        seen.add(signal.key);
+        if (pending === void 0) pending = signal;
+        if (timer !== null) clearTimeout(timer);
+        timer = setTimeout(fire, options.debounceMs);
+      }
+    },
+    dispose() {
+      disposed = true;
+      if (timer !== null) {
+        clearTimeout(timer);
+        timer = null;
+      }
+    }
+  };
+}
+
+// src/utils.ts
+function safeStringify(value, maxDepth = 3) {
+  const seen = /* @__PURE__ */ new WeakSet();
+  function process(val, depth) {
+    if (val === null || val === void 0) return val;
+    const type = typeof val;
+    if (type === "string" || type === "number" || type === "boolean")
+      return val;
+    if (type === "bigint") return val.toString();
+    if (type === "symbol") return val.toString();
+    if (type === "function")
+      return `[Function: ${val.name || "anonymous"}]`;
+    if (seen.has(val)) return "[Circular]";
+    if (depth > maxDepth) {
+      return Array.isArray(val) ? `[Array(${val.length})]` : "[Object]";
+    }
+    seen.add(val);
+    if (val instanceof Error) {
+      return { name: val.name, message: val.message, stack: val.stack };
+    }
+    if (Array.isArray(val)) {
+      return val.map((v) => process(v, depth + 1));
+    }
+    const out = {};
+    for (const k of Object.keys(val)) {
+      out[k] = process(val[k], depth + 1);
+    }
+    return out;
+  }
+  try {
+    return JSON.stringify(process(value, 0));
+  } catch {
+    try {
+      return String(value);
+    } catch {
+      return "[Unserializable]";
+    }
+  }
+}
+function truncate(str, maxLen) {
+  if (str.length <= maxLen) return str;
+  return str.slice(0, maxLen);
+}
+function describeElement(el) {
+  const desc = { tag: el.tagName };
+  if (el.id) desc.id = el.id;
+  if (el.className && typeof el.className === "string") {
+    desc.cls = truncate(el.className, 200);
+  }
+  if (el instanceof HTMLElement) {
+    const txt = el.innerText ?? el.textContent;
+    if (txt) desc.txt = truncate(txt.trim(), 100);
+  }
+  if (el instanceof HTMLAnchorElement) {
+    desc.href = el.href;
+  }
+  if (el instanceof HTMLInputElement || el instanceof HTMLTextAreaElement || el instanceof HTMLSelectElement) {
+    if (el.name) desc.name = el.name;
+  }
+  if (el instanceof HTMLInputElement) {
+    if (el.type) desc.type = el.type;
+  }
+  try {
+    const signature = computeElementSignature(el);
+    desc.sig = signature.sig;
+    desc.path = signature.path;
+  } catch {
+  }
+  return desc;
+}
+function generateSessionId() {
+  const d = /* @__PURE__ */ new Date();
+  const p = (n, len = 2) => String(n).padStart(len, "0");
+  return `ses_${d.getFullYear()}${p(d.getMonth() + 1)}${p(d.getDate())}_${p(d.getHours())}${p(d.getMinutes())}${p(d.getSeconds())}_${randomHex2(6)}`;
+}
+function randomHex2(byteLength) {
+  const bytes = new Uint8Array(byteLength);
+  if (!globalThis.crypto?.getRandomValues) {
+    throw new Error(
+      "Crumbtrail requires crypto.getRandomValues to generate session IDs safely"
+    );
+  }
+  globalThis.crypto.getRandomValues(bytes);
+  return Array.from(bytes, (byte) => byte.toString(16).padStart(2, "0")).join(
+    ""
+  );
+}
+function now() {
+  return Date.now();
+}
+
+// src/transports/http.ts
+var KEEPALIVE_MAX_BYTES = 6e4;
+function utf8ByteLength(text) {
+  if (typeof TextEncoder !== "undefined") {
+    return new TextEncoder().encode(text).byteLength;
+  }
+  return text.length;
+}
+var HttpTransport = class {
+  sessionId = "";
+  authToken;
+  endpoint;
+  constructor(endpoint, options) {
+    this.endpoint = endpoint.replace(/\/+$/, "");
+    this.authToken = options?.authToken;
+  }
+  withAuthHeaders(headers) {
+    if (!this.authToken) return headers;
+    return { ...headers, "X-Crumbtrail-Auth": this.authToken };
+  }
+  async sendEvents(events) {
+    const body = JSON.stringify({ sessionId: this.sessionId, events });
+    const init = {
+      method: "POST",
+      headers: this.withAuthHeaders({ "Content-Type": "application/json" }),
+      body
+    };
+    if (utf8ByteLength(body) <= KEEPALIVE_MAX_BYTES) init.keepalive = true;
+    try {
+      await fetch(`${this.endpoint}/api/events`, init);
+    } catch {
+      if (typeof navigator !== "undefined" && typeof navigator.sendBeacon === "function") {
+        const blob = new Blob([body], { type: "application/json" });
+        navigator.sendBeacon(`${this.endpoint}/api/events`, blob);
+      }
+    }
+  }
+  async sendBlob(name, blob, metadata) {
+    const headers = this.withAuthHeaders({
+      "Content-Type": "application/octet-stream",
+      "X-Session-Id": this.sessionId
+    });
+    if (metadata) {
+      headers["X-Metadata"] = JSON.stringify(metadata);
+    }
+    await fetch(`${this.endpoint}/api/blob/${name}`, {
+      method: "POST",
+      headers,
+      body: blob
+    });
+  }
+  async startSession(sessionId, metadata) {
+    this.sessionId = sessionId;
+    await fetch(`${this.endpoint}/api/session/start`, {
+      method: "POST",
+      headers: this.withAuthHeaders({ "Content-Type": "application/json" }),
+      body: JSON.stringify({ sessionId, metadata })
+    });
+  }
+  async sendBugReport(report, events, voiceBlob) {
+    await fetch(`${this.endpoint}/api/bug/flag`, {
+      method: "POST",
+      headers: this.withAuthHeaders({ "Content-Type": "application/json" }),
+      body: JSON.stringify({ report, events })
+    });
+    if (voiceBlob) {
+      await fetch(`${this.endpoint}/api/bug/${report.bugId}/voice`, {
+        method: "POST",
+        headers: this.withAuthHeaders({
+          "Content-Type": "application/octet-stream"
+        }),
+        body: voiceBlob
+      });
+    }
+  }
+  async endSession(sessionId) {
+    const body = JSON.stringify({ sessionId });
+    try {
+      await fetch(`${this.endpoint}/api/session/end`, {
+        method: "POST",
+        headers: this.withAuthHeaders({ "Content-Type": "application/json" }),
+        body
+      });
+    } catch {
+      if (typeof navigator !== "undefined" && typeof navigator.sendBeacon === "function") {
+        const blob = new Blob([body], { type: "application/json" });
+        navigator.sendBeacon(`${this.endpoint}/api/session/end`, blob);
+      }
+    }
+  }
+};
+
+// src/session-store.ts
+var DEFAULT_SESSION_STORAGE_KEY = "__crumbtrail_session";
+function createWebSessionStore(storage, key = DEFAULT_SESSION_STORAGE_KEY) {
+  const resolvedStorage = arguments.length === 0 ? getBrowserSessionStorage() : storage;
+  if (!resolvedStorage) return void 0;
+  return {
+    read() {
+      try {
+        const raw = resolvedStorage.getItem(key);
+        if (!raw) return void 0;
+        const parsed = JSON.parse(raw);
+        if (typeof parsed.id !== "string" || parsed.id.length === 0)
+          return void 0;
+        return {
+          id: parsed.id,
+          lastActivity: typeof parsed.lastActivity === "number" ? parsed.lastActivity : 0
+        };
+      } catch {
+        return void 0;
+      }
+    },
+    write(session) {
+      try {
+        resolvedStorage.setItem(key, JSON.stringify(session));
+      } catch {
+      }
+    }
+  };
+}
+function getBrowserSessionStorage() {
+  try {
+    return typeof sessionStorage !== "undefined" && sessionStorage !== null ? sessionStorage : void 0;
+  } catch {
+    return void 0;
+  }
+}
+
+// src/redaction.ts
+var BROWSER_REDACTION_POLICY = "crumbtrail.browser-redaction.v1";
+var REDACTED_VALUE = "[REDACTED]";
+var REDACTED_STORAGE_KEY = "[REDACTED_KEY]";
+var SENSITIVE_HEADER_NAMES = /* @__PURE__ */ new Set([
+  "authorization",
+  "cookie",
+  "set-cookie",
+  "proxy-authorization",
+  "x-api-key",
+  "x-auth-token",
+  "x-access-token",
+  "x-csrf-token",
+  "x-xsrf-token",
+  "x-session-id"
+]);
+var URL_HEADER_NAMES = /* @__PURE__ */ new Set([
+  "content-location",
+  "location",
+  "referer",
+  "referrer"
+]);
+var MAX_HEADER_COUNT = 80;
+var MAX_HEADER_NAME_LENGTH = 160;
+var MAX_HEADER_VALUE_LENGTH = 2e3;
+var SENSITIVE_NAME_RE = /(^|[^a-z0-9])(access[-_]?token|api[-_]?key|auth|authorization|bearer|card[-_]?number|client[-_]?secret|cookie|credential(s)?|creds|csrf|cvv|cvc|id[-_]?token|jsessionid|jwt|mfa|otp|pass[-_]?phrase|pass(code|word)?|passwd|password[-_]?confirmation|pin|private[-_]?key|pwd|refresh[-_]?token|secret|security[-_]?code|session|session[-_]?id|sid|ssn|token|verification[-_]?code|xsrf)([^a-z0-9]|$)/i;
+var PII_NAME_RE = /(^|[^a-z0-9])(email|phone|address|dob|birthdate|postal|zip)([^a-z0-9]|$)/i;
+var SENSITIVE_URL_SCHEMES = /* @__PURE__ */ new Set([
+  "blob:",
+  "data:",
+  "file:",
+  "javascript:"
+]);
+var SENSITIVE_COMPACT_NAMES = /* @__PURE__ */ new Set([
+  "accesskey",
+  "accesstoken",
+  "accesstokens",
+  "apikey",
+  "apikeys",
+  "apisecret",
+  "apisecrets",
+  "auth",
+  "authentication",
+  "authenticationinfo",
+  "authkey",
+  "authtoken",
+  "authorization",
+  "authorizationinfo",
+  "bearer",
+  "cardnumber",
+  "clientsecret",
+  "clientsecrets",
+  "cookie",
+  "credentials",
+  "creds",
+  "csrf",
+  "csrfkey",
+  "csrftoken",
+  "cvc",
+  "cvv",
+  "idtoken",
+  "idtokens",
+  "jsessionid",
+  "jwt",
+  "mfa",
+  "otp",
+  "passcode",
+  "passphrase",
+  "passwd",
+  "password",
+  "passwordconfirmation",
+  "passwords",
+  "pin",
+  "privatekey",
+  "proxyauthentication",
+  "proxyauthenticationinfo",
+  "pwd",
+  "refreshtoken",
+  "refreshtokens",
+  "secret",
+  "secrets",
+  "securitycode",
+  "session",
+  "sessionid",
+  "sessiontoken",
+  "sessiontokens",
+  "sid",
+  "ssn",
+  "token",
+  "tokenkey",
+  "tokens",
+  "verificationcode",
+  "xapikey",
+  "xauthkey",
+  "xauthtoken",
+  "xcsrf",
+  "xcsrfkey",
+  "xcsrftoken",
+  "xsrf",
+  "xsrfkey",
+  "xsrftoken",
+  "xxsrf",
+  "xxsrfkey",
+  "xxsrftoken"
+]);
+var SENSITIVE_COMPACT_SUFFIXES = [
+  "accesstoken",
+  "accesstokens",
+  "apikey",
+  "apikeys",
+  "apisecret",
+  "apisecrets",
+  "authtoken",
+  "clientsecret",
+  "clientsecrets",
+  "csrftoken",
+  "idtoken",
+  "idtokens",
+  "privatekey",
+  "refreshtoken",
+  "refreshtokens",
+  "sessiontoken",
+  "sessiontokens",
+  "xsrftoken"
+];
+var TOKEN_PATTERNS = [
+  {
+    pattern: /\b(?:Bearer|Token|Basic)\s+[A-Za-z0-9._~+/=-]{8,}\b/gi,
+    reason: "auth_scheme_token"
+  },
+  {
+    pattern: /\beyJ[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}\b/g,
+    reason: "jwt_token"
+  },
+  {
+    pattern: /(?:sk|pk|rk|ghp|gho|ghu|ghs|glpat|xox[baprs])[-_][A-Za-z0-9_.=-]{12,}/gi,
+    reason: "prefixed_token"
+  },
+  { pattern: /\b[A-Fa-f0-9]{32,}\b/g, reason: "long_hex_token" },
+  { pattern: /\b[A-Za-z0-9_-]{40,}\b/g, reason: "long_token_like_string" }
+];
+var REDACTED_KEY = "[REDACTED_KEY]";
+var SENSITIVE_PATH_PRECEDERS = /* @__PURE__ */ new Set([
+  "code",
+  "invite",
+  "magic",
+  "mfa",
+  "otp",
+  "passcode",
+  "reset",
+  "session",
+  "token",
+  "verify"
+]);
+function metadataFromField(field, summary) {
+  return {
+    policy: BROWSER_REDACTION_POLICY,
+    fields: [field],
+    ...summary ? { summaries: [summary] } : {}
+  };
+}
+function metadataFromFields(fields, summaries = []) {
+  if (fields.length === 0 && summaries.length === 0) return void 0;
+  return {
+    policy: BROWSER_REDACTION_POLICY,
+    fields,
+    ...summaries.length > 0 ? { summaries } : {}
+  };
+}
+function mergeRedactionMetadata(...items) {
+  const fields = [];
+  const summaries = [];
+  for (const item of items) {
+    if (!item) continue;
+    fields.push(...item.fields);
+    if (item.summaries) summaries.push(...item.summaries);
+  }
+  if (fields.length === 0 && summaries.length === 0) return void 0;
+  return {
+    policy: BROWSER_REDACTION_POLICY,
+    fields,
+    ...summaries.length > 0 ? { summaries } : {}
+  };
+}
+function attachRedactionMetadata(target, ...items) {
+  const metadata = mergeRedactionMetadata(...items);
+  if (metadata) target.redaction = metadata;
+}
+function withMetadata(value, field, summary) {
+  return {
+    value,
+    ...field ? { metadata: metadataFromField(field, summary) } : {},
+    ...summary ? { summary } : {}
+  };
+}
+function isSensitiveName(name) {
+  if (!name) return false;
+  const normalized = name.replace(/([a-z])([A-Z])/g, "$1_$2");
+  const compact = normalized.toLowerCase().replace(/[^a-z0-9]/g, "");
+  return SENSITIVE_NAME_RE.test(name) || PII_NAME_RE.test(name) || SENSITIVE_NAME_RE.test(normalized) || PII_NAME_RE.test(normalized) || isSensitiveCompactName(compact);
+}
+function isSensitiveCompactName(compact) {
+  return SENSITIVE_COMPACT_NAMES.has(compact) || SENSITIVE_COMPACT_SUFFIXES.some(
+    (suffix) => compact.length > suffix.length && compact.endsWith(suffix)
+  );
+}
+function buildSummary(kind, action, reason, originalLength, limit, redactedFields, contentLength) {
+  return {
+    kind,
+    action,
+    reason,
+    ...originalLength !== void 0 ? { originalLength } : {},
+    ...limit !== void 0 ? { limit } : {},
+    ...redactedFields !== void 0 ? { redactedFields } : {},
+    ...contentLength !== void 0 ? { contentLength } : {}
+  };
+}
+function redactTokenLikeString(value, path = "value") {
+  let output = value;
+  const fields = [];
+  for (const { pattern, reason } of TOKEN_PATTERNS) {
+    pattern.lastIndex = 0;
+    let matched = false;
+    output = output.replace(pattern, () => {
+      matched = true;
+      return REDACTED_VALUE;
+    });
+    if (matched) fields.push({ path, reason, action: "redacted" });
+  }
+  const metadata = metadataFromFields(fields);
+  return { value: output, ...metadata ? { metadata } : {} };
+}
+function redactQueryString(query, path) {
+  if (!query) return { value: "" };
+  const search = query.startsWith("?") ? query.slice(1) : query;
+  const params = new URLSearchParams(search);
+  const fields = [];
+  for (const key of Array.from(params.keys())) {
+    const values = params.getAll(key);
+    const safeKey = sanitizeKeyName(key);
+    params.delete(key);
+    for (const value of values) {
+      if (value === "") {
+        params.append(safeKey, "");
+      } else {
+        params.append(safeKey, REDACTED_VALUE);
+        fields.push({
+          path: `${path}.query.${safeKey}`,
+          reason: "url_query_value",
+          action: "redacted"
+        });
+      }
+    }
+  }
+  const serialized = params.toString();
+  const metadata = metadataFromFields(fields);
+  return {
+    value: serialized ? `?${serialized}` : "",
+    ...metadata ? { metadata } : {}
+  };
+}
+function sanitizeKeyName(key) {
+  return redactTokenLikeString(key).value === key ? key : REDACTED_KEY;
+}
+function uniqueOutputKey(key, output) {
+  if (!Object.prototype.hasOwnProperty.call(output, key)) return key;
+  let suffix = 2;
+  while (Object.prototype.hasOwnProperty.call(output, `${key}_${suffix}`))
+    suffix += 1;
+  return `${key}_${suffix}`;
+}
+function redactUrlPath(pathname, path) {
+  if (!pathname || pathname === "/") return { value: pathname };
+  const fields = [];
+  let previousDecoded = "";
+  const parts = pathname.split("/");
+  const output = parts.map((part, index) => {
+    if (part === "") return part;
+    const decoded = decodeURIComponentDeep(part);
+    const subResult = redactUrlPathComponent(
+      decoded,
+      previousDecoded,
+      `${path}.path`
+    );
+    previousDecoded = subResult.lastToken || decoded.toLowerCase();
+    if (subResult.metadata) fields.push(...subResult.metadata.fields);
+    return subResult.value === decoded ? part : encodeURIComponent(subResult.value);
+  });
+  const metadata = metadataFromFields(fields);
+  return { value: output.join("/"), ...metadata ? { metadata } : {} };
+}
+function redactUrlPathComponent(component, previous, path) {
+  const fields = [];
+  let lastToken = previous;
+  if ((SENSITIVE_PATH_PRECEDERS.has(previous) || isSensitiveName(previous)) && component.length > 0) {
+    fields.push({
+      path,
+      reason: "url_path_secret_segment",
+      action: "redacted"
+    });
+    return {
+      value: REDACTED_VALUE,
+      lastToken: REDACTED_VALUE.toLowerCase(),
+      metadata: { policy: BROWSER_REDACTION_POLICY, fields }
+    };
+  }
+  const parts = component.split(/([/\\;])/);
+  const output = parts.map((part) => {
+    if (part === "/" || part === "\\" || part === ";") return part;
+    if (part === "") return part;
+    const keyValueIndex = part.indexOf("=");
+    if (keyValueIndex > 0) {
+      const key = part.slice(0, keyValueIndex);
+      const value = part.slice(keyValueIndex + 1);
+      const tokenResult2 = redactTokenLikeString(value, path);
+      if (isSensitiveName(key) || tokenResult2.value !== value || isSecretLikePathSegment(value, key.toLowerCase())) {
+        fields.push({
+          path,
+          reason: isSensitiveName(key) ? "url_path_sensitive_key" : "url_path_token",
+          action: "redacted"
+        });
+        lastToken = key.toLowerCase();
+        return `${key}=${REDACTED_VALUE}`;
+      }
+    }
+    const tokenResult = redactTokenLikeString(part, path);
+    if (tokenResult.value !== part || isSecretLikePathSegment(part, lastToken)) {
+      fields.push({
+        path,
+        reason: tokenResult.value !== part ? "url_path_token" : "url_path_secret_segment",
+        action: "redacted"
+      });
+      lastToken = REDACTED_VALUE.toLowerCase();
+      return REDACTED_VALUE;
+    }
+    if (part.includes("?") || part.includes("&")) {
+      const decodedQueryResult = redactDecodedQueryLikePathComponent(
+        part,
+        path,
+        lastToken
+      );
+      if (decodedQueryResult.metadata)
+        fields.push(...decodedQueryResult.metadata.fields);
+      lastToken = decodedQueryResult.lastToken;
+      return decodedQueryResult.value;
+    }
+    lastToken = part.toLowerCase();
+    return part;
+  }).join("");
+  const metadata = metadataFromFields(fields);
+  return { value: output, lastToken, ...metadata ? { metadata } : {} };
+}
+function redactDecodedQueryLikePathComponent(component, path, previous) {
+  const fields = [];
+  let lastToken = previous;
+  let inDecodedQuery = false;
+  const output = component.split(/([?&])/).map((part) => {
+    if (part === "?" || part === "&") {
+      inDecodedQuery = true;
+      return part;
+    }
+    if (!inDecodedQuery || part === "") return part;
+    const keyValueIndex = part.indexOf("=");
+    if (keyValueIndex > 0) {
+      const rawKey = part.slice(0, keyValueIndex);
+      const rawValue = part.slice(keyValueIndex + 1);
+      const safeKey = sanitizeKeyName(rawKey);
+      lastToken = safeKey.toLowerCase();
+      if (rawValue === "") return `${safeKey}=`;
+      fields.push({
+        path: `${path}.decoded_query.${safeKey}`,
+        reason: "url_path_decoded_query_value",
+        action: "redacted"
+      });
+      return `${safeKey}=${REDACTED_VALUE}`;
+    }
+    fields.push({
+      path: `${path}.decoded_query`,
+      reason: "url_path_decoded_query_value",
+      action: "redacted"
+    });
+    lastToken = REDACTED_VALUE.toLowerCase();
+    return REDACTED_VALUE;
+  }).join("");
+  const metadata = metadataFromFields(fields);
+  return { value: output, lastToken, ...metadata ? { metadata } : {} };
+}
+function decodeURIComponentSafe(value) {
+  try {
+    return decodeURIComponent(value);
+  } catch {
+    return value;
+  }
+}
+function decodeURIComponentDeep(value) {
+  let output = value;
+  for (let index = 0; index < 3; index += 1) {
+    const decoded = decodeURIComponentSafe(output);
+    if (decoded === output) return output;
+    output = decoded;
+  }
+  return output;
+}
+function isSecretLikePathSegment(segment2, previous) {
+  if (/^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(
+    segment2
+  ))
+    return true;
+  if ((SENSITIVE_PATH_PRECEDERS.has(previous) || isSensitiveName(previous)) && segment2.length > 0 && segment2.length <= 256)
+    return true;
+  return /^[A-Za-z0-9_-]{16,39}$/.test(segment2) && /[A-Z0-9_-]/.test(segment2);
+}
+function redactRelativeUrl(url, path) {
+  const hashIndex = url.indexOf("#");
+  const beforeHash = hashIndex >= 0 ? url.slice(0, hashIndex) : url;
+  const hash = hashIndex >= 0 ? url.slice(hashIndex) : "";
+  const queryIndex = beforeHash.indexOf("?");
+  const base = queryIndex >= 0 ? beforeHash.slice(0, queryIndex) : beforeHash;
+  const query = queryIndex >= 0 ? beforeHash.slice(queryIndex) : "";
+  const queryResult = redactQueryString(query, path);
+  const pathResult = redactUrlPath(base, path);
+  const tokenResult = redactTokenLikeString(
+    `${pathResult.value}${queryResult.value}`,
+    path
+  );
+  const fields = [];
+  if (queryResult.metadata) fields.push(...queryResult.metadata.fields);
+  if (pathResult.metadata) fields.push(...pathResult.metadata.fields);
+  if (tokenResult.metadata)
+    fields.push(
+      ...tokenResult.metadata.fields.map((field) => ({
+        ...field,
+        reason: `url_${field.reason}`
+      }))
+    );
+  if (hash)
+    fields.push({
+      path: `${path}.hash`,
+      reason: "url_hash",
+      action: "dropped"
+    });
+  const metadata = metadataFromFields(fields);
+  return { value: tokenResult.value, ...metadata ? { metadata } : {} };
+}
+function redactMalformedAbsoluteUrl(path) {
+  return withMetadata(REDACTED_VALUE, {
+    path,
+    reason: "malformed_absolute_url",
+    action: "redacted"
+  });
+}
+function redactUrl(url, path = "url") {
+  if (url.trim().startsWith("//")) {
+    const leadingWhitespace2 = url.match(/^\s*/)?.[0] ?? "";
+    const trimmed = url.trim();
+    try {
+      const parsed = new URL(`https:${trimmed}`);
+      const fields = [];
+      if (parsed.username || parsed.password) {
+        parsed.username = "";
+        parsed.password = "";
+        fields.push({
+          path: `${path}.credentials`,
+          reason: "url_credentials",
+          action: "dropped"
+        });
+      }
+      if (parsed.search) {
+        const queryResult = redactQueryString(parsed.search, path);
+        parsed.search = queryResult.value;
+        if (queryResult.metadata) fields.push(...queryResult.metadata.fields);
+      }
+      const pathResult = redactUrlPath(parsed.pathname, path);
+      parsed.pathname = pathResult.value;
+      if (pathResult.metadata) fields.push(...pathResult.metadata.fields);
+      if (parsed.hash) {
+        parsed.hash = "";
+        fields.push({
+          path: `${path}.hash`,
+          reason: "url_hash",
+          action: "dropped"
+        });
+      }
+      const withoutScheme = `//${parsed.host}${parsed.pathname}${parsed.search}`;
+      const tokenResult = redactTokenLikeString(
+        `${leadingWhitespace2}${withoutScheme}`,
+        path
+      );
+      if (tokenResult.metadata)
+        fields.push(
+          ...tokenResult.metadata.fields.map((field) => ({
+            ...field,
+            reason: `url_${field.reason}`
+          }))
+        );
+      const metadata = metadataFromFields(fields);
+      return { value: tokenResult.value, ...metadata ? { metadata } : {} };
+    } catch {
+      return redactMalformedAbsoluteUrl(path);
+    }
+  }
+  const leadingWhitespace = url.match(/^\s*/)?.[0] ?? "";
+  const trimmedUrl = url.slice(leadingWhitespace.length);
+  const hasScheme = /^[a-z][a-z\d+.-]*:/i.test(trimmedUrl);
+  if (!hasScheme) return redactRelativeUrl(url, path);
+  try {
+    const parsed = new URL(trimmedUrl);
+    const fields = [];
+    if (SENSITIVE_URL_SCHEMES.has(parsed.protocol.toLowerCase())) {
+      const summary = `${parsed.protocol}${REDACTED_VALUE}`;
+      return withMetadata(`${leadingWhitespace}${summary}`, {
+        path,
+        reason: "sensitive_url_scheme",
+        action: "redacted"
+      });
+    }
+    if (parsed.username || parsed.password) {
+      parsed.username = "";
+      parsed.password = "";
+      fields.push({
+        path: `${path}.credentials`,
+        reason: "url_credentials",
+        action: "dropped"
+      });
+    }
+    if (parsed.search) {
+      const queryResult = redactQueryString(parsed.search, path);
+      parsed.search = queryResult.value;
+      if (queryResult.metadata) fields.push(...queryResult.metadata.fields);
+    }
+    const pathResult = redactUrlPath(parsed.pathname, path);
+    parsed.pathname = pathResult.value;
+    if (pathResult.metadata) fields.push(...pathResult.metadata.fields);
+    if (parsed.hash) {
+      parsed.hash = "";
+      fields.push({
+        path: `${path}.hash`,
+        reason: "url_hash",
+        action: "dropped"
+      });
+    }
+    const tokenResult = redactTokenLikeString(
+      `${leadingWhitespace}${parsed.toString()}`,
+      path
+    );
+    if (tokenResult.metadata) {
+      fields.push(
+        ...tokenResult.metadata.fields.map((field) => ({
+          ...field,
+          reason: `url_${field.reason}`
+        }))
+      );
+    }
+    const metadata = metadataFromFields(fields);
+    return { value: tokenResult.value, ...metadata ? { metadata } : {} };
+  } catch {
+    return redactMalformedAbsoluteUrl(path);
+  }
+}
+var URL_IN_TEXT_RE = /https?:\/\/[^\s"'`<>\\{}()[\]|^]+/gi;
+var URL_TRAILING_PUNCT_RE = /[.,;:!?]+$/;
+function redactUrlsInText(value, path = "value") {
+  if (value.indexOf("://") === -1) return { value };
+  const fields = [];
+  const output = value.replace(URL_IN_TEXT_RE, (match) => {
+    const trailing = match.match(URL_TRAILING_PUNCT_RE)?.[0] ?? "";
+    const core = trailing ? match.slice(0, match.length - trailing.length) : match;
+    const result = redactUrl(core, path);
+    if (result.metadata) fields.push(...result.metadata.fields);
+    return `${result.value}${trailing}`;
+  });
+  const metadata = metadataFromFields(fields);
+  return { value: output, ...metadata ? { metadata } : {} };
+}
+function redactHeaders(headers, path = "headers") {
+  const output = /* @__PURE__ */ Object.create(null);
+  const fields = [];
+  let processed = 0;
+  for (const originalName in headers) {
+    if (!Object.prototype.hasOwnProperty.call(headers, originalName)) continue;
+    if (processed >= MAX_HEADER_COUNT) {
+      fields.push({
+        path: `${path}.__truncatedHeaders`,
+        reason: "header_count_limit",
+        action: "dropped"
+      });
+      break;
+    }
+    processed += 1;
+    const value = headers[originalName];
+    const name = originalName.slice(0, MAX_HEADER_NAME_LENGTH);
+    const rawValue = typeof value === "string" ? value.slice(0, MAX_HEADER_VALUE_LENGTH) : String(value).slice(0, MAX_HEADER_VALUE_LENGTH);
+    if (name !== originalName) {
+      fields.push({
+        path: `${path}.${sanitizeKeyName(name)}`,
+        reason: "header_name_truncated",
+        action: "summarized"
+      });
+    }
+    if (rawValue !== value) {
+      fields.push({
+        path: `${path}.${sanitizeKeyName(name)}`,
+        reason: "header_value_truncated",
+        action: "summarized"
+      });
+    }
+    const normalized = name.toLowerCase();
+    const sanitizedName = sanitizeKeyName(name);
+    const outputName = uniqueOutputKey(sanitizedName, output);
+    if (sanitizedName !== name || SENSITIVE_HEADER_NAMES.has(normalized) || isSensitiveName(normalized)) {
+      output[outputName] = REDACTED_VALUE;
+      fields.push({
+        path: `${path}.${outputName}`,
+        reason: "sensitive_header_name",
+        action: "redacted"
+      });
+      continue;
+    }
+    const valueResult = URL_HEADER_NAMES.has(normalized) ? redactUrl(rawValue, `${path}.${outputName}`) : normalized === "link" || headerValueLooksUrlLike(rawValue) ? redactUrlLikeHeaderValue(rawValue, `${path}.${outputName}`) : redactTokenLikeString(rawValue, `${path}.${outputName}`);
+    output[outputName] = valueResult.value;
+    if (valueResult.metadata) fields.push(...valueResult.metadata.fields);
+  }
+  const metadata = metadataFromFields(fields);
+  return { value: output, ...metadata ? { metadata } : {} };
+}
+function headerValueLooksUrlLike(value) {
+  return /^\s*(?:https?:\/\/|\/\/|[./]*[^ \t\r\n;,]+[/?#][^ \t\r\n]*)/i.test(
+    value
+  ) || /\bhttps?:\/\/[^\s,;]+/i.test(value) || /\burl\s*=\s*(?:"[^"]*"|'[^']*'|[^\s,;]+)/i.test(value);
+}
+function redactUrlLikeHeaderValue(value, path) {
+  const fields = [];
+  let output = value.replace(
+    /<([^>]+)>|https?:\/\/[^\s,;]+/gi,
+    (match, bracketed) => {
+      const rawUrl = bracketed ?? match;
+      const result = redactUrl(rawUrl, path);
+      if (result.metadata) fields.push(...result.metadata.fields);
+      return bracketed === void 0 ? result.value : `<${result.value}>`;
+    }
+  );
+  output = output.replace(
+    /\burl(\s*=\s*)(?:"([^"]*)"|'([^']*)'|([^\s,;]+))/gi,
+    (_match, separator, doubleQuoted, singleQuoted, unquoted) => {
+      const rawUrl = doubleQuoted ?? singleQuoted ?? unquoted ?? "";
+      const quote = doubleQuoted !== void 0 ? '"' : singleQuoted !== void 0 ? "'" : "";
+      const result = redactUrl(rawUrl, path);
+      if (result.metadata) fields.push(...result.metadata.fields);
+      return `url${separator}${quote}${result.value}${quote}`;
+    }
+  );
+  output = output.replace(
+    /^(\s*)((?:\/|\.\.?\/)[^\s,;]+)/,
+    (_match, prefix, rawUrl) => {
+      const result = redactUrl(rawUrl, path);
+      if (result.metadata) fields.push(...result.metadata.fields);
+      return `${prefix}${result.value}`;
+    }
+  );
+  const tokenResult = redactTokenLikeString(output, path);
+  if (tokenResult.metadata) fields.push(...tokenResult.metadata.fields);
+  const metadata = metadataFromFields(fields);
+  return { value: tokenResult.value, ...metadata ? { metadata } : {} };
+}
+function redactCookieValue(name, value, path = `cookies.${name}`, configuredMaskNames = []) {
+  if (value === "") return { value: "" };
+  const configured = configuredMaskNames.includes(name);
+  const safeName = sanitizeKeyName(name);
+  const safePath = path.replace(name, safeName);
+  const summary = buildSummary(
+    "cookie",
+    "redacted",
+    configured ? "configured_cookie_mask" : "cookie_value",
+    value.length
+  );
+  return withMetadata(
+    REDACTED_VALUE,
+    {
+      path: safePath,
+      reason: configured ? "configured_cookie_mask" : "cookie_value",
+      action: "redacted"
+    },
+    summary
+  );
+}
+function redactCookieName(name) {
+  return sanitizeKeyName(name);
+}
+function redactCookieMap(cookies, path = "cookies", configuredMaskNames = []) {
+  const output = {};
+  const metadataItems = [];
+  for (const [name, value] of Object.entries(cookies)) {
+    const safeName = sanitizeKeyName(name);
+    const result = redactCookieValue(
+      name,
+      value,
+      `${path}.${safeName}`,
+      configuredMaskNames
+    );
+    output[safeName] = result.value;
+    metadataItems.push(result.metadata);
+  }
+  const metadata = mergeRedactionMetadata(...metadataItems);
+  return { value: output, ...metadata ? { metadata } : {} };
+}
+function isJsonContentType(contentType) {
+  const lower = contentType.toLowerCase();
+  return lower.includes("application/json") || lower.includes("+json");
+}
+function isFormContentType(contentType) {
+  return contentType.toLowerCase().includes("application/x-www-form-urlencoded");
+}
+function isMarkupContentType(contentType) {
+  const lower = contentType.toLowerCase();
+  return lower.includes("application/xml") || lower.includes("text/xml") || lower.includes("+xml") || lower.includes("text/html") || lower.includes("multipart/form-data");
+}
+function looksLikeJson(body) {
+  const trimmed = body.trim();
+  return trimmed.startsWith("{") && trimmed.endsWith("}") || trimmed.startsWith("[") && trimmed.endsWith("]");
+}
+function redactJsonValue(value, path, keyName) {
+  if (keyName && isSensitiveName(keyName)) {
+    return {
+      value: REDACTED_VALUE,
+      fields: [{ path, reason: "sensitive_json_field", action: "redacted" }]
+    };
+  }
+  if (typeof value === "string") {
+    const urlResult = redactUrlsInText(value, path);
+    const result = redactTokenLikeString(urlResult.value, path);
+    return {
+      value: result.value,
+      fields: [
+        ...urlResult.metadata?.fields ?? [],
+        ...result.metadata?.fields ?? []
+      ]
+    };
+  }
+  if (Array.isArray(value)) {
+    const fields = [];
+    const output = value.map((entry, index) => {
+      const result = redactJsonValue(entry, `${path}[${index}]`);
+      fields.push(...result.fields);
+      return result.value;
+    });
+    return { value: output, fields };
+  }
+  if (value !== null && typeof value === "object") {
+    const fields = [];
+    const output = {};
+    for (const [key, entry] of Object.entries(
+      value
+    )) {
+      const safeKey = sanitizeKeyName(key);
+      if (safeKey !== key) {
+        fields.push({
+          path: `${path}.${safeKey}`,
+          reason: "json_key_token_like",
+          action: "redacted"
+        });
+        output[safeKey] = REDACTED_VALUE;
+        continue;
+      }
+      const result = redactJsonValue(entry, `${path}.${safeKey}`, key);
+      fields.push(...result.fields);
+      output[safeKey] = result.value;
+    }
+    return { value: output, fields };
+  }
+  return { value, fields: [] };
+}
+function redactValue(value, path = "value") {
+  const result = redactJsonValue(value, path);
+  const metadata = metadataFromFields(result.fields);
+  return { value: result.value, ...metadata ? { metadata } : {} };
+}
+function redactFormBody(body, path) {
+  const params = new URLSearchParams(body);
+  const fields = [];
+  for (const key of Array.from(params.keys())) {
+    const values = params.getAll(key);
+    const safeKey = sanitizeKeyName(key);
+    params.delete(key);
+    for (const value of values) {
+      if (value === "") {
+        params.append(safeKey, "");
+      } else {
+        params.append(safeKey, REDACTED_VALUE);
+        fields.push({
+          path: `${path}.${safeKey}`,
+          reason: "form_value",
+          action: "redacted"
+        });
+      }
+    }
+  }
+  if (fields.length === 0) return { body };
+  const summary = buildSummary(
+    "form",
+    "redacted",
+    "form_value",
+    body.length,
+    void 0,
+    fields.length
+  );
+  return {
+    body: params.toString(),
+    bodySummary: summary,
+    metadata: {
+      policy: BROWSER_REDACTION_POLICY,
+      fields,
+      summaries: [summary]
+    }
+  };
+}
+function redactTextKeyValueBody(body, path) {
+  const parts = body.split(/([&;\n\r])/);
+  const fields = [];
+  let changed = false;
+  let sawKeyValue = false;
+  const output = parts.map((part) => {
+    if (part === "&" || part === ";" || part === "\n" || part === "\r")
+      return part;
+    const match = part.match(/^([^:=\n\r]{1,120})([:=])(.*)$/s);
+    if (!match) {
+      return part;
+    }
+    sawKeyValue = true;
+    const [, rawKey, delimiter, rawValue] = match;
+    const safeKey = sanitizeKeyName(rawKey.trim());
+    const sensitive = isSensitiveName(rawKey);
+    const valueResult = sensitive ? { value: REDACTED_VALUE } : redactTokenLikeString(rawValue, `${path}.${safeKey}`);
+    if (safeKey !== rawKey.trim() || valueResult.value !== rawValue)
+      changed = true;
+    if (sensitive || valueResult.value !== rawValue)
+      fields.push({
+        path: `${path}.${safeKey}`,
+        reason: sensitive ? "text_sensitive_field" : "text_token_like_value",
+        action: "redacted"
+      });
+    return `${safeKey}${delimiter}${valueResult.value}`;
+  });
+  if (!sawKeyValue || !changed) return void 0;
+  const bodySummary = buildSummary(
+    "text",
+    "redacted",
+    "text_key_value_fields",
+    body.length,
+    void 0,
+    fields.length
+  );
+  const metadata = metadataFromFields(fields, [bodySummary]);
+  return { body: output.join(""), bodySummary, metadata };
+}
+function redactMarkupTextBody(body, path) {
+  const fields = [];
+  let output = body.replace(
+    /<((?:[\w.-]+:)?(?:access[-_]?token|api[-_]?key|auth|authorization|card[-_]?number|client[-_]?secret|credential|credentials|csrf|cvc|cvv|id[-_]?token|jsessionid|jwt|otp|pass[-_]?phrase|passcode|passwd|password|pin|private[-_]?key|pwd|refresh[-_]?token|secret|security[-_]?code|session[-_]?id|sid|token|verification[-_]?code|xsrf))(\s[^>]*)?>[\s\S]*?<\/\1>/gi,
+    (match, tag, attrs) => {
+      if (!isSensitiveName(tag)) return match;
+      fields.push({
+        path: `${path}.${sanitizeKeyName(tag)}`,
+        reason: "markup_sensitive_tag",
+        action: "redacted"
+      });
+      return `<${tag}${attrs ?? ""}>${REDACTED_VALUE}</${tag}>`;
+    }
+  );
+  output = output.replace(
+    /<([A-Za-z][\w:.-]{0,119})([^>]*)>/gi,
+    (match, tag, attrs) => {
+      const marker = readSensitiveMarkupMarker(attrs);
+      if (!marker) return match;
+      const redactedAttrs = replaceSensitiveMarkupPayloadAttributes(attrs);
+      if (redactedAttrs === attrs) return match;
+      fields.push({
+        path: `${path}.${sanitizeKeyName(marker.value)}`,
+        reason: "markup_sensitive_payload_attribute",
+        action: "redacted"
+      });
+      return `<${tag}${redactedAttrs}>`;
+    }
+  );
+  output = output.replace(
+    /<((?:textarea|select|option)\b)([^>]*)>([\s\S]*?)<\/\1>/gi,
+    (match, tag, attrs) => {
+      const marker = readSensitiveMarkupMarker(attrs);
+      if (!marker) return match;
+      fields.push({
+        path: `${path}.${sanitizeKeyName(marker.value)}`,
+        reason: "markup_sensitive_control_text",
+        action: "redacted"
+      });
+      return `<${tag}${attrs}>${REDACTED_VALUE}</${tag}>`;
+    }
+  );
+  output = output.replace(
+    /<([A-Za-z][\w:.-]{0,119})(\s[^>]*)?>([^<]*)<\/\1>/gi,
+    (match, tag, attrs) => {
+      if (!isSensitiveName(tag)) return match;
+      fields.push({
+        path: `${path}.${sanitizeKeyName(tag)}`,
+        reason: "markup_sensitive_tag",
+        action: "redacted"
+      });
+      return `<${tag}${attrs ?? ""}>${REDACTED_VALUE}</${tag}>`;
+    }
+  );
+  output = output.replace(
+    /([A-Za-z_:][\w:.-]{0,119})(\s*=\s*)(?:"([^"]*)"|'([^']*)'|([^\s"'=<>`]+))/gi,
+    (match, name, eq, doubleQuoted, singleQuoted, _unquoted) => {
+      if (!isSensitiveName(name)) return match;
+      const quote = doubleQuoted !== void 0 ? '"' : singleQuoted !== void 0 ? "'" : "";
+      fields.push({
+        path: `${path}.${sanitizeKeyName(name)}`,
+        reason: "markup_sensitive_attribute",
+        action: "redacted"
+      });
+      return `${name}${eq}${quote}${REDACTED_VALUE}${quote}`;
+    }
+  );
+  output = output.replace(
+    /(name\s*=\s*)(?:"([^"]+)"|'([^']+)'|([^;\s\r\n]+))([\s\S]{0,256}?)(\r?\n\r?\n)([\s\S]*?)(?=\r?\n--|$)/gi,
+    (match, prefix, doubleQuoted, singleQuoted, unquoted, between, separator) => {
+      const name = doubleQuoted ?? singleQuoted ?? unquoted ?? "";
+      if (!isSensitiveName(name)) return match;
+      const quote = doubleQuoted !== void 0 ? '"' : singleQuoted !== void 0 ? "'" : "";
+      fields.push({
+        path: `${path}.${sanitizeKeyName(name)}`,
+        reason: "multipart_sensitive_field",
+        action: "redacted"
+      });
+      return `${prefix}${quote}${name}${quote}${between}${separator}${REDACTED_VALUE}`;
+    }
+  );
+  if (fields.length === 0) return void 0;
+  const bodySummary = buildSummary(
+    "text",
+    "redacted",
+    "markup_sensitive_fields",
+    body.length,
+    void 0,
+    fields.length
+  );
+  const metadata = metadataFromFields(fields, [bodySummary]);
+  return { body: output, bodySummary, metadata };
+}
+function readMarkupAttributes(attrs, names) {
+  const wanted = new Set(names.map((name) => name.toLowerCase()));
+  const attributes = [];
+  const attrPattern = /([A-Za-z_:][\w:.-]{0,119})\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s"'=<>`]+))/gi;
+  let match;
+  while ((match = attrPattern.exec(attrs)) !== null) {
+    const name = match[1];
+    if (!wanted.has(name.toLowerCase())) continue;
+    attributes.push({ name, value: match[2] ?? match[3] ?? match[4] ?? "" });
+  }
+  return attributes;
+}
+function readSensitiveMarkupMarker(attrs) {
+  for (const marker of readMarkupAttributes(attrs, [
+    "name",
+    "id",
+    "autocomplete",
+    "type"
+  ])) {
+    const value = marker.value.toLowerCase();
+    if (isSensitiveName(marker.value) || value === "hidden" || value === "password")
+      return marker;
+  }
+  return void 0;
+}
+function replaceSensitiveMarkupPayloadAttributes(attrs) {
+  const attrPattern = /([A-Za-z_:][\w:.-]{0,119})(\s*=\s*)(?:"([^"]*)"|'([^']*)'|([^\s"'=<>`]+))/gi;
+  return attrs.replace(
+    attrPattern,
+    (match, name, eq, doubleQuoted, singleQuoted) => {
+      const normalized = name.toLowerCase();
+      if (normalized !== "value" && normalized !== "content" && normalized !== "href" && normalized !== "src" && !normalized.startsWith("data-"))
+        return match;
+      const quote = doubleQuoted !== void 0 ? '"' : singleQuoted !== void 0 ? "'" : "";
+      return `${name}${eq}${quote}${REDACTED_VALUE}${quote}`;
+    }
+  );
+}
+function redactNetworkTextBody(body, options = {}) {
+  const path = options.path ?? "body";
+  const contentType = options.contentType ?? "";
+  const maxLength = options.maxLength;
+  const kind = isFormContentType(contentType) ? "form" : isJsonContentType(contentType) || looksLikeJson(body) ? "json" : "text";
+  if (maxLength !== void 0 && maxLength >= 0 && body.length > maxLength) {
+    const summary2 = buildSummary(
+      kind,
+      "summarized",
+      "payload_too_large",
+      body.length,
+      maxLength
+    );
+    const metadata = metadataFromField(
+      { path, reason: "payload_too_large", action: "summarized" },
+      summary2
+    );
+    return { bodySummary: summary2, metadata };
+  }
+  if (kind === "form") return redactFormBody(body, path);
+  if (kind === "json") {
+    try {
+      const parsed = JSON.parse(body);
+      const result = redactJsonValue(parsed, path);
+      if (result.fields.length === 0) return { body };
+      const summary2 = buildSummary(
+        "json",
+        "redacted",
+        "sensitive_json_field",
+        body.length,
+        void 0,
+        result.fields.length
+      );
+      return {
+        body: JSON.stringify(result.value),
+        bodySummary: summary2,
+        metadata: {
+          policy: BROWSER_REDACTION_POLICY,
+          fields: result.fields,
+          summaries: [summary2]
+        }
+      };
+    } catch {
+      const summary2 = buildSummary(
+        "json",
+        "dropped",
+        "malformed_json_body",
+        body.length
+      );
+      const metadata = metadataFromField(
+        { path, reason: "malformed_json_body", action: "dropped" },
+        summary2
+      );
+      return { bodySummary: summary2, metadata };
+    }
+  }
+  if (isMarkupContentType(contentType)) {
+    const markupResult = redactMarkupTextBody(body, path);
+    if (markupResult) return markupResult;
+  }
+  const urlInTextResult = redactUrlsInText(body, path);
+  const urlFields = urlInTextResult.metadata?.fields ?? [];
+  const workingBody = urlInTextResult.value;
+  const keyValueResult = redactTextKeyValueBody(workingBody, path);
+  if (keyValueResult) {
+    if (urlFields.length === 0) return keyValueResult;
+    const mergedFields = [
+      ...urlFields,
+      ...keyValueResult.metadata?.fields ?? []
+    ];
+    const summaries = keyValueResult.metadata?.summaries ?? [];
+    return {
+      ...keyValueResult,
+      metadata: {
+        policy: BROWSER_REDACTION_POLICY,
+        fields: mergedFields,
+        ...summaries.length > 0 ? { summaries } : {}
+      }
+    };
+  }
+  const textResult = redactTokenLikeString(workingBody, path);
+  const tokenFields = textResult.metadata?.fields ?? [];
+  const allFields = [...urlFields, ...tokenFields];
+  if (allFields.length === 0) return { body };
+  const reason = tokenFields.length > 0 ? "token_like_value" : "url_query_value";
+  const summary = buildSummary(
+    "text",
+    "redacted",
+    reason,
+    body.length,
+    void 0,
+    allFields.length
+  );
+  return {
+    body: textResult.value,
+    bodySummary: summary,
+    metadata: {
+      policy: BROWSER_REDACTION_POLICY,
+      fields: allFields,
+      summaries: [summary]
+    }
+  };
+}
+function summarizeBinaryPayload(contentType, contentLength, path = "body") {
+  const reason = contentType ? `binary_payload:${contentType}` : "binary_payload";
+  const summary = buildSummary(
+    "binary",
+    "summarized",
+    reason,
+    void 0,
+    void 0,
+    void 0,
+    contentLength ?? void 0
+  );
+  const metadata = metadataFromField(
+    { path, reason: "binary_payload", action: "summarized" },
+    summary
+  );
+  return {
+    body: contentLength ? `[bin:${contentLength}]` : "[bin]",
+    bodySummary: summary,
+    metadata
+  };
+}
+function summarizeOmittedPayload(reason, path = "body") {
+  const kind = reason === "stream_payload" ? "stream" : "unknown";
+  const summary = buildSummary(kind, "dropped", reason);
+  const metadata = metadataFromField(
+    { path, reason, action: "dropped" },
+    summary
+  );
+  return { bodySummary: summary, metadata };
+}
+function redactStorageKey(key, path = "storage.key") {
+  if (isSensitiveName(key)) {
+    return withMetadata(REDACTED_STORAGE_KEY, {
+      path,
+      reason: "sensitive_storage_key",
+      action: "redacted"
+    });
+  }
+  const tokenResult = redactTokenLikeString(key, path);
+  if (tokenResult.metadata) {
+    return {
+      value: REDACTED_STORAGE_KEY,
+      metadata: {
+        policy: BROWSER_REDACTION_POLICY,
+        fields: tokenResult.metadata.fields.map((field) => ({
+          ...field,
+          reason: "storage_key_token_like"
+        }))
+      }
+    };
+  }
+  return { value: key };
+}
+function redactStoredValue(value, options = {}) {
+  if (value == null) return { value: void 0 };
+  if (value === "") return { value: "" };
+  const path = options.path ?? "storage.value";
+  const reason = options.maxLength !== void 0 && value.length > options.maxLength ? "storage_value_too_large" : options.key && isSensitiveName(options.key) ? "sensitive_storage_value" : "storage_value";
+  const summary = buildSummary(
+    "storage",
+    "redacted",
+    reason,
+    value.length,
+    options.maxLength
+  );
+  return withMetadata(
+    REDACTED_VALUE,
+    { path, reason, action: "redacted" },
+    summary
+  );
+}
+function redactInputValue(value, options = {}) {
+  if (value === "") return { value: "" };
+  const path = options.path ?? "input.value";
+  const type = options.type?.toLowerCase();
+  const reason = type === "password" || type === "email" || type === "tel" || type === "search" || isSensitiveName(options.name) ? "sensitive_input_value" : "input_value";
+  const summary = buildSummary("input", "redacted", reason, value.length);
+  return withMetadata(
+    REDACTED_VALUE,
+    { path, reason, action: "redacted" },
+    summary
+  );
+}
+
+// src/collectors/console.ts
+var LEVEL_MAP = {
+  log: "log",
+  warn: "warn",
+  error: "err",
+  debug: "dbg",
+  info: "info"
+};
+var METHODS = ["log", "warn", "error", "debug", "info"];
+function redactConsoleArg(value, path) {
+  if (typeof value === "string") {
+    const result2 = redactNetworkTextBody(value, {
+      contentType: "text/plain",
+      path
+    });
+    return {
+      value: safeStringify(result2.body ?? ""),
+      metadata: result2.metadata
+    };
+  }
+  const serialized = safeStringify(value);
+  const result = redactNetworkTextBody(serialized, {
+    contentType: "application/json",
+    path
+  });
+  return {
+    value: result.body ?? serialized,
+    metadata: result.metadata
+  };
+}
+function redactConsoleStack(stack) {
+  if (!stack) return {};
+  const result = redactNetworkTextBody(stack, {
+    contentType: "text/plain",
+    path: "stk"
+  });
+  return { value: result.body ?? stack, metadata: result.metadata };
+}
+function consoleCollector(bus, config) {
+  const originals = /* @__PURE__ */ new Map();
+  for (const method of METHODS) {
+    originals.set(method, console[method]);
+    console[method] = (...args) => {
+      const redactedArgs = config.captureRawConsole ? args.map((a) => safeStringify(a)) : args.map((a, index) => redactConsoleArg(a, `args[${index}]`));
+      const stack = method === "error" ? config.captureRawConsole ? { value: new Error().stack } : redactConsoleStack(new Error().stack) : void 0;
+      const d = {
+        lv: LEVEL_MAP[method],
+        args: redactedArgs.map(
+          (arg) => typeof arg === "string" ? arg : arg.value
+        )
+      };
+      if (method === "error") d.stk = stack?.value;
+      if (!config.captureRawConsole) {
+        attachRedactionMetadata(
+          d,
+          ...redactedArgs.map(
+            (arg) => typeof arg === "string" ? void 0 : arg.metadata
+          ),
+          stack?.metadata
+        );
+      }
+      bus.emit({ t: now(), k: "con", d });
+      originals.get(method).apply(console, args);
+    };
+  }
+  return () => {
+    for (const method of METHODS) {
+      console[method] = originals.get(method);
+    }
+  };
+}
+
+// src/collectors/error.ts
+function bodyPlaceholder(summary) {
+  return summary ? `[${summary.action}:${summary.reason}]` : "[REDACTED]";
+}
+function redactText(value, path) {
+  if (value == null) return {};
+  const result = redactNetworkTextBody(value, {
+    contentType: "text/plain",
+    path
+  });
+  return {
+    value: result.body ?? bodyPlaceholder(result.bodySummary),
+    metadata: result.metadata
+  };
+}
+function redactErrorPayload(payload, config) {
+  if (config.captureRawErrors) return payload;
+  const msg = redactText(
+    typeof payload.msg === "string" ? payload.msg : void 0,
+    "msg"
+  );
+  const stk = redactText(
+    typeof payload.stk === "string" ? payload.stk : void 0,
+    "stk"
+  );
+  const file = typeof payload.file === "string" ? redactUrl(payload.file, "file") : void 0;
+  const d = {
+    ...payload,
+    ...msg.value !== void 0 ? { msg: msg.value } : {},
+    ...stk.value !== void 0 ? { stk: stk.value } : {},
+    ...file ? { file: file.value } : {}
+  };
+  attachRedactionMetadata(d, msg.metadata, stk.metadata, file?.metadata);
+  return d;
+}
+function errorCollector(bus, config) {
+  const onError = (event) => {
+    bus.emit({
+      t: now(),
+      k: "err",
+      d: redactErrorPayload(
+        {
+          msg: event.message,
+          file: event.filename,
+          line: event.lineno,
+          col: event.colno,
+          stk: event.error?.stack
+        },
+        config
+      )
+    });
+  };
+  const onRejection = (event) => {
+    const reason = event.reason;
+    bus.emit({
+      t: now(),
+      k: "rej",
+      d: redactErrorPayload(
+        {
+          msg: reason instanceof Error ? reason.message : String(reason),
+          stk: reason instanceof Error ? reason.stack : void 0
+        },
+        config
+      )
+    });
+  };
+  window.addEventListener("error", onError);
+  window.addEventListener("unhandledrejection", onRejection);
+  return () => {
+    window.removeEventListener("error", onError);
+    window.removeEventListener("unhandledrejection", onRejection);
+  };
+}
+
+// src/collectors/interaction.ts
+function describeInteractionTarget(target, config) {
+  try {
+    const descriptor = config.describeInteractionElement?.(target) ?? describeElement(target);
+    if (isRecord(descriptor)) return removeUndefined(descriptor);
+  } catch {
+  }
+  return {
+    tag: target.tagName,
+    descriptorError: "interaction_descriptor_failed"
+  };
+}
+function readDescriptorMetadata(descriptor) {
+  const redaction = descriptor.redaction;
+  if (!isRecord(redaction)) return void 0;
+  if (redaction.policy !== BROWSER_REDACTION_POLICY) return void 0;
+  if (!Array.isArray(redaction.fields)) return void 0;
+  return redaction;
+}
+function isRecord(value) {
+  return value != null && typeof value === "object" && !Array.isArray(value);
+}
+function removeUndefined(value) {
+  return Object.fromEntries(
+    Object.entries(value).filter(([, entry]) => entry !== void 0)
+  );
+}
+function readSafeOrigin(url) {
+  if (!url) return void 0;
+  try {
+    const parsed = new URL(url, window.location.href);
+    return parsed.origin === "null" ? void 0 : parsed.origin;
+  } catch {
+    return void 0;
+  }
+}
+function isTopFrame() {
+  try {
+    return window.self === window.top;
+  } catch {
+    return false;
+  }
+}
+function describeFrameContext(url) {
+  return removeUndefined({
+    top: isTopFrame(),
+    origin: readSafeOrigin(url)
+  });
+}
+function interactionCollector(bus, config) {
+  const cleanups = [];
+  const onClick = (e) => {
+    const target = e.target;
+    if (!(target instanceof Element)) return;
+    for (const sel of config.ignoreSelectors) {
+      if (target.matches(sel)) return;
+    }
+    const el = describeInteractionTarget(target, config);
+    const d = {
+      el,
+      pos: [e.clientX, e.clientY]
+    };
+    attachRedactionMetadata(d, readDescriptorMetadata(el));
+    bus.emit({
+      t: now(),
+      k: "clk",
+      d
+    });
+  };
+  document.addEventListener("click", onClick, true);
+  cleanups.push(() => document.removeEventListener("click", onClick, true));
+  const onInput = (e) => {
+    const target = e.target;
+    if (!(target instanceof HTMLInputElement || target instanceof HTMLTextAreaElement || target instanceof HTMLSelectElement))
+      return;
+    const el = describeInteractionTarget(target, config);
+    const type = target instanceof HTMLInputElement ? target.type : void 0;
+    const val = redactInputValue(target.value, {
+      name: target.name || void 0,
+      type,
+      path: "val"
+    });
+    const d = {
+      el,
+      val: val.value,
+      ev: e.type
+    };
+    if (val.summary) d.valSummary = val.summary;
+    attachRedactionMetadata(d, readDescriptorMetadata(el), val.metadata);
+    bus.emit({
+      t: now(),
+      k: "inp",
+      d
+    });
+  };
+  document.addEventListener("input", onInput, true);
+  document.addEventListener("change", onInput, true);
+  cleanups.push(() => {
+    document.removeEventListener("input", onInput, true);
+    document.removeEventListener("change", onInput, true);
+  });
+  const onSubmit = (e) => {
+    const target = e.target;
+    if (!(target instanceof HTMLFormElement)) return;
+    const el = describeInteractionTarget(target, config);
+    const d = {
+      el,
+      val: "",
+      ev: "submit"
+    };
+    attachRedactionMetadata(d, readDescriptorMetadata(el));
+    bus.emit({
+      t: now(),
+      k: "inp",
+      d
+    });
+  };
+  document.addEventListener("submit", onSubmit, true);
+  cleanups.push(() => document.removeEventListener("submit", onSubmit, true));
+  let currentUrl = window.location.href;
+  const emitNav = (to, from, tr) => {
+    const toResult = redactUrl(to, "to");
+    const fromResult = from ? redactUrl(from, "from") : void 0;
+    const d = removeUndefined({
+      from: fromResult?.value ?? "",
+      to: toResult.value,
+      tr,
+      fromOrigin: from ? readSafeOrigin(from) : void 0,
+      toOrigin: readSafeOrigin(to),
+      frame: describeFrameContext(to)
+    });
+    attachRedactionMetadata(d, fromResult?.metadata, toResult.metadata);
+    bus.emit({ t: now(), k: "nav", d });
+  };
+  emitNav(currentUrl, "", "init");
+  const origPushState = history.pushState.bind(history);
+  const origReplaceState = history.replaceState.bind(history);
+  history.pushState = function(...args) {
+    const from = currentUrl;
+    origPushState(...args);
+    currentUrl = window.location.href;
+    emitNav(currentUrl, from, "push");
+  };
+  history.replaceState = function(...args) {
+    const from = currentUrl;
+    origReplaceState(...args);
+    currentUrl = window.location.href;
+    emitNav(currentUrl, from, "replace");
+  };
+  const onPopState = () => {
+    const from = currentUrl;
+    currentUrl = window.location.href;
+    emitNav(currentUrl, from, "pop");
+  };
+  window.addEventListener("popstate", onPopState);
+  const onHashChange = () => {
+    const from = currentUrl;
+    currentUrl = window.location.href;
+    emitNav(currentUrl, from, "hash");
+  };
+  window.addEventListener("hashchange", onHashChange);
+  cleanups.push(() => {
+    history.pushState = origPushState;
+    history.replaceState = origReplaceState;
+    window.removeEventListener("popstate", onPopState);
+    window.removeEventListener("hashchange", onHashChange);
+  });
+  return () => {
+    for (const fn of cleanups) fn();
+  };
+}
+
+// src/collectors/keystroke.ts
+var SENSITIVE_AUTOCOMPLETE_TOKENS = /* @__PURE__ */ new Set([
+  "cc-additional-name",
+  "cc-csc",
+  "cc-exp",
+  "cc-exp-month",
+  "cc-exp-year",
+  "cc-family-name",
+  "cc-given-name",
+  "cc-name",
+  "cc-number",
+  "cc-type",
+  "current-password",
+  "email",
+  "new-password",
+  "one-time-code",
+  "tel",
+  "tel-area-code",
+  "tel-country-code",
+  "tel-extension",
+  "tel-local",
+  "tel-local-prefix",
+  "tel-local-suffix",
+  "tel-national",
+  "transaction-amount",
+  "transaction-currency",
+  "username"
+]);
+function keystrokeCollector(bus, config) {
+  let lastKeystrokeTs = 0;
+  let lastKeyupTs = 0;
+  const throttleMs = config.keystrokeThrottleMs;
+  function getModifiers(e) {
+    let mod = "";
+    if (e.ctrlKey) mod += "c";
+    if (e.shiftKey) mod += "s";
+    if (e.altKey) mod += "a";
+    if (e.metaKey) mod += "m";
+    return mod || void 0;
+  }
+  function inputName(target) {
+    if (target instanceof HTMLInputElement || target instanceof HTMLTextAreaElement || target instanceof HTMLSelectElement) {
+      return target.name || target.id || void 0;
+    }
+    return void 0;
+  }
+  function inputType(target) {
+    return target instanceof HTMLInputElement ? target.type.toLowerCase() : void 0;
+  }
+  function hasSensitiveMarker(target) {
+    if (!(target instanceof Element)) return false;
+    if (target.closest(
+      '[data-sensitive="true"],[data-sensitive=""],[data-crumbtrail-sensitive="true"],[data-crumbtrail-sensitive=""]'
+    )) {
+      return true;
+    }
+    const autocomplete = target.getAttribute("autocomplete");
+    if (!autocomplete) return false;
+    return autocomplete.toLowerCase().split(/\s+/).some((token) => SENSITIVE_AUTOCOMPLETE_TOKENS.has(token));
+  }
+  function shouldMaskKey(target) {
+    if (hasSensitiveMarker(target)) return true;
+    const type = inputType(target);
+    if (type && config.maskInputTypes.map((entry) => entry.toLowerCase()).includes(type))
+      return true;
+    const name = inputName(target);
+    if (!name) return false;
+    return Boolean(redactValue({ [name]: "x" }, "key.el").metadata);
+  }
+  function emitKeyEvent(e, dir) {
+    const t = now();
+    if (dir === "up" && throttleMs > 0 && t - lastKeyupTs < throttleMs) {
+      return;
+    }
+    const dt = lastKeystrokeTs > 0 ? t - lastKeystrokeTs : void 0;
+    lastKeystrokeTs = t;
+    if (dir === "up") lastKeyupTs = t;
+    const target = e.target;
+    const el = {
+      tag: target instanceof Element ? target.tagName : "UNKNOWN"
+    };
+    if (target instanceof Element && target.id) el.id = target.id;
+    if (target instanceof HTMLInputElement && target.name)
+      el.name = target.name;
+    const masked = shouldMaskKey(target);
+    const keyRedaction = masked ? redactInputValue(e.key, {
+      name: inputName(target),
+      type: inputType(target),
+      path: "key"
+    }) : void 0;
+    const d = {
+      key: masked ? "*" : e.key,
+      code: e.code,
+      dir,
+      el,
+      mod: getModifiers(e),
+      dt
+    };
+    if (masked && e.key) {
+      attachRedactionMetadata(
+        d,
+        keyRedaction?.metadata ?? redactValue(REDACTED_VALUE, "key").metadata
+      );
+    }
+    bus.emit({
+      t,
+      k: "key",
+      d
+    });
+  }
+  const onKeydown = (e) => emitKeyEvent(e, "dn");
+  const onKeyup = (e) => emitKeyEvent(e, "up");
+  document.addEventListener("keydown", onKeydown, true);
+  document.addEventListener("keyup", onKeyup, true);
+  return () => {
+    document.removeEventListener("keydown", onKeydown, true);
+    document.removeEventListener("keyup", onKeyup, true);
+  };
+}
+
+// src/collectors/scroll.ts
+function scrollCollector(bus, config) {
+  const throttleMs = config.scrollThrottleMs;
+  const lastEmit = /* @__PURE__ */ new Map();
+  const lastPos = /* @__PURE__ */ new Map();
+  function getDirection(prev, curr) {
+    const dx = curr[0] - prev[0];
+    const dy = curr[1] - prev[1];
+    if (Math.abs(dy) >= Math.abs(dx)) {
+      return dy > 0 ? "dn" : "up";
+    }
+    return dx > 0 ? "rt" : "lt";
+  }
+  const handler = (event) => {
+    const target = event.target;
+    let el;
+    let pos;
+    if (target === document || target === document.documentElement) {
+      el = "document";
+      pos = [window.scrollX, window.scrollY];
+    } else if (target instanceof Element) {
+      el = target.id ? `#${target.id}` : target.tagName.toLowerCase();
+      pos = [target.scrollLeft, target.scrollTop];
+    } else {
+      return;
+    }
+    const t = now();
+    const lastTime = lastEmit.get(el) ?? 0;
+    if (t - lastTime < throttleMs) return;
+    const prev = lastPos.get(el);
+    const dir = prev ? getDirection(prev, pos) : "dn";
+    lastEmit.set(el, t);
+    lastPos.set(el, pos);
+    bus.emit({ t, k: "scr", d: { el, pos, dir } });
+  };
+  document.addEventListener("scroll", handler, true);
+  return () => {
+    document.removeEventListener("scroll", handler, true);
+  };
+}
+
+// src/collectors/visibility.ts
+function visibilityCollector(bus, _config) {
+  const handler = () => {
+    bus.emit({
+      t: now(),
+      k: "vis",
+      d: { state: document.visibilityState }
+    });
+  };
+  document.addEventListener("visibilitychange", handler);
+  return () => {
+    document.removeEventListener("visibilitychange", handler);
+  };
+}
+
+// src/collectors/clipboard.ts
+function clipboardCollector(bus, config) {
+  const maxLen = config.clipboardMaxLength;
+  const handler = (event) => {
+    const type = event.type;
+    let txt;
+    if (type === "paste") {
+      const ce = event;
+      txt = ce.clipboardData?.getData("text/plain");
+    } else {
+      txt = window.getSelection()?.toString();
+    }
+    const d = { op: type };
+    if (txt) {
+      const truncated = truncate(txt, maxLen);
+      if (config.captureRawClipboard) {
+        d.txt = truncated;
+      } else {
+        const redacted = redactNetworkTextBody(truncated, {
+          contentType: "text/plain",
+          path: "txt"
+        });
+        d.txt = redacted.body ?? "";
+        if (redacted.bodySummary) d.txtSummary = redacted.bodySummary;
+        attachRedactionMetadata(d, redacted.metadata);
+      }
+    }
+    if (event.target instanceof Element) {
+      const el = { tag: event.target.tagName };
+      if (event.target.id) el.id = event.target.id;
+      d.el = el;
+    }
+    bus.emit({ t: now(), k: "clip", d });
+  };
+  document.addEventListener("copy", handler, true);
+  document.addEventListener("cut", handler, true);
+  document.addEventListener("paste", handler, true);
+  return () => {
+    document.removeEventListener("copy", handler, true);
+    document.removeEventListener("cut", handler, true);
+    document.removeEventListener("paste", handler, true);
+  };
+}
+
+// src/collectors/cookie.ts
+function parseCookies(cookieStr) {
+  const map = {};
+  if (!cookieStr) return map;
+  const pairs = cookieStr.split(";");
+  for (const pair of pairs) {
+    const eqIdx = pair.indexOf("=");
+    if (eqIdx === -1) continue;
+    const name = pair.slice(0, eqIdx).trim();
+    const value = pair.slice(eqIdx + 1).trim();
+    if (name) map[name] = value;
+  }
+  return map;
+}
+function buildFlags(cookie) {
+  let flags = "";
+  if (cookie.secure) flags += "s";
+  if (cookie.httpOnly) flags += "h";
+  if (cookie.sameSite) {
+    const ss = cookie.sameSite.toLowerCase();
+    if (ss === "strict") flags += "S";
+    else if (ss === "lax") flags += "L";
+    else if (ss === "none") flags += "N";
+  }
+  return flags;
+}
+function redactCookieForEvent(name, value, config) {
+  return redactCookieValue(
+    name,
+    value,
+    `cookie.${name}.val`,
+    config.cookieMaskNames
+  );
+}
+function safeCookieName(name) {
+  return redactCookieName(name);
+}
+function cookieCollector(bus, config) {
+  let lastCookies = {};
+  const initial = parseCookies(document.cookie);
+  for (const [name, value] of Object.entries(initial)) {
+    const val = redactCookieForEvent(name, value, config);
+    const d = {
+      op: "set",
+      name: safeCookieName(name),
+      val: val.value
+    };
+    if (val.summary) d.valSummary = val.summary;
+    attachRedactionMetadata(d, val.metadata);
+    bus.emit({
+      t: now(),
+      k: "cookie",
+      d
+    });
+  }
+  lastCookies = { ...initial };
+  const hasCookieStore = typeof globalThis.cookieStore !== "undefined";
+  if (hasCookieStore) {
+    const cs = globalThis.cookieStore;
+    const changeHandler = (event) => {
+      const e = event;
+      for (const cookie of e.changed) {
+        const val = redactCookieForEvent(cookie.name, cookie.value, config);
+        const flags = buildFlags(cookie);
+        const d = {
+          op: lastCookies[cookie.name] !== void 0 ? "mod" : "set",
+          name: safeCookieName(cookie.name),
+          val: val.value
+        };
+        if (val.summary) d.valSummary = val.summary;
+        if (flags) d.flags = flags;
+        attachRedactionMetadata(d, val.metadata);
+        bus.emit({ t: now(), k: "cookie", d });
+        lastCookies[cookie.name] = cookie.value;
+      }
+      for (const cookie of e.deleted) {
+        bus.emit({
+          t: now(),
+          k: "cookie",
+          d: { op: "del", name: safeCookieName(cookie.name) }
+        });
+        delete lastCookies[cookie.name];
+      }
+    };
+    cs.addEventListener("change", changeHandler);
+    return () => {
+      cs.removeEventListener("change", changeHandler);
+    };
+  }
+  const pollInterval = setInterval(() => {
+    const current = parseCookies(document.cookie);
+    for (const [name, value] of Object.entries(current)) {
+      if (!(name in lastCookies)) {
+        const val = redactCookieForEvent(name, value, config);
+        const d = {
+          op: "set",
+          name: safeCookieName(name),
+          val: val.value
+        };
+        if (val.summary) d.valSummary = val.summary;
+        attachRedactionMetadata(d, val.metadata);
+        bus.emit({
+          t: now(),
+          k: "cookie",
+          d
+        });
+      } else if (lastCookies[name] !== value) {
+        const val = redactCookieForEvent(name, value, config);
+        const d = {
+          op: "mod",
+          name: safeCookieName(name),
+          val: val.value
+        };
+        if (val.summary) d.valSummary = val.summary;
+        attachRedactionMetadata(d, val.metadata);
+        bus.emit({
+          t: now(),
+          k: "cookie",
+          d
+        });
+      }
+    }
+    for (const name of Object.keys(lastCookies)) {
+      if (!(name in current)) {
+        bus.emit({
+          t: now(),
+          k: "cookie",
+          d: { op: "del", name: safeCookieName(name) }
+        });
+      }
+    }
+    lastCookies = { ...current };
+  }, config.cookiePollIntervalMs);
+  return () => {
+    clearInterval(pollInterval);
+  };
+}
+
+// src/collectors/storage.ts
+function parseCookies2(cookieStr) {
+  const map = {};
+  if (!cookieStr) return map;
+  const pairs = cookieStr.split(";");
+  for (const pair of pairs) {
+    const eqIdx = pair.indexOf("=");
+    if (eqIdx === -1) continue;
+    const name = pair.slice(0, eqIdx).trim();
+    const value = pair.slice(eqIdx + 1).trim();
+    if (name) map[name] = value;
+  }
+  return map;
+}
+function dumpStorage(storage) {
+  const map = {};
+  for (let i = 0; i < storage.length; i++) {
+    const key = storage.key(i);
+    if (key !== null) {
+      map[key] = storage.getItem(key) ?? "";
+    }
+  }
+  return map;
+}
+function redactStorageSnapshot(values, type, maxLen) {
+  const out = {};
+  const metadataItems = [];
+  for (const [key, value] of Object.entries(values)) {
+    const keyResult = redactStorageKey(key, `${type}.key`);
+    const valueResult = redactStoredValue(value, {
+      key,
+      maxLength: maxLen,
+      path: `${type}.${keyResult.value}.value`
+    });
+    out[keyResult.value] = valueResult.value;
+    metadataItems.push(keyResult.metadata, valueResult.metadata);
+  }
+  const metadata = mergeRedactionMetadata(...metadataItems);
+  return { value: out, ...metadata ? { metadata } : {} };
+}
+function redactStorageNameList(values, path) {
+  const out = [];
+  const metadataItems = [];
+  values.forEach((value, index) => {
+    if (!value) {
+      out.push("");
+      return;
+    }
+    const result = redactStorageKey(value, `${path}[${index}]`);
+    out.push(result.value);
+    metadataItems.push(result.metadata);
+  });
+  const metadata = mergeRedactionMetadata(...metadataItems);
+  return { value: out, ...metadata ? { metadata } : {} };
+}
+function mergeIntoRedactionMetadata(target, metadata) {
+  if (!metadata) return;
+  const existing = isRedactionMetadata(target.redaction) ? target.redaction : void 0;
+  attachRedactionMetadata(target, existing, metadata);
+}
+function isRedactionMetadata(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value) && value.policy === "crumbtrail.browser-redaction.v1" && Array.isArray(value.fields);
+}
+function assignRedactedStorageValue(target, field, result) {
+  if (result.value !== void 0) target[field] = result.value;
+  if (result.summary) target[`${field}Summary`] = result.summary;
+  return result.metadata;
+}
+function patchStorageMethod(storage, method, fn) {
+  Object.defineProperty(storage, method, {
+    value: fn,
+    writable: true,
+    configurable: true,
+    enumerable: false
+  });
+}
+function restoreStorageMethod(storage, method, origFn) {
+  Object.defineProperty(storage, method, {
+    value: origFn,
+    writable: true,
+    configurable: true,
+    enumerable: false
+  });
+}
+function storageCollector(bus, config) {
+  const maxLen = config.storageValueMaxLength;
+  const excludeKeys = new Set(config.storageExcludeKeys);
+  const cookieSnap = redactCookieMap(
+    parseCookies2(document.cookie),
+    "cookies",
+    config.cookieMaskNames
+  );
+  const localStorageSnap = redactStorageSnapshot(
+    dumpStorage(localStorage),
+    "localStorage",
+    maxLen
+  );
+  const sessionStorageSnap = redactStorageSnapshot(
+    dumpStorage(sessionStorage),
+    "sessionStorage",
+    maxLen
+  );
+  const snapData = {
+    cookies: cookieSnap.value,
+    localStorage: localStorageSnap.value,
+    sessionStorage: sessionStorageSnap.value
+  };
+  attachRedactionMetadata(
+    snapData,
+    cookieSnap.metadata,
+    localStorageSnap.metadata,
+    sessionStorageSnap.metadata
+  );
+  if (config.captureIdb) {
+    try {
+      const idbFactory = typeof indexedDB !== "undefined" ? indexedDB : void 0;
+      if (idbFactory && typeof idbFactory.databases === "function") {
+        idbFactory.databases().then((dbs) => {
+          const names = redactStorageNameList(
+            dbs.map((db) => db.name),
+            "idb.name"
+          );
+          snapData.idb = dbs.map((db, index) => ({
+            name: names.value[index],
+            version: db.version
+          }));
+          mergeIntoRedactionMetadata(snapData, names.metadata);
+        }).catch(() => {
+        });
+      }
+    } catch {
+    }
+  }
+  if (config.captureCacheApi) {
+    try {
+      if (typeof caches !== "undefined" && typeof caches.keys === "function") {
+        caches.keys().then((names) => {
+          const redactedNames = redactStorageNameList(names, "cacheApi.name");
+          snapData.cacheApi = redactedNames.value;
+          mergeIntoRedactionMetadata(snapData, redactedNames.metadata);
+        }).catch(() => {
+        });
+      }
+    } catch {
+    }
+  }
+  bus.emit({ t: now(), k: "snap", d: snapData });
+  const origProtoSetItem = Storage.prototype.setItem;
+  const origProtoRemoveItem = Storage.prototype.removeItem;
+  const origProtoClear = Storage.prototype.clear;
+  const origLocalSetItem = localStorage.setItem.bind(localStorage);
+  const origLocalRemoveItem = localStorage.removeItem.bind(localStorage);
+  const origLocalClear = localStorage.clear.bind(localStorage);
+  const origSessionSetItem = sessionStorage.setItem.bind(sessionStorage);
+  const origSessionRemoveItem = sessionStorage.removeItem.bind(sessionStorage);
+  const origSessionClear = sessionStorage.clear.bind(sessionStorage);
+  function makeSetItem(type, storage, origFn) {
+    return function patchedSetItem(key, value) {
+      if (!excludeKeys.has(key)) {
+        const keyResult = redactStorageKey(key, `${type}.key`);
+        const d = {
+          type,
+          op: "set",
+          key: keyResult.value
+        };
+        const oldValMetadata = assignRedactedStorageValue(
+          d,
+          "oldVal",
+          redactStoredValue(storage.getItem(key), {
+            key,
+            maxLength: maxLen,
+            path: `${type}.${keyResult.value}.oldVal`
+          })
+        );
+        const newValMetadata = assignRedactedStorageValue(
+          d,
+          "newVal",
+          redactStoredValue(value, {
+            key,
+            maxLength: maxLen,
+            path: `${type}.${keyResult.value}.newVal`
+          })
+        );
+        attachRedactionMetadata(
+          d,
+          keyResult.metadata,
+          oldValMetadata,
+          newValMetadata
+        );
+        bus.emit({
+          t: now(),
+          k: "stor",
+          d
+        });
+      }
+      return origFn(key, value);
+    };
+  }
+  function makeRemoveItem(type, storage, origFn) {
+    return function patchedRemoveItem(key) {
+      if (!excludeKeys.has(key)) {
+        const keyResult = redactStorageKey(key, `${type}.key`);
+        const d = {
+          type,
+          op: "del",
+          key: keyResult.value
+        };
+        const oldValMetadata = assignRedactedStorageValue(
+          d,
+          "oldVal",
+          redactStoredValue(storage.getItem(key), {
+            key,
+            maxLength: maxLen,
+            path: `${type}.${keyResult.value}.oldVal`
+          })
+        );
+        attachRedactionMetadata(d, keyResult.metadata, oldValMetadata);
+        bus.emit({
+          t: now(),
+          k: "stor",
+          d
+        });
+      }
+      return origFn(key);
+    };
+  }
+  function makeClear(type, origFn) {
+    return function patchedClear() {
+      bus.emit({
+        t: now(),
+        k: "stor",
+        d: { type, op: "clear" }
+      });
+      return origFn();
+    };
+  }
+  Storage.prototype.setItem = makeSetItem(
+    "local",
+    localStorage,
+    origProtoSetItem
+  );
+  Storage.prototype.removeItem = makeRemoveItem(
+    "local",
+    localStorage,
+    origProtoRemoveItem
+  );
+  Storage.prototype.clear = makeClear("local", origProtoClear);
+  patchStorageMethod(
+    localStorage,
+    "setItem",
+    makeSetItem("local", localStorage, origLocalSetItem)
+  );
+  patchStorageMethod(
+    localStorage,
+    "removeItem",
+    makeRemoveItem("local", localStorage, origLocalRemoveItem)
+  );
+  patchStorageMethod(localStorage, "clear", makeClear("local", origLocalClear));
+  patchStorageMethod(
+    sessionStorage,
+    "setItem",
+    makeSetItem("session", sessionStorage, origSessionSetItem)
+  );
+  patchStorageMethod(
+    sessionStorage,
+    "removeItem",
+    makeRemoveItem("session", sessionStorage, origSessionRemoveItem)
+  );
+  patchStorageMethod(
+    sessionStorage,
+    "clear",
+    makeClear("session", origSessionClear)
+  );
+  const storageHandler = (event) => {
+    if (event.key && excludeKeys.has(event.key)) return;
+    const type = event.storageArea === localStorage ? "local" : "session";
+    if (event.key === null) {
+      bus.emit({
+        t: now(),
+        k: "stor",
+        d: { type, op: "clear" }
+      });
+    } else if (event.newValue === null) {
+      const keyResult = redactStorageKey(event.key, `${type}.key`);
+      const d = {
+        type,
+        op: "del",
+        key: keyResult.value
+      };
+      const oldValMetadata = assignRedactedStorageValue(
+        d,
+        "oldVal",
+        redactStoredValue(event.oldValue, {
+          key: event.key,
+          maxLength: maxLen,
+          path: `${type}.${keyResult.value}.oldVal`
+        })
+      );
+      attachRedactionMetadata(d, keyResult.metadata, oldValMetadata);
+      bus.emit({
+        t: now(),
+        k: "stor",
+        d
+      });
+    } else {
+      const keyResult = redactStorageKey(event.key, `${type}.key`);
+      const d = {
+        type,
+        op: "set",
+        key: keyResult.value
+      };
+      const oldValMetadata = assignRedactedStorageValue(
+        d,
+        "oldVal",
+        redactStoredValue(event.oldValue, {
+          key: event.key,
+          maxLength: maxLen,
+          path: `${type}.${keyResult.value}.oldVal`
+        })
+      );
+      const newValMetadata = assignRedactedStorageValue(
+        d,
+        "newVal",
+        redactStoredValue(event.newValue, {
+          key: event.key,
+          maxLength: maxLen,
+          path: `${type}.${keyResult.value}.newVal`
+        })
+      );
+      attachRedactionMetadata(
+        d,
+        keyResult.metadata,
+        oldValMetadata,
+        newValMetadata
+      );
+      bus.emit({
+        t: now(),
+        k: "stor",
+        d
+      });
+    }
+  };
+  window.addEventListener("storage", storageHandler);
+  return () => {
+    Storage.prototype.setItem = origProtoSetItem;
+    Storage.prototype.removeItem = origProtoRemoveItem;
+    Storage.prototype.clear = origProtoClear;
+    restoreStorageMethod(localStorage, "setItem", origLocalSetItem);
+    restoreStorageMethod(localStorage, "removeItem", origLocalRemoveItem);
+    restoreStorageMethod(localStorage, "clear", origLocalClear);
+    restoreStorageMethod(sessionStorage, "setItem", origSessionSetItem);
+    restoreStorageMethod(sessionStorage, "removeItem", origSessionRemoveItem);
+    restoreStorageMethod(sessionStorage, "clear", origSessionClear);
+    window.removeEventListener("storage", storageHandler);
+  };
+}
+
+// src/collectors/network.ts
+var nextId = 1;
+var BINARY_CONTENT_TYPES = ["octet-stream", "image/", "audio/", "video/"];
+var DEDUP_MAP_MAX = 1e3;
+var dedupMap = /* @__PURE__ */ new Map();
+function djb2(s) {
+  let h = 5381;
+  for (let i = 0; i < s.length; i++) h = (h << 5) + h ^ s.charCodeAt(i);
+  return h >>> 0;
+}
+function clearDedupMap() {
+  dedupMap.clear();
+}
+function checkDedup(url, body, timestamp) {
+  if (body == null || typeof body !== "string") return void 0;
+  const key = url + ":" + djb2(url + body);
+  if (dedupMap.has(key)) {
+    return { ref: dedupMap.get(key), dedup: true };
+  }
+  if (dedupMap.size >= DEDUP_MAP_MAX) {
+    const oldest = dedupMap.keys().next().value;
+    if (oldest !== void 0) dedupMap.delete(oldest);
+  }
+  dedupMap.set(key, timestamp);
+  return void 0;
+}
+function isBinaryContentType(ct) {
+  const lower = ct.toLowerCase();
+  return BINARY_CONTENT_TYPES.some((t) => lower.includes(t));
+}
+function isSSE(ct) {
+  return ct.toLowerCase().includes("text/event-stream");
+}
+function shouldExclude(url, config) {
+  if (config.httpEndpoint && url.includes(config.httpEndpoint)) return true;
+  return config.networkExcludeUrls.some((pattern) => url.includes(pattern));
+}
+function headersToRecord(headers) {
+  if (!headers) return void 0;
+  const result = {};
+  if (headers instanceof Headers) {
+    headers.forEach((value, key) => {
+      result[key] = value;
+    });
+  } else if (Array.isArray(headers)) {
+    for (const [key, value] of headers) {
+      result[key] = value;
+    }
+  } else {
+    return headers;
+  }
+  return Object.keys(result).length > 0 ? result : void 0;
+}
+function responseHeadersToRecord(response) {
+  const result = {};
+  response.headers.forEach((value, key) => {
+    result[key] = value;
+  });
+  return Object.keys(result).length > 0 ? result : void 0;
+}
+function extractUrlString(input) {
+  if (typeof input === "string") return input;
+  if (input instanceof URL) return input.toString();
+  if (input instanceof Request) return input.url;
+  return String(input);
+}
+function extractMethod(input, init) {
+  if (init?.method) return init.method.toUpperCase();
+  if (input instanceof Request) return input.method.toUpperCase();
+  return "GET";
+}
+function extractRequestBody(input, init) {
+  const body = init?.body ?? (input instanceof Request ? input.body : void 0);
+  if (body == null) return { nonText: false };
+  if (typeof body === "string") return { body, nonText: false };
+  return { nonText: true };
+}
+function getHeaderValue(headers, name) {
+  if (!headers) return void 0;
+  const target = name.toLowerCase();
+  for (const [key, value] of Object.entries(headers)) {
+    if (key.toLowerCase() === target) return value;
+  }
+  return void 0;
+}
+function headersToInit(input, init) {
+  try {
+    if (init?.headers !== void 0) return new Headers(init.headers);
+    if (input instanceof Request) return new Headers(input.headers);
+    return void 0;
+  } catch {
+    return void 0;
+  }
+}
+function headersToWritableInit(input, init) {
+  return headersToInit(input, init) ?? new Headers();
+}
+function buildFetchArgsWithHeaders(input, init, headers) {
+  return [input, { ...init, headers }];
+}
+function applyFetchCorrelationHeaders(input, init, config, context) {
+  const existingHeaders = headersToInit(input, init);
+  const url = extractUrlString(input);
+  if (!config.networkCorrelationHeaders || !canInjectCorrelationHeaders(url, config.networkCorrelationAllowedOrigins)) {
+    return { input, init, requestHeaders: headersToRecord(existingHeaders) };
+  }
+  const sessionId = existingHeaders?.get(CRUMBTRAIL_SESSION_HEADER) ?? context?.sessionId;
+  if (!sessionId) {
+    return { input, init, requestHeaders: headersToRecord(existingHeaders) };
+  }
+  try {
+    const headers = headersToWritableInit(input, init);
+    const existingSessionId = headers.get(CRUMBTRAIL_SESSION_HEADER);
+    const existingRequestId = headers.get(CRUMBTRAIL_REQUEST_HEADER);
+    const existingTraceparent = headers.get(W3C_TRACEPARENT_HEADER);
+    const correlation = resolveOutboundCorrelation({
+      sessionId: existingSessionId ?? sessionId,
+      existingRequestId: existingRequestId ?? void 0,
+      existingTraceparent: existingTraceparent ?? void 0
+    });
+    if (!existingSessionId)
+      headers.set(CRUMBTRAIL_SESSION_HEADER, correlation.sessionId);
+    if (!existingRequestId)
+      headers.set(CRUMBTRAIL_REQUEST_HEADER, correlation.requestId);
+    if (!existingTraceparent)
+      headers.set(W3C_TRACEPARENT_HEADER, correlation.traceparent);
+    const [nextInput, nextInit] = buildFetchArgsWithHeaders(
+      input,
+      init,
+      headers
+    );
+    return {
+      input: nextInput,
+      init: nextInit,
+      requestHeaders: headersToRecord(headers),
+      sessionId: correlation.sessionId,
+      requestId: correlation.requestId,
+      traceId: correlation.traceId,
+      spanId: correlation.spanId
+    };
+  } catch {
+    return { input, init, requestHeaders: headersToRecord(existingHeaders) };
+  }
+}
+function applyBodyResult(target, result) {
+  if (result.body !== void 0) target.body = result.body;
+  if (result.bodySummary) target.bodySummary = result.bodySummary;
+}
+function wrapFetch(bus, config, originalFetch, context, pending) {
+  return async function instrumentedFetch(input, init) {
+    const url = extractUrlString(input);
+    if (shouldExclude(url, config)) {
+      return originalFetch(input, init);
+    }
+    const id = nextId++;
+    const method = extractMethod(input, init);
+    const startTime = now();
+    const fetchArgs = applyFetchCorrelationHeaders(
+      input,
+      init,
+      config,
+      context
+    );
+    const urlResult = redactUrl(url, "url");
+    const reqMetadata = [
+      urlResult.metadata
+    ];
+    const reqData = {
+      id,
+      method,
+      url: urlResult.value
+    };
+    if (fetchArgs.sessionId) reqData.sessionId = fetchArgs.sessionId;
+    if (fetchArgs.requestId) reqData.requestId = fetchArgs.requestId;
+    if (fetchArgs.traceId) reqData.traceId = fetchArgs.traceId;
+    if (fetchArgs.spanId) reqData.spanId = fetchArgs.spanId;
+    const requestHeaders = config.networkCaptureHeaders ? fetchArgs.requestHeaders : void 0;
+    if (requestHeaders) {
+      const headersResult = redactHeaders(requestHeaders, "hdrs");
+      reqData.hdrs = headersResult.value;
+      reqMetadata.push(headersResult.metadata);
+    }
+    const requestBody = extractRequestBody(input, init);
+    if (requestBody.body !== void 0) {
+      const bodyResult = redactNetworkTextBody(requestBody.body, {
+        contentType: getHeaderValue(requestHeaders, "content-type"),
+        maxLength: config.networkMaxBodySize,
+        path: "body"
+      });
+      applyBodyResult(reqData, bodyResult);
+      reqMetadata.push(bodyResult.metadata);
+    } else if (requestBody.nonText) {
+      const bodyResult = summarizeOmittedPayload(
+        "non_text_request_body",
+        "body"
+      );
+      applyBodyResult(reqData, bodyResult);
+      reqMetadata.push(bodyResult.metadata);
+    }
+    attachRedactionMetadata(reqData, ...reqMetadata);
+    bus.emit({ t: startTime, k: "net.req", d: reqData });
+    pending.set(id, { method, url: urlResult.value, startTime });
+    let response;
+    try {
+      response = await originalFetch(fetchArgs.input, fetchArgs.init);
+    } finally {
+      pending.delete(id);
+    }
+    const dur = now() - startTime;
+    const resMetadata = [];
+    const resData = { id, st: response.status, dur };
+    if (fetchArgs.sessionId) resData.sessionId = fetchArgs.sessionId;
+    if (fetchArgs.requestId) resData.requestId = fetchArgs.requestId;
+    if (fetchArgs.traceId) resData.traceId = fetchArgs.traceId;
+    if (fetchArgs.spanId) resData.spanId = fetchArgs.spanId;
+    if (config.networkCaptureHeaders) {
+      const hdrs = responseHeadersToRecord(response);
+      if (hdrs) {
+        const headersResult = redactHeaders(hdrs, "hdrs");
+        resData.hdrs = headersResult.value;
+        resMetadata.push(headersResult.metadata);
+      }
+    }
+    const contentType = response.headers.get("content-type") ?? "";
+    if (isSSE(contentType)) {
+      const bodyResult = summarizeOmittedPayload("stream_payload", "body");
+      applyBodyResult(resData, bodyResult);
+      resMetadata.push(bodyResult.metadata);
+    } else if (isBinaryContentType(contentType)) {
+      const bodyResult = summarizeBinaryPayload(
+        contentType,
+        response.headers.get("content-length"),
+        "body"
+      );
+      applyBodyResult(resData, bodyResult);
+      resMetadata.push(bodyResult.metadata);
+    } else {
+      try {
+        const cloned = response.clone();
+        const text = await cloned.text();
+        if (text) {
+          const bodyResult = redactNetworkTextBody(text, {
+            contentType,
+            maxLength: config.networkMaxBodySize,
+            path: "body"
+          });
+          if (bodyResult.body !== void 0) {
+            const ts = String(now());
+            const dedupResult = checkDedup(
+              urlResult.value,
+              bodyResult.body,
+              ts
+            );
+            if (dedupResult) {
+              resData.body = dedupResult;
+              resData.dedup = true;
+            } else {
+              resData.body = bodyResult.body;
+            }
+          }
+          if (bodyResult.bodySummary)
+            resData.bodySummary = bodyResult.bodySummary;
+          resMetadata.push(bodyResult.metadata);
+        }
+      } catch {
+        const bodyResult = summarizeOmittedPayload("body_read_failed", "body");
+        applyBodyResult(resData, bodyResult);
+        resMetadata.push(bodyResult.metadata);
+      }
+    }
+    attachRedactionMetadata(resData, ...resMetadata);
+    bus.emit({ t: now(), k: "net.res", d: resData });
+    return response;
+  };
+}
+function wrapXHR(bus, config, xhrPrototype, context, pending) {
+  const origOpen = xhrPrototype.open;
+  const origSend = xhrPrototype.send;
+  const origSetRequestHeader = xhrPrototype.setRequestHeader;
+  const xhrMeta = /* @__PURE__ */ new WeakMap();
+  xhrPrototype.open = function(method, url, ...rest) {
+    const urlStr = typeof url === "string" ? url : url.toString();
+    const excluded = shouldExclude(urlStr, config);
+    xhrMeta.set(this, {
+      id: nextId++,
+      method: method.toUpperCase(),
+      url: urlStr,
+      startTime: 0,
+      excluded,
+      requestHeaders: {}
+    });
+    return origOpen.call(this, method, url, ...rest);
+  };
+  xhrPrototype.setRequestHeader = function(name, value) {
+    const meta = xhrMeta.get(this);
+    if (meta) {
+      meta.requestHeaders[name] = value;
+    }
+    return origSetRequestHeader.call(this, name, value);
+  };
+  xhrPrototype.send = function(body) {
+    const meta = xhrMeta.get(this);
+    if (!meta || meta.excluded) {
+      return origSend.call(this, body);
+    }
+    if (config.networkCorrelationHeaders && canInjectCorrelationHeaders(
+      meta.url,
+      config.networkCorrelationAllowedOrigins
+    )) {
+      const existingSessionId = getHeaderValue(
+        meta.requestHeaders,
+        CRUMBTRAIL_SESSION_HEADER
+      );
+      const existingRequestId = getHeaderValue(
+        meta.requestHeaders,
+        CRUMBTRAIL_REQUEST_HEADER
+      );
+      const existingTraceparent = getHeaderValue(
+        meta.requestHeaders,
+        W3C_TRACEPARENT_HEADER
+      );
+      const sessionId = existingSessionId ?? context?.sessionId;
+      if (sessionId) {
+        const correlation = resolveOutboundCorrelation({
+          sessionId,
+          existingRequestId,
+          existingTraceparent
+        });
+        meta.sessionId = correlation.sessionId;
+        meta.requestId = correlation.requestId;
+        meta.traceId = correlation.traceId;
+        meta.spanId = correlation.spanId;
+        if (!existingSessionId) {
+          try {
+            origSetRequestHeader.call(
+              this,
+              CRUMBTRAIL_SESSION_HEADER,
+              meta.sessionId
+            );
+            meta.requestHeaders[CRUMBTRAIL_SESSION_HEADER] = meta.sessionId;
+          } catch {
+            meta.sessionId = void 0;
+          }
+        }
+        if (!existingRequestId) {
+          try {
+            origSetRequestHeader.call(
+              this,
+              CRUMBTRAIL_REQUEST_HEADER,
+              meta.requestId
+            );
+            meta.requestHeaders[CRUMBTRAIL_REQUEST_HEADER] = meta.requestId;
+          } catch {
+            meta.requestId = void 0;
+          }
+        }
+        if (!existingTraceparent) {
+          try {
+            origSetRequestHeader.call(
+              this,
+              W3C_TRACEPARENT_HEADER,
+              correlation.traceparent
+            );
+            meta.requestHeaders[W3C_TRACEPARENT_HEADER] = correlation.traceparent;
+          } catch {
+            meta.traceId = void 0;
+            meta.spanId = void 0;
+          }
+        }
+      }
+    }
+    meta.startTime = now();
+    const urlResult = redactUrl(meta.url, "url");
+    const reqMetadata = [
+      urlResult.metadata
+    ];
+    const reqData = {
+      id: meta.id,
+      method: meta.method,
+      url: urlResult.value
+    };
+    if (meta.sessionId) reqData.sessionId = meta.sessionId;
+    if (meta.requestId) reqData.requestId = meta.requestId;
+    if (meta.traceId) reqData.traceId = meta.traceId;
+    if (meta.spanId) reqData.spanId = meta.spanId;
+    if (config.networkCaptureHeaders && Object.keys(meta.requestHeaders).length > 0) {
+      const headersResult = redactHeaders({ ...meta.requestHeaders }, "hdrs");
+      reqData.hdrs = headersResult.value;
+      reqMetadata.push(headersResult.metadata);
+    }
+    if (body != null && typeof body === "string") {
+      const bodyResult = redactNetworkTextBody(body, {
+        contentType: getHeaderValue(meta.requestHeaders, "content-type"),
+        maxLength: config.networkMaxBodySize,
+        path: "body"
+      });
+      applyBodyResult(reqData, bodyResult);
+      reqMetadata.push(bodyResult.metadata);
+    } else if (body != null) {
+      const bodyResult = summarizeOmittedPayload(
+        "non_text_request_body",
+        "body"
+      );
+      applyBodyResult(reqData, bodyResult);
+      reqMetadata.push(bodyResult.metadata);
+    }
+    attachRedactionMetadata(reqData, ...reqMetadata);
+    bus.emit({ t: meta.startTime, k: "net.req", d: reqData });
+    const emitResponse = () => {
+      const dur = now() - meta.startTime;
+      const resMetadata = [];
+      const resData = {
+        id: meta.id,
+        st: this.status,
+        dur
+      };
+      if (meta.sessionId) resData.sessionId = meta.sessionId;
+      if (meta.requestId) resData.requestId = meta.requestId;
+      if (meta.traceId) resData.traceId = meta.traceId;
+      if (meta.spanId) resData.spanId = meta.spanId;
+      if (config.networkCaptureHeaders) {
+        const rawHeaders = this.getAllResponseHeaders();
+        if (rawHeaders) {
+          const hdrs = {};
+          rawHeaders.split("\r\n").filter(Boolean).forEach((line) => {
+            const idx = line.indexOf(": ");
+            if (idx > -1) {
+              hdrs[line.slice(0, idx)] = line.slice(idx + 2);
+            }
+          });
+          if (Object.keys(hdrs).length > 0) {
+            const headersResult = redactHeaders(hdrs, "hdrs");
+            resData.hdrs = headersResult.value;
+            resMetadata.push(headersResult.metadata);
+          }
+        }
+      }
+      const contentType = this.getResponseHeader("content-type") ?? "";
+      if (isSSE(contentType)) {
+        const bodyResult = summarizeOmittedPayload("stream_payload", "body");
+        applyBodyResult(resData, bodyResult);
+        resMetadata.push(bodyResult.metadata);
+      } else if (isBinaryContentType(contentType)) {
+        const bodyResult = summarizeBinaryPayload(
+          contentType,
+          this.getResponseHeader("content-length"),
+          "body"
+        );
+        applyBodyResult(resData, bodyResult);
+        resMetadata.push(bodyResult.metadata);
+      } else {
+        const text = this.responseText;
+        if (text) {
+          const bodyResult = redactNetworkTextBody(text, {
+            contentType,
+            maxLength: config.networkMaxBodySize,
+            path: "body"
+          });
+          if (bodyResult.body !== void 0) {
+            const ts = String(now());
+            const dedupResult = checkDedup(
+              urlResult.value,
+              bodyResult.body,
+              ts
+            );
+            if (dedupResult) {
+              resData.body = dedupResult;
+              resData.dedup = true;
+            } else {
+              resData.body = bodyResult.body;
+            }
+          }
+          if (bodyResult.bodySummary)
+            resData.bodySummary = bodyResult.bodySummary;
+          resMetadata.push(bodyResult.metadata);
+        }
+      }
+      attachRedactionMetadata(resData, ...resMetadata);
+      bus.emit({ t: now(), k: "net.res", d: resData });
+    };
+    this.addEventListener("load", emitResponse);
+    this.addEventListener("error", emitResponse);
+    this.addEventListener("timeout", emitResponse);
+    pending.set(meta.id, {
+      method: meta.method,
+      url: urlResult.value,
+      startTime: meta.startTime
+    });
+    this.addEventListener("loadend", () => pending.delete(meta.id));
+    return origSend.call(this, body);
+  };
+  return { origOpen, origSend, origSetRequestHeader };
+}
+function networkCollector(bus, config, context) {
+  const originalFetch = globalThis.fetch;
+  const shouldPatchFetch = typeof originalFetch === "function";
+  const xhrPrototype = globalThis.XMLHttpRequest?.prototype;
+  const shouldPatchXHR = Boolean(
+    xhrPrototype && typeof xhrPrototype.open === "function" && typeof xhrPrototype.send === "function" && typeof xhrPrototype.setRequestHeader === "function"
+  );
+  const pending = /* @__PURE__ */ new Map();
+  const originalXHRMethods = shouldPatchXHR ? wrapXHR(bus, config, xhrPrototype, context, pending) : void 0;
+  if (shouldPatchFetch) {
+    globalThis.fetch = wrapFetch(bus, config, originalFetch, context, pending);
+  }
+  const unregisterPendingProvider = context?.registerStateProvider?.(
+    "network.pending",
+    () => Array.from(pending.values()).map((request) => ({
+      method: request.method,
+      url: request.url,
+      ageMs: now() - request.startTime
+    }))
+  );
+  return () => {
+    if (shouldPatchFetch) {
+      globalThis.fetch = originalFetch;
+    }
+    if (shouldPatchXHR && originalXHRMethods) {
+      xhrPrototype.open = originalXHRMethods.origOpen;
+      xhrPrototype.send = originalXHRMethods.origSend;
+      xhrPrototype.setRequestHeader = originalXHRMethods.origSetRequestHeader;
+    }
+    unregisterPendingProvider?.();
+    pending.clear();
+    clearDedupMap();
+  };
+}
+
+// src/collectors/performance.ts
+var ENTRY_TYPES = [
+  {
+    type: "resource",
+    metric: "res",
+    extract: (entry) => {
+      const name = redactUrl(String(entry.name ?? ""), "name");
+      const data = {
+        name: name.value,
+        duration: entry.duration,
+        transferSize: entry.transferSize,
+        initiatorType: entry.initiatorType
+      };
+      attachRedactionMetadata(data, name.metadata);
+      return data;
+    }
+  },
+  {
+    type: "longtask",
+    metric: "longtask",
+    extract: (entry) => ({
+      duration: entry.duration,
+      name: entry.name
+    })
+  },
+  {
+    type: "layout-shift",
+    metric: "cls",
+    extract: (entry) => ({
+      value: entry.value,
+      hadRecentInput: entry.hadRecentInput
+    })
+  },
+  {
+    type: "largest-contentful-paint",
+    metric: "lcp",
+    extract: (entry) => {
+      const data = {
+        startTime: entry.startTime,
+        size: entry.size
+      };
+      if (entry.element?.tagName) {
+        data.element = entry.element.tagName;
+      }
+      return data;
+    }
+  },
+  {
+    type: "first-input",
+    metric: "fid",
+    extract: (entry) => ({
+      delay: entry.processingStart - entry.startTime,
+      name: entry.name
+    })
+  }
+];
+function performanceCollector(bus, _config) {
+  if (typeof globalThis.PerformanceObserver === "undefined") {
+    return () => {
+    };
+  }
+  const observers = [];
+  for (const cfg of ENTRY_TYPES) {
+    try {
+      const observer = new PerformanceObserver((list) => {
+        for (const entry of list.getEntries()) {
+          bus.emit({
+            t: now(),
+            k: "perf",
+            d: { metric: cfg.metric, ...cfg.extract(entry) }
+          });
+        }
+      });
+      observer.observe({ type: cfg.type, buffered: true });
+      observers.push(observer);
+    } catch {
+    }
+  }
+  return () => {
+    for (const observer of observers) {
+      observer.disconnect();
+    }
+  };
+}
+
+// src/collectors/heartbeat.ts
+var INTERVAL_MS = 3e4;
+function heartbeatCollector(bus, _config) {
+  const id = setInterval(() => {
+    const d = {};
+    const heap = performance.memory?.usedJSHeapSize;
+    if (heap !== void 0) {
+      d.heap = heap;
+    }
+    if (typeof document !== "undefined") {
+      d.dom = document.querySelectorAll("*").length;
+    }
+    bus.emit({ t: now(), k: "hb", d });
+  }, INTERVAL_MS);
+  return () => {
+    clearInterval(id);
+  };
+}
+
+// src/collectors/environment.ts
+function environmentCollector(bus, _config, context) {
+  const declared = context.getDeclaredEnv?.() ?? {};
+  const snapshot = buildEnvSnapshot(declared.flags, declared.config);
+  bus.emit({
+    t: now(),
+    k: "env",
+    d: snapshot
+  });
+  context.onEnvEmitted?.();
+  return () => {
+  };
+}
+function buildEnvSnapshot(flags, config) {
+  const snapshot = { kind: "snapshot" };
+  const ua = safeUserAgent();
+  if (ua) {
+    snapshot.userAgent = ua;
+    const browser = detectBrowser(ua);
+    if (browser) snapshot.browser = browser;
+    const os = detectOs(ua);
+    if (os) snapshot.os = os;
+  }
+  const viewport = safeViewport();
+  if (viewport) snapshot.viewport = viewport;
+  const locale = safeLocale();
+  if (locale) snapshot.locale = locale;
+  const timezone = safeTimezone();
+  if (timezone) snapshot.timezone = timezone;
+  applyDeclaredEnv(snapshot, flags, config);
+  return snapshot;
+}
+function buildEnvDelta(flags, config) {
+  const delta = { kind: "delta" };
+  applyDeclaredEnv(delta, flags, config);
+  return delta;
+}
+function applyDeclaredEnv(target, flags, config) {
+  const metadataItems = [];
+  if (flags && Object.keys(flags).length > 0) {
+    const result = redactValue(flags, "env.flags");
+    target.flags = result.value;
+    if (result.metadata) metadataItems.push(result.metadata);
+  }
+  if (config && Object.keys(config).length > 0) {
+    const result = redactValue(config, "env.config");
+    target.config = result.value;
+    if (result.metadata) metadataItems.push(result.metadata);
+  }
+  if (metadataItems.length > 0) {
+    target.redaction = mergeMetadata(metadataItems);
+  }
+}
+function mergeMetadata(items) {
+  return {
+    policy: items[0].policy,
+    fields: items.flatMap((item) => item.fields)
+  };
+}
+function safeUserAgent() {
+  try {
+    if (typeof navigator !== "undefined" && typeof navigator.userAgent === "string") {
+      return navigator.userAgent;
+    }
+  } catch {
+  }
+  return void 0;
+}
+function safeViewport() {
+  try {
+    if (typeof window !== "undefined" && typeof window.innerWidth === "number" && typeof window.innerHeight === "number") {
+      return { w: window.innerWidth, h: window.innerHeight };
+    }
+  } catch {
+  }
+  return void 0;
+}
+function safeLocale() {
+  try {
+    const resolved = Intl.DateTimeFormat().resolvedOptions().locale;
+    if (resolved) return resolved;
+  } catch {
+  }
+  try {
+    if (typeof navigator !== "undefined" && typeof navigator.language === "string") {
+      return navigator.language;
+    }
+  } catch {
+  }
+  return void 0;
+}
+function safeTimezone() {
+  try {
+    const tz = Intl.DateTimeFormat().resolvedOptions().timeZone;
+    if (tz) return tz;
+  } catch {
+  }
+  return void 0;
+}
+function detectBrowser(ua) {
+  const tests = [
+    { name: "Edge", re: /Edg(?:e|A|iOS)?\/([\d.]+)/ },
+    { name: "Opera", re: /OPR\/([\d.]+)/ },
+    { name: "Chrome", re: /Chrome\/([\d.]+)/ },
+    { name: "Firefox", re: /Firefox\/([\d.]+)/ },
+    { name: "Safari", re: /Version\/([\d.]+).*Safari/ }
+  ];
+  for (const { name, re } of tests) {
+    const match = ua.match(re);
+    if (match) return match[1] ? { name, version: match[1] } : { name };
+  }
+  return void 0;
+}
+function detectOs(ua) {
+  if (/Windows NT/.test(ua)) return "Windows";
+  if (/Mac OS X/.test(ua)) return "macOS";
+  if (/Android/.test(ua)) return "Android";
+  if (/(iPhone|iPad|iPod)/.test(ua)) return "iOS";
+  if (/Linux/.test(ua)) return "Linux";
+  return void 0;
+}
+
+// src/bug-logger.ts
+var PRESETS = {
+  full: PRESET_FULL,
+  light: PRESET_LIGHT,
+  passive: PRESET_PASSIVE
+};
+var COLLECTOR_MAP = {
+  environment: environmentCollector,
+  console: consoleCollector,
+  errors: errorCollector,
+  interactions: interactionCollector,
+  keystrokes: keystrokeCollector,
+  scroll: scrollCollector,
+  visibility: visibilityCollector,
+  clipboard: clipboardCollector,
+  cookies: cookieCollector,
+  storage: storageCollector,
+  network: networkCollector,
+  performance: performanceCollector,
+  heartbeat: heartbeatCollector
+};
+var SEVERITY_FLUSH_MIN_INTERVAL_MS = 1e3;
+var INERT_TRANSPORT = {
+  async sendEvents() {
+  },
+  async sendBlob() {
+  },
+  async startSession() {
+  },
+  async endSession() {
+  },
+  async sendBugReport() {
+  }
+};
+function bodyPlaceholder2(summary) {
+  return summary ? `[${summary.action}:${summary.reason}]` : "[REDACTED]";
+}
+function readPersistedSessionId(store, idleMs) {
+  const persisted = store.read();
+  if (!persisted) return void 0;
+  if (now() - persisted.lastActivity > idleMs) return void 0;
+  return persisted.id;
+}
+function writePersistedSession(store, id) {
+  store.write({ id, lastActivity: now() });
+}
+var Crumbtrail = class _Crumbtrail {
+  bus;
+  transport;
+  ringBuffer;
+  cleanups = [];
+  config;
+  sessionId;
+  widgetCleanup;
+  stateProviders = /* @__PURE__ */ new Map();
+  declaredFlags = {};
+  declaredConfig = {};
+  envEmitted = false;
+  constructor(config, bus, transport, ringBuffer, sessionId) {
+    this.config = config;
+    this.bus = bus;
+    this.transport = transport;
+    this.ringBuffer = ringBuffer;
+    this.sessionId = sessionId;
+  }
+  static init(presetOrConfig) {
+    const overrides = typeof presetOrConfig === "string" ? PRESETS[presetOrConfig] : presetOrConfig;
+    const config = { ...DEFAULT_CONFIG, ...overrides };
+    if (typeof window === "undefined" && !config.transportInstance) {
+      return new _Crumbtrail(
+        config,
+        new EventBus(),
+        INERT_TRANSPORT,
+        new RingBuffer(config.ringBufferMs, config.ringBufferMaxEvents),
+        config.sessionId ?? generateSessionId()
+      );
+    }
+    const sessionStore = config.sessionPersistence === "session" ? config.sessionStore ?? createWebSessionStore() : void 0;
+    const useSessionStore = Boolean(sessionStore);
+    const sessionId = config.sessionId ?? (sessionStore ? readPersistedSessionId(sessionStore, config.sessionIdleMs) : void 0) ?? generateSessionId();
+    if (sessionStore) writePersistedSession(sessionStore, sessionId);
+    const bus = new EventBus();
+    const ringBuffer = new RingBuffer(
+      config.ringBufferMs,
+      config.ringBufferMaxEvents
+    );
+    const transport = config.transportInstance ?? new HttpTransport(config.httpEndpoint, {
+      authToken: config.httpAuthToken
+    });
+    bus.subscribe((events) => {
+      transport.sendEvents(events).catch(() => {
+      });
+    });
+    bus.subscribe((events) => {
+      ringBuffer.pushBatch(events);
+    });
+    if (useSessionStore && sessionStore) {
+      bus.subscribe(() => {
+        writePersistedSession(sessionStore, sessionId);
+      });
+    }
+    bus.start(config.flushIntervalMs, config.flushBufferSize);
+    const instance = new _Crumbtrail(
+      config,
+      bus,
+      transport,
+      ringBuffer,
+      sessionId
+    );
+    let lastSeverityFlushAt = Number.NEGATIVE_INFINITY;
+    let severityFlushPending = false;
+    instance.cleanups.push(
+      bus.tap((event) => {
+        if (severityFlushPending) return;
+        if (!isSevereEvent(event)) return;
+        if (now() - lastSeverityFlushAt < SEVERITY_FLUSH_MIN_INTERVAL_MS)
+          return;
+        lastSeverityFlushAt = now();
+        severityFlushPending = true;
+        queueMicrotask(() => {
+          severityFlushPending = false;
+          bus.flush();
+        });
+      })
+    );
+    if (typeof window !== "undefined") {
+      const flushOnPageHide = () => bus.flush();
+      window.addEventListener("pagehide", flushOnPageHide);
+      instance.cleanups.push(
+        () => window.removeEventListener("pagehide", flushOnPageHide)
+      );
+    }
+    const collectorContext = {
+      sessionId,
+      getDeclaredEnv: () => ({
+        flags: instance.declaredFlags,
+        config: instance.declaredConfig
+      }),
+      onEnvEmitted: () => {
+        instance.envEmitted = true;
+      },
+      registerStateProvider: (name, provider) => instance.registerStateProvider(name, provider)
+    };
+    const autoFlagDetectors = [];
+    if (config.autoFlagOnError) autoFlagDetectors.push(errorDetector());
+    if (config.autoFlagOnSignals) {
+      autoFlagDetectors.push(
+        rageClickDetector({
+          threshold: config.rageClickThreshold,
+          windowMs: config.rageClickWindowMs
+        }),
+        retryStormDetector({
+          threshold: config.retryStormThreshold,
+          windowMs: config.retryStormWindowMs,
+          failThreshold: config.retryStormFailThreshold
+        }),
+        slowResponseDetector({
+          thresholdMs: config.slowRequestMs,
+          count: config.slowRequestCount,
+          windowMs: config.slowRequestWindowMs
+        }),
+        abandonedFlowDetector({
+          windowMs: config.abandonedFlowWindowMs,
+          minInputs: config.abandonedFlowMinInputs
+        })
+      );
+    }
+    if (autoFlagDetectors.length > 0) {
+      const autoFlag = createAutoFlagController({
+        debounceMs: config.autoFlagDebounceMs,
+        maxPerSession: config.autoFlagMaxPerSession,
+        flag: (options) => instance.flagBug(options),
+        detectors: autoFlagDetectors
+      });
+      instance.cleanups.push(bus.tap((event) => autoFlag.handleEvent(event)));
+      instance.cleanups.push(() => autoFlag.dispose());
+    }
+    transport.startSession(sessionId, {
+      url: typeof location !== "undefined" ? location.href : "",
+      ua: typeof navigator !== "undefined" ? navigator.userAgent : ""
+    }).catch(() => {
+    });
+    for (const [key, collector] of Object.entries(COLLECTOR_MAP)) {
+      if (config[key]) {
+        instance.cleanups.push(collector(bus, config, collectorContext));
+      }
+    }
+    if (config.widget && typeof document !== "undefined") {
+      Promise.resolve().then(() => (init_bug_widget(), bug_widget_exports)).then(({ mountWidget: mountWidget2 }) => {
+        instance.widgetCleanup = mountWidget2(instance);
+      }).catch(() => {
+      });
+    }
+    return instance;
+  }
+  async flagBug(options) {
+    const bugId = `bug_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+    const windowMs = options?.windowMs ?? this.config.ringBufferMs;
+    const flaggedAt = now();
+    const stateProviderNames = Array.from(this.stateProviders.keys());
+    for (const [name, provider] of this.stateProviders) {
+      try {
+        const rawValue = provider();
+        const state = this.config.captureRawState ? { value: rawValue, metadata: void 0 } : redactValue(rawValue, `state.${name}`);
+        const value = state.value;
+        const json = JSON.stringify(value);
+        const truncated = json.length > this.config.stateMaxBytes ? `${json.slice(0, this.config.stateMaxBytes)}...` : json;
+        const d = {
+          name,
+          json: truncated,
+          truncated: truncated !== json
+        };
+        if (!this.config.captureRawState)
+          attachRedactionMetadata(d, state.metadata);
+        this.bus.emit({
+          t: flaggedAt,
+          k: "state.snap",
+          d
+        });
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        const redactedMsg = this.config.captureRawState ? { body: msg, metadata: void 0 } : redactNetworkTextBody(msg, {
+          contentType: "text/plain",
+          path: "msg"
+        });
+        const d = {
+          name,
+          msg: redactedMsg.body ?? bodyPlaceholder2(redactedMsg.bodySummary),
+          ...redactedMsg.bodySummary ? { msgSummary: redactedMsg.bodySummary } : {}
+        };
+        if (!this.config.captureRawState)
+          attachRedactionMetadata(d, redactedMsg.metadata);
+        this.bus.emit({
+          t: flaggedAt,
+          k: "state.err",
+          d
+        });
+      }
+    }
+    if (this.config.domSnapshot && typeof document !== "undefined") {
+      try {
+        const fullHtml = document.documentElement.outerHTML;
+        const clipped = fullHtml.slice(0, this.config.domSnapshotMaxBytes);
+        const redacted = this.config.captureRawState ? { body: clipped, metadata: void 0 } : redactNetworkTextBody(clipped, {
+          contentType: "text/html",
+          path: "dom"
+        });
+        const d = {
+          html: redacted.body ?? clipped,
+          truncated: clipped.length !== fullHtml.length,
+          bytes: fullHtml.length
+        };
+        if (!this.config.captureRawState)
+          attachRedactionMetadata(d, redacted.metadata);
+        this.bus.emit({ t: flaggedAt, k: "dom.snap", d });
+      } catch {
+      }
+    }
+    this.bus.emit({
+      t: flaggedAt,
+      k: "bug.flag",
+      d: { bugId, note: options?.note }
+    });
+    this.bus.flush();
+    const events = this.ringBuffer.snapshot(windowMs);
+    const errorCount = events.filter(
+      (e) => e.k === "err" || e.k === "rej"
+    ).length;
+    const failedRequestCount = events.filter(
+      (e) => isFailedNetworkResponse(e)
+    ).length;
+    const eventKinds = {};
+    for (const e of events) {
+      eventKinds[e.k] = (eventKinds[e.k] || 0) + 1;
+    }
+    const durationMs = events.length >= 2 ? events[events.length - 1].t - events[0].t : 0;
+    const report = {
+      bugId,
+      sessionId: this.sessionId,
+      flaggedAt,
+      windowMs,
+      note: options?.note,
+      voiceNote: options?.voiceBlob ? "voice.webm" : void 0,
+      url: typeof location !== "undefined" ? location.href : "",
+      userAgent: typeof navigator !== "undefined" ? navigator.userAgent : "",
+      tags: options?.tags,
+      summary: {
+        errorCount,
+        failedRequestCount,
+        eventCount: events.length,
+        eventKinds,
+        durationMs,
+        stateProviderCount: stateProviderNames.length
+      }
+    };
+    await this.transport.sendBugReport(report, events, options?.voiceBlob);
+    return { bugId };
+  }
+  mark(label) {
+    this.bus.emit({ t: now(), k: "mark", d: { label } });
+  }
+  addEvent(partial) {
+    const { type, data, ...envelope } = partial;
+    this.bus.emit({ t: now(), k: type, d: data, ...envelope });
+  }
+  getSessionId() {
+    return this.sessionId;
+  }
+  createRequestHeaders(requestId) {
+    return createCrumbtrailRequestHeaders(this.sessionId, requestId);
+  }
+  pause() {
+    this.bus.pause();
+  }
+  resume() {
+    this.bus.resume();
+  }
+  registerStateProvider(name, provider) {
+    this.stateProviders.set(name, provider);
+    return () => {
+      this.stateProviders.delete(name);
+    };
+  }
+  /**
+   * Declaratively attach vendor-agnostic feature flags / config to the session environment.
+   * Values are redacted before they rest. Merges into the declared env; if the initial
+   * `k:'env'` snapshot has already been emitted (the normal case, since `setEnv` is called
+   * after `init`), it emits a `k:'env'` delta event ({ kind:'delta' }). If called before the
+   * snapshot is emitted (e.g. environment collector disabled or not yet run), the values are
+   * folded into the snapshot instead.
+   */
+  setEnv(declaration) {
+    if (declaration.flags) Object.assign(this.declaredFlags, declaration.flags);
+    if (declaration.config)
+      Object.assign(this.declaredConfig, declaration.config);
+    if (!this.envEmitted) return;
+    const delta = buildEnvDelta(declaration.flags, declaration.config);
+    this.bus.emit({
+      t: now(),
+      k: "env",
+      d: delta
+    });
+  }
+  async stop() {
+    if (this.widgetCleanup) this.widgetCleanup();
+    for (const cleanup of this.cleanups) {
+      cleanup();
+    }
+    this.stateProviders.clear();
+    this.bus.stop();
+    this.ringBuffer.clear();
+    await this.transport.endSession(this.sessionId);
+    return { sessionId: this.sessionId };
+  }
+};
+function isSevereEvent(event) {
+  return event.k === "err" || event.k === "rej" || isFailedNetworkResponse(event);
+}
+function isFailedNetworkResponse(event) {
+  return event.k === "net.res" && (typeof event.d.st === "number" && event.d.st >= 400 || hasApplicationFailure(event.d.body));
+}
+function hasApplicationFailure(value) {
+  if (typeof value === "string") return hasApplicationFailureInText(value);
+  if (Array.isArray(value))
+    return value.some((item) => hasApplicationFailure(item));
+  if (!isRecord2(value) || value.dedup === true) return false;
+  if (value.ok === false || value.status === "failed") return true;
+  return Object.values(value).some((nested) => hasApplicationFailure(nested));
+}
+function hasApplicationFailureInText(text) {
+  for (const candidate of extractJsonCandidates(text)) {
+    try {
+      if (hasApplicationFailure(JSON.parse(candidate))) return true;
+    } catch {
+    }
+  }
+  return false;
+}
+function extractJsonCandidates(text) {
+  const trimmed = text.trim();
+  const candidates = /* @__PURE__ */ new Set();
+  if (trimmed.startsWith("{") || trimmed.startsWith("["))
+    candidates.add(trimmed);
+  for (const line of trimmed.split(/\r?\n/)) {
+    const chunk = line.trim();
+    if (!chunk) continue;
+    const framed = chunk.match(/^\d+:(.*)$/);
+    const unframed = (framed?.[1] ?? chunk).trim();
+    if (unframed.startsWith("{") || unframed.startsWith("["))
+      candidates.add(unframed);
+    const objectStart = unframed.indexOf("{");
+    if (objectStart >= 0) candidates.add(unframed.slice(objectStart));
+  }
+  return [...candidates];
+}
+function isRecord2(value) {
+  return value != null && typeof value === "object" && !Array.isArray(value);
+}
+
+// src/target-resolver.ts
+var WebTargetDescriptorResolver = class {
+  resolve(element) {
+    try {
+      const signature = computeElementSignature(element);
+      return {
+        componentName: element.tagName.toLowerCase(),
+        ancestryHash: signature.sig,
+        selector: signature.path
+      };
+    } catch {
+      return void 0;
+    }
+  }
+};
+var webTargetDescriptorResolver = new WebTargetDescriptorResolver();
+
+// src/evidence.ts
+var EVIDENCE_SCHEMA_VERSION = "evidence.v1";
+
+// src/tokenize.ts
+function tokenize(s) {
+  return s.toLowerCase().split(/[^a-z0-9]+/).filter((token) => token.length >= 3);
+}
+
+// src/intent.ts
+var MIN_SHARED = 2;
+var STRUCTURAL_TOKENS = /* @__PURE__ */ new Set([
+  "src",
+  "dist",
+  "index",
+  "node",
+  "lib",
+  "libs",
+  "test",
+  "tests",
+  "app",
+  "apps",
+  "routes",
+  "route",
+  "api",
+  "www",
+  "http",
+  "https",
+  "com",
+  "main",
+  "packages",
+  "pkg",
+  "build"
+]);
+var ROUTE_SEGMENT_PATTERN = /\/[a-z0-9_\-/]+/gi;
+function tokensForEvidence(item) {
+  const tokens = /* @__PURE__ */ new Set();
+  const { ref, brief } = item;
+  if (ref.sig) for (const t of tokenize(ref.sig)) tokens.add(t);
+  if (ref.table) for (const t of tokenize(ref.table)) tokens.add(t);
+  if (brief) for (const t of tokenize(brief)) tokens.add(t);
+  return tokens;
+}
+function tokensForCommit(commit) {
+  const tokens = /* @__PURE__ */ new Set();
+  for (const file of commit.files) {
+    for (const t of tokenize(file)) tokens.add(t);
+  }
+  for (const t of tokenize(commit.message)) tokens.add(t);
+  return tokens;
+}
+function sharedCount(a, b) {
+  let count = 0;
+  for (const token of a) if (b.has(token)) count++;
+  return count;
+}
+function withoutStructural(tokens) {
+  const result = /* @__PURE__ */ new Set();
+  for (const t of tokens) if (!STRUCTURAL_TOKENS.has(t)) result.add(t);
+  return result;
+}
+function evidenceIdentityTokens(item) {
+  const tokens = /* @__PURE__ */ new Set();
+  const { ref, brief } = item;
+  if (ref.table) for (const t of tokenize(ref.table)) tokens.add(t);
+  if (brief) {
+    const matches = brief.match(ROUTE_SEGMENT_PATTERN) ?? [];
+    for (const segment2 of matches) {
+      for (const t of tokenize(segment2)) tokens.add(t);
+    }
+  }
+  return withoutStructural(tokens);
+}
+function commitPathTokens(commit) {
+  const tokens = /* @__PURE__ */ new Set();
+  for (const file of commit.files) {
+    for (const t of tokenize(file)) tokens.add(t);
+  }
+  return withoutStructural(tokens);
+}
+function inferIntent(evidence, commits) {
+  const signals = [];
+  const commitTokens = commits.map((commit) => ({
+    commit,
+    tokens: tokensForCommit(commit),
+    pathTokens: commitPathTokens(commit)
+  }));
+  for (const item of evidence) {
+    const evidenceTokens = tokensForEvidence(item);
+    const identityTokens = evidenceIdentityTokens(item);
+    let best;
+    for (const { commit, tokens, pathTokens } of commitTokens) {
+      const strong = sharedCount(identityTokens, pathTokens);
+      const weak = sharedCount(evidenceTokens, tokens);
+      const qualifies = strong >= 1 || weak >= MIN_SHARED;
+      if (!qualifies) continue;
+      const score = strong * 100 + weak;
+      if (!best || score > best.score || score === best.score && commit.sha < best.commit.sha) {
+        best = { commit, score };
+      }
+    }
+    if (best) {
+      signals.push({
+        evidenceId: item.id,
+        explainedByCommit: {
+          sha: best.commit.sha,
+          pr: best.commit.pr,
+          message: best.commit.message
+        },
+        prIntent: best.commit.message.split("\n")[0]
+      });
+    }
+  }
+  return signals;
+}
+
+// src/fusion.ts
+var FUSION_SCHEMA_VERSION = "fusion.v1";
+function assembleBundle(input) {
+  const evidence = rankEvidence(input.symptom, input.evidence);
+  const hypotheses = classifyHypotheses(
+    input.symptom,
+    input.evidence,
+    input.intent
+  );
+  const gaps = input.gaps ?? [];
+  return {
+    schemaVersion: FUSION_SCHEMA_VERSION,
+    symptom: input.symptom,
+    evidence,
+    opinion: { stance: "advisory", hypotheses },
+    gaps,
+    directives: suggestCaptureDirectives(input.symptom, input.evidence, gaps)
+  };
+}
+var LANE_PRIOR = {
+  db: 0.2,
+  network: 0.2,
+  flow: 0.15,
+  env: 0.1,
+  browser: 0.1,
+  logs: 0.05,
+  memory: 0.05,
+  code: 0.05
+};
+function jaccard(a, b) {
+  if (a.length === 0 && b.length === 0) return 0;
+  const setA = new Set(a);
+  const setB = new Set(b);
+  let intersection = 0;
+  for (const value of setA) if (setB.has(value)) intersection += 1;
+  const union = (/* @__PURE__ */ new Set([...a, ...b])).size;
+  return union === 0 ? 0 : intersection / union;
+}
+function symptomText(symptom) {
+  return [symptom.title, symptom.description, symptom.errorSig].filter((part) => Boolean(part)).join(" ");
+}
+function scoreEvidenceRelevance(symptom, item) {
+  let score = 0;
+  if (symptom.url) {
+    const needle = symptom.url.toLowerCase();
+    const haystack = `${item.ref.sig ?? ""} ${item.brief}`.toLowerCase();
+    if (haystack.includes(needle)) score += 0.5;
+  }
+  const symptomTokens = tokenize(symptomText(symptom));
+  const itemTokens = tokenize(`${item.brief} ${item.kind}`);
+  score += 0.3 * jaccard(symptomTokens, itemTokens);
+  score += LANE_PRIOR[item.lane] ?? 0.05;
+  return Math.min(1, score);
+}
+function rankEvidence(symptom, items) {
+  return items.map((item, index) => ({
+    item,
+    index,
+    score: scoreEvidenceRelevance(symptom, item)
+  })).sort((a, b) => {
+    if (b.score !== a.score) return b.score - a.score;
+    return a.index - b.index;
+  }).map((entry) => entry.item);
+}
+function classifyHypotheses(symptom, evidence, intent) {
+  const hypotheses = [];
+  const evidenceIds = new Set(evidence.map((item) => item.id));
+  const explainedById = /* @__PURE__ */ new Map();
+  for (const signal of intent) {
+    if (signal.explainedByCommit && evidenceIds.has(signal.evidenceId)) {
+      explainedById.set(signal.evidenceId, signal);
+    }
+  }
+  for (const [evidenceId, signal] of explainedById) {
+    const commit = signal.explainedByCommit;
+    hypotheses.push({
+      kind: "intentional-change",
+      confidence: 0.7,
+      rationale: `explained by commit ${commit.sha}: ${commit.message}`,
+      evidenceIds: [evidenceId]
+    });
+  }
+  const unexplained = evidence.filter((item) => !explainedById.has(item.id));
+  const regressionEvidence = unexplained.filter(
+    (item) => item.lane === "network" || item.lane === "db" || item.lane === "flow"
+  );
+  if (regressionEvidence.length > 0) {
+    const confidence = Math.min(0.9, 0.4 + 0.1 * regressionEvidence.length);
+    hypotheses.push({
+      kind: "regression",
+      confidence,
+      rationale: `${regressionEvidence.length} behavior change(s) vs baseline with no matching intentional commit`,
+      evidenceIds: regressionEvidence.map((item) => item.id)
+    });
+  }
+  const envEvidence = unexplained.filter((item) => item.lane === "env");
+  if (envEvidence.length > 0) {
+    hypotheses.push({
+      kind: "environment",
+      confidence: 0.5,
+      rationale: "environment/config differs",
+      evidenceIds: envEvidence.map((item) => item.id)
+    });
+  }
+  const browserEvidence = unexplained.filter((item) => item.lane === "browser");
+  if (browserEvidence.length > 0) {
+    hypotheses.push({
+      kind: "client-side",
+      confidence: 0.5,
+      rationale: "client-side factor (browser/network/device)",
+      evidenceIds: browserEvidence.map((item) => item.id)
+    });
+  }
+  if (evidence.length === 0 && symptom.title.trim().length > 0) {
+    hypotheses.push({
+      kind: "latent",
+      confidence: 0.3,
+      rationale: "no behavior change captured; likely a long-standing/latent issue or missing instrumentation",
+      evidenceIds: []
+    });
+  }
+  if (hypotheses.length === 0) {
+    hypotheses.push({
+      kind: "inconclusive",
+      confidence: 0.2,
+      rationale: "insufficient evidence to distinguish causes",
+      evidenceIds: []
+    });
+  }
+  return hypotheses.map((hypothesis, index) => ({ hypothesis, index })).sort((a, b) => {
+    if (b.hypothesis.confidence !== a.hypothesis.confidence) {
+      return b.hypothesis.confidence - a.hypothesis.confidence;
+    }
+    return a.index - b.index;
+  }).map((entry) => entry.hypothesis);
+}
+var INFORMATIVE_LANES = ["network", "db", "browser", "flow"];
+function slugify(title) {
+  return title.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+}
+function signatureFor(symptom) {
+  if (symptom.errorSig && symptom.errorSig.length > 0) return symptom.errorSig;
+  const slug = slugify(symptom.title ?? "");
+  return slug.length > 0 ? slug : "unknown";
+}
+function suggestCaptureDirectives(symptom, evidence, gaps) {
+  const thin = evidence.length === 0 || gaps.length > 0;
+  if (!thin) return [];
+  const present = new Set(evidence.map((e) => e.lane));
+  const missing = INFORMATIVE_LANES.filter((lane) => !present.has(lane));
+  if (missing.length === 0) return [];
+  return [
+    {
+      signature: signatureFor(symptom),
+      raise: missing,
+      scope: "signature",
+      reason: `thin evidence for this signature; raise capture on: ${missing.join(", ")}`
+    }
+  ];
+}
+
+// src/evidence-source.ts
+var EVIDENCE_SOURCE_SCHEMA_VERSION = "evidence-source.v1";
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BROWSER_REDACTION_POLICY,
+  CRUMBTRAIL_EVENT_KINDS,
+  CRUMBTRAIL_REQUEST_HEADER,
+  CRUMBTRAIL_REQUEST_HEADER_LOWER,
+  CRUMBTRAIL_REQUEST_ID_MAX_LENGTH,
+  CRUMBTRAIL_SCHEMA_VERSION,
+  CRUMBTRAIL_SESSION_HEADER,
+  CRUMBTRAIL_SESSION_HEADER_LOWER,
+  Crumbtrail,
+  DB_DIFF_BULK_EVENT_KIND,
+  DB_DIFF_EVENT_KIND,
+  DB_READ_BULK_EVENT_KIND,
+  DB_READ_EVENT_KIND,
+  DEFAULT_CONFIG,
+  DEFAULT_SESSION_STORAGE_KEY,
+  EVIDENCE_SCHEMA_VERSION,
+  EVIDENCE_SOURCE_SCHEMA_VERSION,
+  EventBus,
+  FUSION_SCHEMA_VERSION,
+  HttpTransport,
+  PRESET_FULL,
+  PRESET_LIGHT,
+  PRESET_PASSIVE,
+  REDACTED_STORAGE_KEY,
+  REDACTED_VALUE,
+  RingBuffer,
+  W3C_TRACEPARENT_HEADER,
+  WebTargetDescriptorResolver,
+  abandonedFlowDetector,
+  assembleBundle,
+  attachRedactionMetadata,
+  buildEnvDelta,
+  buildEnvSnapshot,
+  canInjectCorrelationHeaders,
+  computeElementPath,
+  computeElementSignature,
+  createAutoFlagController,
+  createCrumbtrailRequestHeaders,
+  createWebSessionStore,
+  environmentCollector,
+  errorDetector,
+  errorSignature,
+  formatTraceparent,
+  generateRequestId,
+  generateSpanId,
+  generateTraceContext,
+  generateTraceId,
+  hashString,
+  inferIntent,
+  mergeRedactionMetadata,
+  parseTraceparent,
+  rageClickDetector,
+  redactCookieMap,
+  redactCookieName,
+  redactCookieValue,
+  redactHeaders,
+  redactInputValue,
+  redactNetworkTextBody,
+  redactStorageKey,
+  redactStoredValue,
+  redactTokenLikeString,
+  redactUrl,
+  redactUrlsInText,
+  redactValue,
+  resolveOutboundCorrelation,
+  retryStormDetector,
+  slowResponseDetector,
+  summarizeBinaryPayload,
+  summarizeOmittedPayload,
+  webTargetDescriptorResolver
+});