@fixback/sdk-core 0.2.0 → 0.3.0

package/dist/index.mjs

@@ -0,0 +1,1057 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
+// src/version.ts
+var SDK_CORE_VERSION = "0.3.0";
+
+// src/scrub.ts
+var MIN_DIGIT_RUN = 7;
+var EMAIL_RE = /[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}/gi;
+var DIGIT_RUN_RE = new RegExp(`\\d{${MIN_DIGIT_RUN},}`, "g");
+var BEARER_RE = /\b(bearer|token)\s+[\w.\-~+/]+=*/gi;
+var URL_IN_TEXT_RE = /\bhttps?:\/\/[^\s"'<>]+/gi;
+function redactPii(text) {
+  if (typeof text !== "string" || text.length === 0) return text;
+  return text.replace(EMAIL_RE, "[redacted-email]").replace(BEARER_RE, (_match, keyword) => `${keyword} [redacted]`).replace(DIGIT_RUN_RE, "[redacted-number]");
+}
+function redactPathPii(pathAndBeyond) {
+  return pathAndBeyond.replace(EMAIL_RE, "[redacted-email]").replace(DIGIT_RUN_RE, "[redacted-number]");
+}
+function scrubUrl(url) {
+  if (typeof url !== "string" || url.length === 0) return url;
+  let out = url;
+  out = out.replace(/(^[a-z][a-z0-9+.-]*:\/\/)[^/@?#]*@/i, "$1");
+  out = out.replace(/\?[^#]*/, "");
+  out = out.replace(
+    /#.*$/,
+    (fragment) => fragment.includes("=") ? "" : fragment
+  );
+  const absolute = out.match(/^([a-z][a-z0-9+.-]*:\/\/[^/?#]*)([\s\S]*)$/i);
+  if (absolute) return absolute[1] + redactPathPii(absolute[2] ?? "");
+  const protocolRelative = out.match(/^(\/\/[^/?#]*)([\s\S]*)$/);
+  if (protocolRelative) {
+    return protocolRelative[1] + redactPathPii(protocolRelative[2] ?? "");
+  }
+  return redactPathPii(out);
+}
+function scrubCrumbData(data) {
+  const next = { ...data };
+  if (typeof next.url === "string") next.url = scrubUrl(next.url);
+  if (typeof next.from === "string") next.from = scrubUrl(next.from);
+  if (typeof next.to === "string") next.to = scrubUrl(next.to);
+  return next;
+}
+function scrubMessage(message) {
+  return redactPii(message.replace(URL_IN_TEXT_RE, (url) => scrubUrl(url)));
+}
+function scrubArgValue(value) {
+  if (typeof value === "string") return scrubMessage(value);
+  if (Array.isArray(value)) return value.map(scrubArgValue);
+  if (value && typeof value === "object") {
+    const out = {};
+    for (const [key, v] of Object.entries(value)) {
+      out[key] = scrubArgValue(v);
+    }
+    return out;
+  }
+  return value;
+}
+function scrubConsoleArg(arg) {
+  switch (arg.t) {
+    case "string":
+      return typeof arg.v === "string" ? { t: "string", v: scrubMessage(arg.v) } : arg;
+    case "json":
+      return { t: "json", v: scrubArgValue(arg.v) };
+    case "error": {
+      if (!arg.v || typeof arg.v !== "object") return arg;
+      const v = arg.v;
+      const next = { ...v };
+      if (typeof next.message === "string") next.message = scrubMessage(next.message);
+      if (typeof next.stack === "string") next.stack = scrubMessage(next.stack);
+      return { t: "error", v: next };
+    }
+    default:
+      return arg;
+  }
+}
+function scrubCrumb(crumb) {
+  const next = { ...crumb };
+  if (typeof next.message === "string") next.message = scrubMessage(next.message);
+  if (next.data) next.data = scrubCrumbData(next.data);
+  if (typeof next.url === "string") next.url = scrubUrl(next.url);
+  if (Array.isArray(next.args)) next.args = next.args.map(scrubConsoleArg);
+  return next;
+}
+function applyDefaultScrub(draft) {
+  const next = { ...draft };
+  if (typeof next.url === "string") next.url = scrubUrl(next.url);
+  if (next.trace && next.trace.length > 0) {
+    next.trace = next.trace.map(scrubCrumb);
+  }
+  if (next.errorFrames && next.errorFrames.length > 0) {
+    next.errorFrames = next.errorFrames.map((frame) => ({
+      ...frame,
+      file: scrubUrl(frame.file)
+    }));
+  }
+  return next;
+}
+function runBeforeSend(draft, options = {}) {
+  const current = options.scrub === false ? draft : applyDefaultScrub(draft);
+  const hook = options.hook;
+  if (!hook) return current;
+  try {
+    const result = hook(current);
+    return result ?? null;
+  } catch {
+    return current;
+  }
+}
+
+// src/stack.ts
+var STRUCTURED_FRAME_LIMIT = 30;
+function parseStackLine(line) {
+  const v8Named = line.match(/^at\s+(.+?)\s+\((.+)\)$/);
+  if (v8Named) return { fn: v8Named[1] ?? null, location: v8Named[2] ?? "" };
+  const v8Bare = line.match(/^at\s+(.+)$/);
+  if (v8Bare) return { fn: null, location: v8Bare[1] ?? "" };
+  const at = line.indexOf("@");
+  if (at >= 0) {
+    return { fn: at > 0 ? line.slice(0, at) : null, location: line.slice(at + 1) };
+  }
+  return null;
+}
+function parseFrameLocation(location) {
+  const match = location.match(/^(.*?):(\d+)(?::(\d+))?$/);
+  if (!match) return null;
+  const file = match[1] ?? "";
+  if (file.length === 0 || file === "native" || file.includes("<anonymous>")) {
+    return null;
+  }
+  const line = Number(match[2]);
+  if (!Number.isFinite(line)) return null;
+  const column = match[3] !== void 0 ? Number(match[3]) : null;
+  return { file, line, column };
+}
+function extractStructuredFrames(stack, limit = STRUCTURED_FRAME_LIMIT) {
+  if (typeof stack !== "string" || stack.length === 0) return [];
+  const frames = [];
+  for (const raw of stack.split("\n")) {
+    if (frames.length >= limit) break;
+    const tokens = parseStackLine(raw.trim());
+    if (!tokens || !tokens.location) continue;
+    const parsed = parseFrameLocation(tokens.location);
+    if (!parsed) continue;
+    frames.push({
+      file: scrubUrl(parsed.file),
+      line: parsed.line,
+      column: parsed.column,
+      function: tokens.fn && tokens.fn.length > 0 ? tokens.fn : null
+    });
+  }
+  return frames;
+}
+
+// src/fingerprint.ts
+var UUID_RE = /[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/gi;
+var URL_RE = /\bhttps?:\/\/[^\s"')]+/gi;
+var HEX_0X_RE = /\b0x[0-9a-f]+\b/gi;
+var HEX_RUN_RE = /\b[0-9a-f]{8,}\b/gi;
+var DIGIT_RUN_RE2 = /\d{4,}/g;
+var FINGERPRINT_FRAME_LIMIT = 5;
+function normalize(value) {
+  if (typeof value !== "string" || value.length === 0) return "";
+  return value.replace(UUID_RE, "<uuid>").replace(URL_RE, "<url>").replace(HEX_0X_RE, "<hex>").replace(HEX_RUN_RE, "<hex>").replace(DIGIT_RUN_RE2, "<n>").trim();
+}
+function hashString(input) {
+  let h = 2166136261;
+  for (let i = 0; i < input.length; i++) {
+    h ^= input.charCodeAt(i);
+    h = Math.imul(h, 16777619);
+  }
+  return (h >>> 0).toString(36);
+}
+function compactLocation(location) {
+  const noQuery = location.replace(/\?[^:]*/, "");
+  const lastSlash = noQuery.lastIndexOf("/");
+  return lastSlash >= 0 ? noQuery.slice(lastSlash + 1) : noQuery;
+}
+function parseFrame(line) {
+  const tokens = parseStackLine(line);
+  if (!tokens) return null;
+  return `${tokens.fn ?? ""}@${compactLocation(tokens.location)}`;
+}
+function extractTopFrames(stack, limit = FINGERPRINT_FRAME_LIMIT) {
+  if (typeof stack !== "string" || stack.length === 0) return "";
+  const frames = [];
+  for (const raw of stack.split("\n")) {
+    const frame = parseFrame(raw.trim());
+    if (frame) {
+      frames.push(frame);
+      if (frames.length >= limit) break;
+    }
+  }
+  return frames.join(" < ");
+}
+function computeFingerprint(type, value, stack) {
+  return hashString(`${type}|${normalize(value)}|${extractTopFrames(stack)}`);
+}
+
+// src/backoff.ts
+var DEFAULT_RETRY_AFTER_SECONDS = 60;
+function parseRetryAfter(header, now) {
+  if (header == null) return DEFAULT_RETRY_AFTER_SECONDS;
+  const value = header.trim();
+  if (value === "") return DEFAULT_RETRY_AFTER_SECONDS;
+  if (/^\d+$/.test(value)) {
+    return Number(value);
+  }
+  const when = Date.parse(value);
+  if (!Number.isNaN(when)) {
+    return Math.max(0, Math.ceil((when - now) / 1e3));
+  }
+  return DEFAULT_RETRY_AFTER_SECONDS;
+}
+var AutoReportBackoff = class {
+  constructor(now = Date.now) {
+    this.now = now;
+    /** Epoch ms until which automatic reports are held; `0` when clear. */
+    __publicField(this, "pausedUntil", 0);
+  }
+  /** Is the automatic-report pause window currently open? */
+  isPaused() {
+    return this.now() < this.pausedUntil;
+  }
+  /** Whole seconds remaining in the pause window (`0` when clear). */
+  retryAfterSeconds() {
+    return Math.max(0, Math.ceil((this.pausedUntil - this.now()) / 1e3));
+  }
+  /**
+   * Open (or extend) the window from a `429`'s `Retry-After` value, returning the
+   * seconds it will hold for. The window only ever grows — a shorter later hold
+   * never clips a longer one already in effect.
+   */
+  hold(retryAfterHeader) {
+    const now = this.now();
+    const seconds = parseRetryAfter(retryAfterHeader, now);
+    const until = now + seconds * 1e3;
+    if (until > this.pausedUntil) this.pausedUntil = until;
+    return seconds;
+  }
+};
+
+// src/env.ts
+function nowMono() {
+  const perf = globalThis.performance;
+  return perf && typeof perf.now === "function" ? perf.now() : Date.now();
+}
+function textEncoder() {
+  return globalThis.TextEncoder;
+}
+function utf8ByteLength(value) {
+  try {
+    const Encoder = textEncoder();
+    return Encoder ? new Encoder().encode(value).length : value.length;
+  } catch {
+    return value.length;
+  }
+}
+function serializedBytes(value) {
+  try {
+    const json = JSON.stringify(value) ?? "";
+    return utf8ByteLength(json);
+  } catch {
+    return Number.POSITIVE_INFINITY;
+  }
+}
+function trivialBodySize(body) {
+  if (typeof body === "string") return utf8ByteLength(body);
+  const BlobCtor = globalThis.Blob;
+  if (BlobCtor && body instanceof BlobCtor) return body.size;
+  if (typeof ArrayBuffer !== "undefined") {
+    if (body instanceof ArrayBuffer) return body.byteLength;
+    if (ArrayBuffer.isView(body)) return body.byteLength;
+  }
+  return void 0;
+}
+
+// src/http.ts
+function resolveFetch() {
+  const g = globalThis;
+  if (typeof g.fetch !== "function") return void 0;
+  const bound = g.fetch.bind(globalThis);
+  return (url, init) => bound(url, init);
+}
+function safeHeader(response, name) {
+  try {
+    return response.headers?.get?.(name) ?? null;
+  } catch {
+    return null;
+  }
+}
+
+// src/boot.ts
+function bootEndpoint(apiUrl) {
+  return `${apiUrl.replace(/\/+$/, "")}/api/ingest/boot`;
+}
+function feedbackEndpoint(apiUrl) {
+  return `${apiUrl.replace(/\/+$/, "")}/api/ingest/feedback`;
+}
+function isBootAnswer(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const v = value;
+  return typeof v.originAllowed === "boolean" && typeof v.canSubmit === "boolean" && typeof v.gate === "string" && (v.tier === null || typeof v.tier === "string");
+}
+function compactIdentity(identity) {
+  if (!identity) return {};
+  const out = {};
+  if (identity.hostIdentity) out.hostIdentity = identity.hostIdentity;
+  if (identity.reporterSession) out.reporterSession = identity.reporterSession;
+  if (identity.anonymousId) out.anonymousId = identity.anonymousId;
+  return out;
+}
+function isFixbackApiRequest(apiUrl, url) {
+  const apiBase = apiUrl.replace(/\/+$/, "");
+  return url.startsWith(`${apiBase}/api/ingest/`) || url.startsWith(`${apiBase}/api/connect/`);
+}
+async function requestBoot(apiUrl, request, deps = {}) {
+  const doFetch = deps.fetch ?? resolveFetch();
+  if (!doFetch) return null;
+  let response;
+  try {
+    response = await doFetch(bootEndpoint(apiUrl), {
+      method: "POST",
+      headers: {
+        "content-type": "application/json",
+        ...deps.origin ? { origin: deps.origin } : {}
+      },
+      body: JSON.stringify(request)
+    });
+  } catch {
+    return null;
+  }
+  if (!response.ok) return null;
+  let body;
+  try {
+    body = await response.json?.();
+  } catch {
+    return null;
+  }
+  return isBootAnswer(body) ? body : null;
+}
+
+// src/connect.ts
+var CONNECT_MESSAGE_SOURCE = "fixback-connect";
+var CONNECT_RETURN_PARAM = "fixback";
+function connectExchangeEndpoint(apiUrl) {
+  return `${apiUrl.replace(/\/+$/, "")}/api/connect/exchange`;
+}
+function connectSignOutEndpoint(apiUrl) {
+  return `${apiUrl.replace(/\/+$/, "")}/api/connect/signout`;
+}
+function buildConnectUrl(connectUrl, params) {
+  const base = connectUrl.split("#")[0] ?? connectUrl;
+  const sep = base.includes("?") ? "&" : "?";
+  const query = `key=${encodeURIComponent(params.key)}&return=${encodeURIComponent(params.returnUrl)}`;
+  return `${base}${sep}${query}`;
+}
+function reporterSessionStorageKey(publishableKey) {
+  return `fixback.reporterSession.${publishableKey}`;
+}
+function parseConnectMessage(data) {
+  if (typeof data !== "object" || data === null) return null;
+  const v = data;
+  if (v.source !== CONNECT_MESSAGE_SOURCE) return null;
+  return typeof v.code === "string" && v.code.length > 0 ? v.code : null;
+}
+function isConnectExchangeResponse(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const v = value;
+  if (typeof v.reporterSession !== "string" || v.reporterSession.length === 0) {
+    return false;
+  }
+  const account = v.account;
+  return typeof account === "object" && account !== null && typeof account.name === "string" && typeof account.email === "string";
+}
+async function exchangeConnectCode(apiUrl, request, deps = {}) {
+  const doFetch = deps.fetch ?? resolveFetch();
+  if (!doFetch) return null;
+  let response;
+  try {
+    response = await doFetch(connectExchangeEndpoint(apiUrl), {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify(request)
+    });
+  } catch {
+    return null;
+  }
+  if (!response.ok) return null;
+  let body;
+  try {
+    body = await response.json?.();
+  } catch {
+    return null;
+  }
+  return isConnectExchangeResponse(body) ? body : null;
+}
+async function revokeReporterSession(apiUrl, token, deps = {}) {
+  const doFetch = deps.fetch ?? resolveFetch();
+  if (!doFetch) return;
+  try {
+    await doFetch(connectSignOutEndpoint(apiUrl), {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({ reporterSession: token })
+    });
+  } catch {
+  }
+}
+
+// src/anonymous-id.ts
+var ANONYMOUS_ID_STORAGE_KEY = "fixback.anonymousId";
+function generateAnonymousId() {
+  const c = globalThis.crypto;
+  if (c && typeof c.randomUUID === "function") {
+    try {
+      return c.randomUUID();
+    } catch {
+    }
+  }
+  return `fb-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`;
+}
+
+// src/release.ts
+var RELEASE_MAX_LENGTH = 100;
+var RESERVED_RELEASES = /* @__PURE__ */ new Set([".", "..", "latest"]);
+function normaliseRelease(value) {
+  const trimmed = value.trim();
+  if (trimmed.length === 0 || trimmed.length > RELEASE_MAX_LENGTH) return void 0;
+  if (RESERVED_RELEASES.has(trimmed)) return void 0;
+  if (/[\s/\\\u0000-\u001f\u007f]/.test(trimmed)) return void 0;
+  return trimmed;
+}
+
+// src/options.ts
+var DEFAULT_API_URL = "https://api.fixback.dev";
+
+// src/trace/console-args.ts
+var MAX_MESSAGE_LENGTH = 300;
+var MAX_ARG_DEPTH = 4;
+var MAX_ARG_ITEMS = 100;
+var MAX_ARG_STRING_LENGTH = 1024;
+var MAX_CONSOLE_ARGS_BYTES = 4096;
+var MAX_ERROR_STACK_LENGTH = 2048;
+function capLength(value, max) {
+  return value.length > max ? `${value.slice(0, max)}\u2026` : value;
+}
+function stringifyArg(arg) {
+  if (typeof arg === "string") return arg;
+  if (arg instanceof Error) return `${arg.name}: ${arg.message}`;
+  if (arg === null || arg === void 0) return String(arg);
+  if (typeof arg === "number" || typeof arg === "boolean") return String(arg);
+  try {
+    return JSON.stringify(arg) ?? String(arg);
+  } catch {
+    return "[object]";
+  }
+}
+function joinArgs(args) {
+  const text = args.map(stringifyArg).join(" ");
+  return text.length > MAX_MESSAGE_LENGTH ? `${text.slice(0, MAX_MESSAGE_LENGTH)}\u2026` : text;
+}
+function describeErrorValue(error) {
+  const out = {
+    name: error.name || "Error",
+    message: capLength(String(error.message ?? ""), MAX_ARG_STRING_LENGTH)
+  };
+  if (typeof error.stack === "string" && error.stack.length > 0) {
+    out.stack = capLength(error.stack, MAX_ERROR_STACK_LENGTH);
+  }
+  return out;
+}
+function safeCloneValue(value, depth, seen) {
+  if (value === null) return null;
+  const type = typeof value;
+  if (type === "string") return capLength(value, MAX_ARG_STRING_LENGTH);
+  if (type === "number") return Number.isFinite(value) ? value : String(value);
+  if (type === "boolean") return value;
+  if (type === "bigint") return `${value.toString()}n`;
+  if (type === "symbol") return value.toString();
+  if (type === "function") return "[Function]";
+  if (type === "undefined") return null;
+  const obj = value;
+  if (value instanceof Error) {
+    const { name, message } = describeErrorValue(value);
+    return { name, message };
+  }
+  if (seen.has(obj)) return "[Circular]";
+  if (depth <= 0) return Array.isArray(value) ? "[Array]" : "[Object]";
+  seen.add(obj);
+  try {
+    if (Array.isArray(value)) {
+      const items = value.slice(0, MAX_ARG_ITEMS).map((item) => safeCloneValue(item, depth - 1, seen));
+      if (value.length > MAX_ARG_ITEMS) {
+        items.push(`\u2026 ${value.length - MAX_ARG_ITEMS} more`);
+      }
+      return items;
+    }
+    const source = value;
+    const keys = Object.keys(source);
+    const out = {};
+    for (const key of keys.slice(0, MAX_ARG_ITEMS)) {
+      const child = source[key];
+      if (typeof child === "undefined" || typeof child === "function") continue;
+      out[key] = safeCloneValue(child, depth - 1, seen);
+    }
+    if (keys.length > MAX_ARG_ITEMS) out["\u2026"] = `${keys.length - MAX_ARG_ITEMS} more`;
+    return out;
+  } finally {
+    seen.delete(obj);
+  }
+}
+function toConsoleArg(value) {
+  if (value === null || value === void 0) return { t: "null", v: null };
+  const type = typeof value;
+  if (type === "string") {
+    return { t: "string", v: capLength(value, MAX_ARG_STRING_LENGTH) };
+  }
+  if (type === "number") {
+    return Number.isFinite(value) ? { t: "number", v: value } : { t: "string", v: String(value) };
+  }
+  if (type === "boolean") return { t: "bool", v: value };
+  if (type === "bigint") return { t: "string", v: `${value.toString()}n` };
+  if (type === "symbol") return { t: "string", v: value.toString() };
+  if (type === "function") return { t: "string", v: "[Function]" };
+  if (value instanceof Error) return { t: "error", v: describeErrorValue(value) };
+  return { t: "json", v: safeCloneValue(value, MAX_ARG_DEPTH, /* @__PURE__ */ new Set()) };
+}
+function capConsoleArgs(args) {
+  if (serializedBytes(args) <= MAX_CONSOLE_ARGS_BYTES) return args;
+  let out = args.slice();
+  while (out.length > 1 && serializedBytes(out) > MAX_CONSOLE_ARGS_BYTES) {
+    out = out.slice(0, -1);
+  }
+  if (out.length === 1 && serializedBytes(out) > MAX_CONSOLE_ARGS_BYTES) {
+    return [{ t: "string", v: "[trace: console argument omitted (too large)]" }];
+  }
+  return out;
+}
+
+// src/trace/crumbs.ts
+var MAX_URL_LENGTH = 2048;
+function consoleCrumb(level, args, timestamp, source) {
+  const structured = capConsoleArgs(args.map(toConsoleArg));
+  return {
+    category: "console",
+    level,
+    message: joinArgs(args),
+    timestamp,
+    ...structured.length > 0 ? { args: structured } : {},
+    ...source ? { source } : {}
+  };
+}
+function navigationCrumb(from, to, timestamp) {
+  const fromUrl = capLength(scrubUrl(from), MAX_URL_LENGTH);
+  const toUrl = capLength(scrubUrl(to), MAX_URL_LENGTH);
+  return {
+    category: "navigation",
+    message: `${fromUrl} \u2192 ${toUrl}`,
+    timestamp,
+    data: { from: fromUrl, to: toUrl }
+  };
+}
+function outcomeFromStatus(status) {
+  if (typeof status !== "number" || status <= 0) return "network-error";
+  if (status >= 500) return "http-5xx";
+  if (status >= 400) return "http-4xx";
+  return "ok";
+}
+function parseContentLength(value) {
+  if (typeof value !== "string") return void 0;
+  const bytes = Number.parseInt(value, 10);
+  return Number.isFinite(bytes) && bytes >= 0 ? bytes : void 0;
+}
+function contentTypeOf(value) {
+  if (typeof value !== "string" || value.length === 0) return void 0;
+  const media = value.split(";")[0]?.trim();
+  return media && media.length > 0 ? media : void 0;
+}
+function networkCrumb(input, timestamp) {
+  const url = capLength(scrubUrl(input.url), MAX_URL_LENGTH);
+  const hasStatus = typeof input.status === "number" && input.status > 0;
+  const statusPart = hasStatus ? ` \u2192 ${input.status}` : "";
+  const outcomePart = input.outcome !== "ok" ? ` (${input.outcome})` : "";
+  return {
+    category: input.api,
+    api: input.api,
+    method: input.method,
+    url,
+    message: `${input.method} ${url}${statusPart}${outcomePart}`,
+    timestamp,
+    ...hasStatus ? { status: input.status } : {},
+    ...input.statusText ? { statusText: input.statusText } : {},
+    ...typeof input.durationMs === "number" ? { durationMs: input.durationMs } : {},
+    ...typeof input.reqSize === "number" ? { reqSize: input.reqSize } : {},
+    ...typeof input.respSize === "number" ? { respSize: input.respSize } : {},
+    ...input.contentType ? { contentType: input.contentType } : {},
+    outcome: input.outcome
+  };
+}
+function fetchCrumb(method, url, status, timestamp) {
+  return networkCrumb(
+    { api: "fetch", method, url, status, outcome: outcomeFromStatus(status) },
+    timestamp
+  );
+}
+function xhrCrumb(method, url, status, timestamp) {
+  return networkCrumb(
+    { api: "xhr", method, url, status, outcome: outcomeFromStatus(status) },
+    timestamp
+  );
+}
+function describeError(error) {
+  if (error instanceof Error) {
+    return { name: error.name || "Error", message: error.message };
+  }
+  if (typeof error === "string") return { name: "Error", message: error };
+  return { name: "Error", message: stringifyArg(error) };
+}
+function errorCrumb(error, timestamp, causedBy) {
+  const { name, message } = describeError(error);
+  const crumb = {
+    category: "error",
+    level: "error",
+    message: message ? `${name}: ${message}` : name,
+    timestamp,
+    data: { errorType: name }
+  };
+  return causedBy && causedBy.length > 0 ? { ...crumb, causedBy } : crumb;
+}
+
+// src/auto-capture.ts
+var DEFAULT_BURST_CAPACITY = 5;
+var DEFAULT_BURST_REFILL_MS = 2e3;
+var DEFAULT_MAX_DISTINCT_AUTO = 20;
+var CAUSED_BY_LIMIT = 5;
+function asString(value) {
+  if (typeof value === "string") return value;
+  if (value == null) return "";
+  try {
+    return String(value);
+  } catch {
+    return "";
+  }
+}
+function precedingIds(entries) {
+  if (!entries || entries.length === 0) return [];
+  const ids = [];
+  for (let i = entries.length - 1; i >= 0 && ids.length < CAUSED_BY_LIMIT; i -= 1) {
+    const id = entries[i]?.id;
+    if (typeof id === "string" && id.length > 0) ids.unshift(id);
+  }
+  return ids;
+}
+var TokenBucket = class {
+  constructor(options) {
+    this.options = options;
+    __publicField(this, "tokens");
+    __publicField(this, "last");
+    __publicField(this, "now");
+    this.now = options.now ?? Date.now;
+    this.tokens = Math.max(0, options.capacity);
+    this.last = this.now();
+  }
+  /** Consume a token if one is available (refilling first), else refuse. */
+  take() {
+    const now = this.now();
+    const { capacity, refillIntervalMs } = this.options;
+    if (refillIntervalMs > 0 && now > this.last) {
+      const refill = Math.floor((now - this.last) / refillIntervalMs);
+      if (refill > 0) {
+        this.tokens = Math.min(capacity, this.tokens + refill);
+        this.last += refill * refillIntervalMs;
+      }
+    }
+    if (this.tokens >= 1) {
+      this.tokens -= 1;
+      return true;
+    }
+    return false;
+  }
+};
+function createAutoCapture(config) {
+  const now = config.now ?? Date.now;
+  const maxDistinct = config.maxDistinct ?? DEFAULT_MAX_DISTINCT_AUTO;
+  const bucket = new TokenBucket({
+    capacity: config.burstCapacity ?? DEFAULT_BURST_CAPACITY,
+    refillIntervalMs: config.burstRefillMs ?? DEFAULT_BURST_REFILL_MS,
+    now
+  });
+  const seen = /* @__PURE__ */ new Map();
+  let dropped = 0;
+  async function file(fingerprint, occurrences, rich) {
+    const entry = seen.get(fingerprint);
+    if (!entry) return;
+    const previouslySent = entry.sentCount;
+    entry.sentCount = occurrences;
+    try {
+      const accepted = await config.submit({
+        fingerprint,
+        occurrences,
+        rich,
+        frames: entry.frames
+      });
+      if (!accepted && entry.sentCount === occurrences) {
+        entry.sentCount = previouslySent;
+      }
+    } catch {
+      if (entry.sentCount === occurrences) entry.sentCount = previouslySent;
+    }
+  }
+  function handle(extracted) {
+    const fingerprint = computeFingerprint(
+      extracted.type,
+      extracted.value,
+      extracted.stack
+    );
+    const existing = seen.get(fingerprint);
+    if (existing) {
+      existing.count += 1;
+      existing.lastAt = now();
+      return;
+    }
+    if (!bucket.take()) {
+      dropped += 1;
+      return;
+    }
+    if (seen.size >= maxDistinct) {
+      dropped += 1;
+      return;
+    }
+    const at = now();
+    seen.set(fingerprint, {
+      count: 1,
+      firstAt: at,
+      lastAt: at,
+      sentCount: 0,
+      // Parsed once per fingerprint, from the first firing's stack (#117) — the
+      // wire shape symbolication consumes, scrubbed like every captured URL.
+      frames: extractStructuredFrames(extracted.stack)
+    });
+    try {
+      const causedBy = precedingIds(config.buffer?.snapshot());
+      config.buffer?.add(errorCrumb(extracted.original, at, causedBy));
+    } catch {
+    }
+    void file(fingerprint, 1, true);
+  }
+  return {
+    capture(raw) {
+      try {
+        const extracted = config.extract(raw);
+        if (extracted) handle(extracted);
+      } catch {
+      }
+    },
+    flush() {
+      try {
+        for (const [fingerprint, entry] of seen) {
+          if (entry.count > entry.sentCount) {
+            void file(fingerprint, entry.count, false);
+          }
+        }
+      } catch {
+      }
+    },
+    droppedCount: () => dropped
+  };
+}
+
+// src/trace/buffer.ts
+var DEFAULT_STREAM_BUDGETS = {
+  network: 100,
+  console: 80,
+  breadcrumbs: 40
+};
+var DEFAULT_MAX_AGE_MS = 3 * 60 * 1e3;
+var DEFAULT_CONSOLE_LEVELS = [
+  "log",
+  "info",
+  "warn",
+  "error",
+  "assert",
+  "debug"
+];
+var PINNED_CONSOLE_LEVELS = [
+  "warn",
+  "error",
+  "assert"
+];
+function isPinnedConsoleLevel(level) {
+  return level !== void 0 && PINNED_CONSOLE_LEVELS.includes(level);
+}
+var SOURCE_CAPTURE_LEVELS = PINNED_CONSOLE_LEVELS;
+function capturesSource(level) {
+  return SOURCE_CAPTURE_LEVELS.includes(level);
+}
+function streamOf(category) {
+  if (category === "console") return "console";
+  if (category === "fetch" || category === "xhr" || category === "beacon") {
+    return "network";
+  }
+  return "breadcrumbs";
+}
+function normalizeBudget(value, fallback) {
+  if (typeof value !== "number" || !Number.isFinite(value) || value < 1) {
+    return fallback;
+  }
+  return Math.floor(value);
+}
+function createIdFactory() {
+  const salt = Math.random().toString(36).slice(2, 8);
+  let seq = 0;
+  return () => `${salt}${(seq++).toString(36)}`;
+}
+var STREAMS = ["network", "console", "breadcrumbs"];
+function trimConsoleStream(held, budget) {
+  const over = held.length - budget;
+  if (over <= 0) return held;
+  const drop = /* @__PURE__ */ new Set();
+  for (let i = 0; i < held.length && drop.size < over; i += 1) {
+    if (!isPinnedConsoleLevel(held[i].crumb.level)) drop.add(i);
+  }
+  for (let i = 0; i < held.length && drop.size < over; i += 1) {
+    if (!drop.has(i)) drop.add(i);
+  }
+  return held.filter((_, i) => !drop.has(i));
+}
+function createBreadcrumbBuffer(config = {}) {
+  const budgets = {
+    network: normalizeBudget(config.budgets?.network, DEFAULT_STREAM_BUDGETS.network),
+    console: normalizeBudget(config.budgets?.console, DEFAULT_STREAM_BUDGETS.console),
+    breadcrumbs: normalizeBudget(
+      config.budgets?.breadcrumbs,
+      DEFAULT_STREAM_BUDGETS.breadcrumbs
+    )
+  };
+  const maxAgeMs = config.maxAgeMs === void 0 ? DEFAULT_MAX_AGE_MS : config.maxAgeMs;
+  const beforeBreadcrumb = config.beforeBreadcrumb;
+  const now = config.now ?? Date.now;
+  const mono = config.mono ?? nowMono;
+  const nextId = config.nextId ?? createIdFactory();
+  const streams = {
+    network: [],
+    console: [],
+    breadcrumbs: []
+  };
+  let seq = 0;
+  function pruneByAge() {
+    if (typeof maxAgeMs !== "number" || maxAgeMs <= 0) return;
+    const cutoff = now() - maxAgeMs;
+    for (const stream of STREAMS) {
+      const held = streams[stream];
+      if (held.length > 0) {
+        streams[stream] = held.filter((h) => h.crumb.timestamp >= cutoff);
+      }
+    }
+  }
+  return {
+    add(crumb) {
+      let entry = crumb;
+      if (beforeBreadcrumb) {
+        try {
+          entry = beforeBreadcrumb(crumb);
+        } catch {
+          entry = crumb;
+        }
+      }
+      if (!entry) return;
+      const stamped = {
+        ...entry,
+        id: entry.id ?? nextId(),
+        timestamp: typeof entry.timestamp === "number" ? entry.timestamp : now(),
+        mono: typeof entry.mono === "number" ? entry.mono : mono()
+      };
+      const stream = streamOf(stamped.category);
+      streams[stream].push({ crumb: stamped, seq: seq++ });
+      pruneByAge();
+      const held = streams[stream];
+      const budget = budgets[stream];
+      if (held.length > budget) {
+        streams[stream] = stream === "console" ? trimConsoleStream(held, budget) : held.slice(-budget);
+      }
+    },
+    snapshot() {
+      pruneByAge();
+      const merged = [];
+      for (const stream of STREAMS) merged.push(...streams[stream]);
+      merged.sort((a, b) => {
+        const am = typeof a.crumb.mono === "number" ? a.crumb.mono : a.crumb.timestamp;
+        const bm = typeof b.crumb.mono === "number" ? b.crumb.mono : b.crumb.timestamp;
+        return am - bm || a.seq - b.seq;
+      });
+      return merged.map((h) => h.crumb);
+    },
+    clear() {
+      streams.network = [];
+      streams.console = [];
+      streams.breadcrumbs = [];
+      seq = 0;
+    }
+  };
+}
+
+// src/trace/source.ts
+function parseStackFrame(line) {
+  const tokens = parseStackLine(line);
+  if (!tokens || !tokens.location) return void 0;
+  const loc = tokens.location.replace(/\?[^:]*/, "");
+  const m = loc.match(/^(.*):(\d+):\d+$/) ?? loc.match(/^(.*):(\d+)$/);
+  if (!m) return void 0;
+  const file = m[1] ?? "";
+  const lineNo = Number(m[2]);
+  if (!file || !Number.isFinite(lineNo)) return void 0;
+  return { file, line: lineNo };
+}
+function sourceFromStack(stack, skipFrames = 0) {
+  if (typeof stack !== "string" || stack.length === 0) return void 0;
+  const frames = [];
+  for (const raw of stack.split("\n")) {
+    const frame = parseStackFrame(raw.trim());
+    if (frame) frames.push(frame);
+  }
+  return frames[skipFrames];
+}
+var CONSOLE_SOURCE_SKIP_FRAMES = 1;
+
+// src/trace/console.ts
+function instrumentConsole(buffer, consoleObj, levels, now) {
+  const restores = [];
+  for (const level of levels) {
+    const original = consoleObj[level];
+    if (typeof original !== "function") continue;
+    const withSource = capturesSource(level);
+    const wrapper = (...args) => {
+      let source;
+      if (withSource) {
+        try {
+          source = sourceFromStack(new Error().stack, CONSOLE_SOURCE_SKIP_FRAMES);
+        } catch {
+          source = void 0;
+        }
+      }
+      try {
+        if (level === "assert") {
+          if (!args[0]) {
+            buffer.add(consoleCrumb("assert", args.slice(1), now(), source));
+          }
+        } else {
+          buffer.add(consoleCrumb(level, args, now(), source));
+        }
+      } catch {
+      }
+      return original.apply(consoleObj, args);
+    };
+    consoleObj[level] = wrapper;
+    restores.push(() => {
+      consoleObj[level] = original;
+    });
+  }
+  return () => {
+    for (const restore of restores) restore();
+  };
+}
+export {
+  ANONYMOUS_ID_STORAGE_KEY,
+  AutoReportBackoff,
+  CAUSED_BY_LIMIT,
+  CONNECT_MESSAGE_SOURCE,
+  CONNECT_RETURN_PARAM,
+  CONSOLE_SOURCE_SKIP_FRAMES,
+  DEFAULT_API_URL,
+  DEFAULT_BURST_CAPACITY,
+  DEFAULT_BURST_REFILL_MS,
+  DEFAULT_CONSOLE_LEVELS,
+  DEFAULT_MAX_AGE_MS,
+  DEFAULT_MAX_DISTINCT_AUTO,
+  DEFAULT_RETRY_AFTER_SECONDS,
+  DEFAULT_STREAM_BUDGETS,
+  MAX_ARG_DEPTH,
+  MAX_ARG_ITEMS,
+  MAX_ARG_STRING_LENGTH,
+  MAX_CONSOLE_ARGS_BYTES,
+  MAX_MESSAGE_LENGTH,
+  MAX_URL_LENGTH,
+  PINNED_CONSOLE_LEVELS,
+  RELEASE_MAX_LENGTH,
+  SDK_CORE_VERSION,
+  SOURCE_CAPTURE_LEVELS,
+  TokenBucket,
+  applyDefaultScrub,
+  asString,
+  bootEndpoint,
+  buildConnectUrl,
+  capConsoleArgs,
+  capLength,
+  capturesSource,
+  compactIdentity,
+  computeFingerprint,
+  connectExchangeEndpoint,
+  connectSignOutEndpoint,
+  consoleCrumb,
+  contentTypeOf,
+  createAutoCapture,
+  createBreadcrumbBuffer,
+  createIdFactory,
+  describeError,
+  describeErrorValue,
+  errorCrumb,
+  exchangeConnectCode,
+  extractStructuredFrames,
+  extractTopFrames,
+  feedbackEndpoint,
+  fetchCrumb,
+  generateAnonymousId,
+  hashString,
+  instrumentConsole,
+  isBootAnswer,
+  isConnectExchangeResponse,
+  isFixbackApiRequest,
+  isPinnedConsoleLevel,
+  joinArgs,
+  navigationCrumb,
+  networkCrumb,
+  normaliseRelease,
+  normalize,
+  normalizeBudget,
+  nowMono,
+  outcomeFromStatus,
+  parseConnectMessage,
+  parseContentLength,
+  parseFrameLocation,
+  parseRetryAfter,
+  parseStackFrame,
+  parseStackLine,
+  precedingIds,
+  redactPii,
+  reporterSessionStorageKey,
+  requestBoot,
+  resolveFetch,
+  revokeReporterSession,
+  runBeforeSend,
+  safeCloneValue,
+  safeHeader,
+  scrubUrl,
+  serializedBytes,
+  sourceFromStack,
+  streamOf,
+  stringifyArg,
+  toConsoleArg,
+  trimConsoleStream,
+  trivialBodySize,
+  utf8ByteLength,
+  xhrCrumb
+};
+//# sourceMappingURL=index.mjs.map