@morsehq-dev/sdk 0.4.0-rc.1

package/dist/browser/chunk-O4HG3OSK.cjs

@@ -0,0 +1,929 @@
+'use strict';
+
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res, err) => function __init() {
+  if (err) throw err[0];
+  try {
+    return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+  } catch (e) {
+    throw err = [e], e;
+  }
+};
+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/_internal/env.ts
+function readEnv(key) {
+  if (typeof process !== "undefined" && process.env) {
+    const v = process.env[key];
+    if (typeof v === "string") return v;
+  }
+  const denoGlobal = globalThis.Deno;
+  if (denoGlobal?.env?.get) {
+    try {
+      const v = denoGlobal.env.get(key);
+      if (typeof v === "string") return v;
+    } catch {
+    }
+  }
+  return void 0;
+}
+function truthy(value) {
+  if (!value) return false;
+  return ["1", "true", "yes", "on"].includes(value.trim().toLowerCase());
+}
+function getApiKey() {
+  const raw = readEnv("MORSE_API_KEY");
+  if (!raw) return void 0;
+  const trimmed = raw.trim();
+  return trimmed || void 0;
+}
+function getEndpoint() {
+  const raw = readEnv("MORSE_ENDPOINT");
+  if (!raw) return void 0;
+  const trimmed = raw.trim();
+  return trimmed || void 0;
+}
+function getFlushIntervalSeconds(defaultSeconds = 2) {
+  const raw = readEnv("MORSE_FLUSH_INTERVAL_SECONDS");
+  if (!raw) return defaultSeconds;
+  const parsed = Number.parseFloat(raw.trim());
+  if (!Number.isFinite(parsed) || parsed <= 0) return defaultSeconds;
+  return parsed;
+}
+function isDisabled() {
+  return truthy(readEnv("MORSE_DISABLED"));
+}
+function isDebug() {
+  return truthy(readEnv("MORSE_SDK_DEBUG"));
+}
+function isTelemetryDisabled() {
+  return truthy(readEnv("MORSE_SDK_DISABLE_TELEMETRY"));
+}
+function getInternalSource() {
+  const raw = readEnv("MORSE_INTERNAL_SOURCE");
+  if (!raw) return void 0;
+  const trimmed = raw.trim().toLowerCase();
+  if (!trimmed) return void 0;
+  return VALID_INTERNAL_SOURCES.has(trimmed) ? trimmed : void 0;
+}
+function isValidInternalSource(value) {
+  return typeof value === "string" && VALID_INTERNAL_SOURCES.has(value);
+}
+function getSampleRate(defaultRate = 1) {
+  const raw = readEnv("MORSE_SAMPLE_RATE");
+  if (!raw) return defaultRate;
+  const parsed = Number.parseFloat(raw.trim());
+  if (!Number.isFinite(parsed) || parsed < 0 || parsed > 1) return defaultRate;
+  return parsed;
+}
+function getMaxFieldBytes(defaultBytes = 65536) {
+  const raw = readEnv("MORSE_MAX_FIELD_BYTES");
+  if (!raw) return defaultBytes;
+  const parsed = Number.parseInt(raw.trim(), 10);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : defaultBytes;
+}
+function getMaxQueueSize(defaultSize = 2048) {
+  const raw = readEnv("MORSE_MAX_QUEUE_SIZE");
+  if (!raw) return defaultSize;
+  const parsed = Number.parseInt(raw.trim(), 10);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : defaultSize;
+}
+function getMaxBatchSize(defaultSize = 512) {
+  const raw = readEnv("MORSE_MAX_BATCH_SIZE");
+  if (!raw) return defaultSize;
+  const parsed = Number.parseInt(raw.trim(), 10);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : defaultSize;
+}
+function isLegacyTransport() {
+  return truthy(readEnv("MORSE_LEGACY_TRANSPORT"));
+}
+exports.DEFAULT_ENDPOINT = void 0; var VALID_INTERNAL_SOURCES;
+var init_env = __esm({
+  "src/_internal/env.ts"() {
+    exports.DEFAULT_ENDPOINT = "https://api.morsehq.dev/api/v1/traces/batch";
+    VALID_INTERNAL_SOURCES = /* @__PURE__ */ new Set(["copilot", "investigator", "refagent", "ui-bot"]);
+  }
+});
+
+// src/_internal/otel-provider.browser.ts
+function noteBrowserRuntime() {
+  if (warned) return;
+  warned = true;
+  try {
+    console.info(
+      "[morse] Browser build active: OpenTelemetry span export and database capture are Node-only, so traces are sent via Morse's JSON transport instead. Everything else \u2014 run()/span()/track() and W3C traceparent propagation \u2014 behaves identically. Server-side code (Next.js route handlers, RSC, Node services) automatically gets the full OTel pipeline."
+    );
+  } catch {
+  }
+}
+function getEngine() {
+  return engine;
+}
+function withOtelSpanContext(traceIdHex, spanIdHex, fn) {
+  return fn();
+}
+var warned, OtelEngine, engine;
+var init_otel_provider_browser = __esm({
+  "src/_internal/otel-provider.browser.ts"() {
+    warned = false;
+    OtelEngine = class {
+      // Params are declared (not dropped) so this class stays signature-compatible
+      // with the real `OtelEngine` — the build swaps the modules, but anything
+      // type-checking against this one must see the same shape. `void x` marks the
+      // deliberate non-use for @typescript-eslint/no-unused-vars.
+      configure(opts) {
+        noteBrowserRuntime();
+      }
+      shutdown() {
+      }
+      resetForTesting() {
+        warned = false;
+      }
+      async flush() {
+      }
+      resolveSampled(traceIdHex) {
+        return true;
+      }
+      registerInstrumentations(instrumentations) {
+        return null;
+      }
+    };
+    engine = new OtelEngine();
+  }
+});
+
+// src/_internal/redaction.ts
+function buildRedactionConfig(options) {
+  const opts = options ?? {};
+  const enabled = opts.enabled !== false;
+  if (!enabled) {
+    return {
+      enabled: false,
+      enabledPatterns: /* @__PURE__ */ new Set(),
+      extraCompiled: []
+    };
+  }
+  const disabled = new Set(opts.disabledPatterns ?? []);
+  for (const key of disabled) {
+    if (MANDATORY_PATTERNS.has(key)) {
+      throw new Error(`redaction pattern '${key}' cannot be disabled (server-side mandatory)`);
+    }
+  }
+  const active = /* @__PURE__ */ new Set();
+  for (const key of PATTERN_ORDER) {
+    if (DEFAULT_OFF_PATTERNS.has(key)) continue;
+    if (disabled.has(key)) continue;
+    active.add(key);
+  }
+  const extraInput = opts.extraPatterns ?? [];
+  if (extraInput.length > EXTRA_PATTERN_CAP) {
+    throw new Error(
+      `too many redaction extra patterns: ${extraInput.length} (max ${EXTRA_PATTERN_CAP})`
+    );
+  }
+  const extraCompiled = [];
+  for (const raw of extraInput) {
+    if (typeof raw !== "string") {
+      throw new Error(`redaction extra pattern must be a string, got ${typeof raw}`);
+    }
+    if (raw.length > EXTRA_PATTERN_CHAR_CAP) {
+      throw new Error(`redaction extra pattern exceeds ${EXTRA_PATTERN_CHAR_CAP} chars`);
+    }
+    let compiled;
+    try {
+      compiled = new RegExp(raw, "g");
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      throw new Error(`redaction extra pattern failed to compile: ${JSON.stringify(raw)} \u2014 ${msg}`);
+    }
+    extraCompiled.push(compiled);
+  }
+  return {
+    enabled: true,
+    enabledPatterns: active,
+    extraCompiled
+  };
+}
+function luhnValid(s) {
+  let sum = 0;
+  let alt = false;
+  let digits = 0;
+  for (let i = s.length - 1; i >= 0; i--) {
+    const ch = s.charCodeAt(i);
+    if (ch < 48 || ch > 57) continue;
+    let n = ch - 48;
+    if (alt) {
+      n *= 2;
+      if (n > 9) n -= 9;
+    }
+    sum += n;
+    alt = !alt;
+    digits++;
+  }
+  if (digits < 13 || digits > 19) return false;
+  return sum % 10 === 0;
+}
+function resolveEnabled(config, override) {
+  return config.enabledPatterns;
+}
+function redactString(s, config, enabledOverride) {
+  if (!config.enabled && enabledOverride === void 0) {
+    return s;
+  }
+  if (s.length === 0) return s;
+  const enabled = resolveEnabled(config);
+  let out = s;
+  for (const key of PATTERN_ORDER) {
+    if (!enabled.has(key)) continue;
+    const re = PATTERNS[key];
+    if (re === void 0) continue;
+    re.lastIndex = 0;
+    const replacement = `[REDACTED:${SHORT_KEYS[key]}]`;
+    if (key === "credit_card") {
+      out = out.replace(re, (m) => luhnValid(m) ? replacement : m);
+    } else {
+      out = out.replace(re, replacement);
+    }
+  }
+  for (const re of config.extraCompiled) {
+    re.lastIndex = 0;
+    out = out.replace(re, "[REDACTED:custom]");
+  }
+  return out;
+}
+function redactValue(value, config, depth = 0) {
+  if (!config.enabled) return value;
+  if (value === null || value === void 0) return value;
+  if (typeof value === "string") return redactString(value, config);
+  if (typeof value === "number" || typeof value === "boolean") return value;
+  if (depth >= MAX_DEPTH) return value;
+  if (Array.isArray(value)) {
+    return value.map((item) => redactValue(item, config, depth + 1));
+  }
+  if (typeof value === "object") {
+    const proto = Object.getPrototypeOf(value);
+    if (proto === Object.prototype || proto === null) {
+      const out = {};
+      for (const [k, v] of Object.entries(value)) {
+        out[k] = redactValue(v, config, depth + 1);
+      }
+      return out;
+    }
+  }
+  return value;
+}
+var PATTERN_ORDER, MANDATORY_PATTERNS, DEFAULT_OFF_PATTERNS, SHORT_KEYS, PATTERNS, EXTRA_PATTERN_CAP, EXTRA_PATTERN_CHAR_CAP, MAX_DEPTH;
+var init_redaction = __esm({
+  "src/_internal/redaction.ts"() {
+    PATTERN_ORDER = [
+      "api_key_prefixed",
+      "jwt",
+      "credit_card",
+      "email",
+      "phone_us",
+      "phone_e164",
+      "ssn_us",
+      "ip_address"
+    ];
+    MANDATORY_PATTERNS = /* @__PURE__ */ new Set([
+      "api_key_prefixed",
+      "jwt",
+      "credit_card",
+      "ssn_us"
+    ]);
+    DEFAULT_OFF_PATTERNS = /* @__PURE__ */ new Set(["ip_address"]);
+    SHORT_KEYS = {
+      api_key_prefixed: "api_key",
+      jwt: "jwt",
+      credit_card: "credit_card",
+      email: "email",
+      phone_us: "phone",
+      phone_e164: "phone",
+      ssn_us: "ssn",
+      ip_address: "ip"
+    };
+    PATTERNS = {
+      api_key_prefixed: new RegExp(
+        "\\b(?:sk-[A-Za-z0-9_-]{20,}|sk_(?:live|test)_[A-Za-z0-9]{20,}|mhq_[A-Za-z0-9]{20,}|av_[A-Za-z0-9]{20,}|ghp_[A-Za-z0-9]{36}|gho_[A-Za-z0-9]{36}|ghu_[A-Za-z0-9]{36}|ghs_[A-Za-z0-9]{36}|ghr_[A-Za-z0-9]{36}|xox[bopsa]-[0-9A-Za-z\\-]{10,}|(?:AKIA|ASIA|AGPA|AIDA|AROA|AIPA|ANPA|ANVA|ASCA)[0-9A-Z]{16})\\b",
+        "g"
+      ),
+      jwt: new RegExp(
+        "\\beyJ[A-Za-z0-9_=-]{16,}\\.eyJ[A-Za-z0-9_=-]{16,}\\.[A-Za-z0-9_=-]{16,}\\b",
+        "g"
+      ),
+      credit_card: new RegExp("\\b(?:\\d[ -]?){12,18}\\d\\b", "g"),
+      email: new RegExp("\\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\\.[A-Za-z]{2,}\\b", "gi"),
+      // The leading `(?<!\d)` and trailing `(?!\d)` lookarounds prevent
+      // the phone matcher from carving a 10-digit substring out of a longer
+      // continuous digit run (e.g., a 16-digit credit-card-shaped number that
+      // failed Luhn). Without them, `1234567890123456` would emit a
+      // `[REDACTED:phone]` for digits 7-16 even though the whole run was
+      // never a real phone number. The canonical Python regex needs the same
+      // shim — see redaction.py.
+      phone_us: new RegExp(
+        "(?<!\\d)(?:\\+?1[ \\-.])?\\(?[2-9]\\d{2}\\)?[ \\-.]?\\d{3}[ \\-.]?\\d{4}(?!\\d)",
+        "g"
+      ),
+      phone_e164: new RegExp("(?<!\\d)\\+(?:[0-9][ \\-.]?){8,14}[0-9](?!\\d)", "g"),
+      ssn_us: new RegExp(
+        "\\b(?!000|666|9\\d{2})\\d{3}[ \\-.](?!00)\\d{2}[ \\-.](?!0000)\\d{4}\\b",
+        "g"
+      ),
+      ip_address: new RegExp(
+        "\\b(?:(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)(?:\\.(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)){3}|(?:[A-F0-9]{1,4}:){2,7}[A-F0-9]{1,4})\\b",
+        "gi"
+      )
+    };
+    EXTRA_PATTERN_CAP = 10;
+    EXTRA_PATTERN_CHAR_CAP = 256;
+    MAX_DEPTH = 10;
+  }
+});
+
+// src/_internal/spans.ts
+function generateTraceId() {
+  return randomHex(32);
+}
+function generateSpanId() {
+  return randomHex(32);
+}
+function randomHex(chars) {
+  const bytes = new Uint8Array(Math.ceil(chars / 2));
+  const cryptoObj = globalThis.crypto;
+  if (cryptoObj?.getRandomValues) {
+    cryptoObj.getRandomValues(bytes);
+  } else {
+    for (let i = 0; i < bytes.length; i++) {
+      bytes[i] = Math.floor(Math.random() * 256);
+    }
+  }
+  let hex = "";
+  for (const b of bytes) {
+    hex += b.toString(16).padStart(2, "0");
+  }
+  return hex.slice(0, chars);
+}
+function nowIso() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function spanToWire(span) {
+  const out = {};
+  for (const [k, v] of Object.entries(span)) {
+    if (v !== void 0 && v !== null) {
+      out[k] = v;
+    }
+  }
+  return out;
+}
+function buildTraceEntry(fields, spans) {
+  return {
+    trace: fields,
+    spans: spans.map(spanToWire)
+  };
+}
+exports.SpanType = void 0;
+var init_spans = __esm({
+  "src/_internal/spans.ts"() {
+    exports.SpanType = {
+      AGENT: "agent",
+      LLM: "llm",
+      TOOL: "tool",
+      HTTP: "http",
+      DB: "db",
+      CUSTOM: "custom",
+      MEMORY: "memory",
+      // MHQ-482: matches Python's `SpanType.RETRIEVER` (apps/sdk/python/src/morse_ai/spans.py).
+      // @beta — retriever span type is subject to change before SDK v1.0 (see
+      // the plain-LangChain adapter's on_retriever_* callbacks in src/langchain/).
+      RETRIEVER: "retriever"
+    };
+  }
+});
+
+// src/_internal/tracing.ts
+function tryLoadAls() {
+  if (alsLoaded) return als;
+  alsLoaded = true;
+  if (typeof process === "undefined" || !process.versions?.node) {
+    als = null;
+    return als;
+  }
+  try {
+    const dynamicRequire = Function("m", "return require(m)");
+    const mod = dynamicRequire("node:async_hooks");
+    if (mod?.AsyncLocalStorage) {
+      als = new mod.AsyncLocalStorage();
+      return als;
+    }
+  } catch {
+  }
+  als = null;
+  return als;
+}
+function getActiveTraceState() {
+  const store = tryLoadAls();
+  if (store) {
+    return store.getStore() ?? null;
+  }
+  return browserState;
+}
+function setActiveTraceState(state) {
+  const previous = browserState;
+  browserState = state;
+  return () => {
+    browserState = previous;
+  };
+}
+function setTransport(t) {
+  transport = t;
+}
+function getTransport() {
+  return transport;
+}
+function setRedactionConfig(config) {
+  redactionConfig = config;
+}
+function getRedactionConfig() {
+  return redactionConfig;
+}
+function setSource(value) {
+  _source = value && value.length > 0 ? value : null;
+}
+function getLastTrace() {
+  return lastTrace;
+}
+function nowMonotonic() {
+  if (typeof performance !== "undefined" && typeof performance.now === "function") {
+    return performance.now();
+  }
+  return Date.now();
+}
+function elapsedMs(startMonotonic) {
+  return Math.max(0, Math.round(nowMonotonic() - startMonotonic));
+}
+function finalizeSpan(span, startMono, status = "completed", errorMessage) {
+  span.ended_at = nowIso();
+  span.duration_ms = elapsedMs(startMono);
+  span.status = status;
+  if (errorMessage !== void 0) {
+    span.error_message = errorMessage;
+  }
+}
+function redactSpanDict(raw, config) {
+  if (!config.enabled) return raw;
+  const out = {};
+  for (const [k, v] of Object.entries(raw)) {
+    if (SPAN_REDACTABLE_FIELDS.has(k)) {
+      out[k] = redactValue(v, config);
+    } else {
+      out[k] = v;
+    }
+  }
+  return out;
+}
+function redactTraceDict(raw, config) {
+  if (!config.enabled) return raw;
+  const out = {};
+  for (const [k, v] of Object.entries(raw)) {
+    if (TRACE_REDACTABLE_FIELDS.has(k)) {
+      out[k] = redactValue(v, config);
+    } else {
+      out[k] = v;
+    }
+  }
+  return out;
+}
+function buildTraceDict(state, rootSpan) {
+  const trace = {
+    trace_id: state.traceId,
+    // Wire-format field is `agent` (matches backend TracePayloadIn schema +
+    // sibling Python SDK). Was `agent_name` historically — the mismatch
+    // caused dev ingest to reject every TS-emitted trace with a 422
+    // until Phase 13 Option A dogfood surfaced it.
+    agent: state.agentName,
+    status: rootSpan.status,
+    started_at: rootSpan.started_at
+  };
+  if (rootSpan.ended_at) trace.ended_at = rootSpan.ended_at;
+  if (rootSpan.duration_ms !== void 0) trace.duration_ms = rootSpan.duration_ms;
+  if (rootSpan.error_message) trace.error_message = rootSpan.error_message;
+  if (state.success !== void 0) trace.success = state.success;
+  if (state.outcome !== void 0) trace.outcome = state.outcome;
+  if (state.threadId !== void 0) trace.thread_id = state.threadId;
+  if (state.userId !== void 0) trace.user_id = state.userId;
+  if (state.userMetadata && Object.keys(state.userMetadata).length > 0) {
+    trace.user_metadata = state.userMetadata;
+  }
+  const allSpans = [rootSpan, ...state.completedSpans];
+  const spans = allSpans.map((s) => {
+    const out2 = {};
+    for (const [k, v] of Object.entries(s)) {
+      if (v !== void 0 && v !== null) {
+        out2[k] = v;
+      }
+    }
+    return out2;
+  });
+  const config = redactionConfig;
+  const out = {
+    trace: redactTraceDict(trace, config),
+    spans: spans.map((s) => redactSpanDict(s, config))
+  };
+  const effectiveSource = state.sourceOverride || _source;
+  if (effectiveSource) {
+    out.resource = { "morse_ai.source": effectiveSource };
+  }
+  return out;
+}
+function sendTrace(entry) {
+  lastTrace = entry;
+  if (isLegacyTransport() || true) {
+    if (transport !== null) {
+      try {
+        transport.track({ traces: [entry] });
+      } catch {
+      }
+    }
+    return;
+  }
+}
+function withDbCaptureContext(traceId, spanIdHex, fn) {
+  try {
+    return withOtelSpanContext(traceId, spanIdHex.slice(0, 16), fn);
+  } catch {
+    return fn();
+  }
+}
+function buildRunHandle(state) {
+  return {
+    setOutcome(success, outcome) {
+      state.success = success;
+      if (outcome !== void 0) state.outcome = outcome;
+    },
+    setError(message) {
+      state.errorMessage = message;
+      state.success = false;
+    },
+    _state: state
+  };
+}
+function startTrace(opts) {
+  let traceId;
+  if (opts.incomingTraceparent) {
+    const { extractTraceparent: extractTraceparent2 } = (init_propagation(), __toCommonJS(propagation_exports));
+    const ctx = extractTraceparent2(opts.incomingTraceparent);
+    if (ctx) {
+      traceId = ctx.traceId;
+    }
+  }
+  if (!traceId) traceId = generateTraceId();
+  const state = {
+    traceId,
+    agentName: opts.agentName,
+    spanStack: [],
+    completedSpans: []
+  };
+  if (opts.threadId !== void 0) state.threadId = opts.threadId;
+  if (opts.userId !== void 0) state.userId = opts.userId;
+  if (opts.userMetadata) {
+    state.userMetadata = Object.fromEntries(
+      Object.entries(opts.userMetadata).map(([k, v]) => [k, String(v)])
+    );
+  }
+  if (isValidInternalSource(opts.source)) {
+    state.sourceOverride = opts.source;
+  }
+  const rootSpan = {
+    trace_id: traceId,
+    span_id: generateSpanId(),
+    type: "agent",
+    name: opts.agentName,
+    started_at: nowIso(),
+    status: "completed"
+  };
+  state.spanStack.push(rootSpan);
+  return { state, rootSpan, startMono: nowMonotonic() };
+}
+function endTrace(state, rootSpan, startMono, threwError) {
+  state.spanStack.pop();
+  if (threwError !== void 0) {
+    const msg = state.errorMessage ?? errToString(threwError);
+    finalizeSpan(rootSpan, startMono, "failed", msg);
+    if (state.success === void 0) state.success = false;
+  } else if (state.errorMessage !== void 0) {
+    finalizeSpan(rootSpan, startMono, "failed", state.errorMessage);
+  } else {
+    finalizeSpan(rootSpan, startMono);
+    if (state.success === void 0) state.success = true;
+  }
+  const dict = buildTraceDict(state, rootSpan);
+  sendTrace(dict);
+}
+function errToString(e) {
+  if (e instanceof Error) return e.message;
+  return String(e);
+}
+function runSync(opts, fn) {
+  const { state, rootSpan, startMono } = startTrace(opts);
+  const handle = buildRunHandle(state);
+  const store = tryLoadAls();
+  const runFn = () => withDbCaptureContext(state.traceId, rootSpan.span_id, () => fn(handle));
+  if (store) {
+    try {
+      const result = store.run(state, runFn);
+      endTrace(state, rootSpan, startMono, void 0);
+      return result;
+    } catch (err) {
+      endTrace(state, rootSpan, startMono, err);
+      throw err;
+    }
+  } else {
+    const reset = setActiveTraceState(state);
+    try {
+      const result = runFn();
+      endTrace(state, rootSpan, startMono, void 0);
+      return result;
+    } catch (err) {
+      endTrace(state, rootSpan, startMono, err);
+      throw err;
+    } finally {
+      reset();
+    }
+  }
+}
+async function runAsync(opts, fn) {
+  const { state, rootSpan, startMono } = startTrace(opts);
+  const handle = buildRunHandle(state);
+  const store = tryLoadAls();
+  const runFn = () => withDbCaptureContext(state.traceId, rootSpan.span_id, () => fn(handle));
+  if (store) {
+    try {
+      const result = await store.run(state, runFn);
+      endTrace(state, rootSpan, startMono, void 0);
+      return result;
+    } catch (err) {
+      endTrace(state, rootSpan, startMono, err);
+      throw err;
+    }
+  } else {
+    const reset = setActiveTraceState(state);
+    try {
+      const result = await runFn();
+      endTrace(state, rootSpan, startMono, void 0);
+      return result;
+    } catch (err) {
+      endTrace(state, rootSpan, startMono, err);
+      throw err;
+    } finally {
+      reset();
+    }
+  }
+}
+function setContext(dims) {
+  const state = getActiveTraceState();
+  if (state === null) return;
+  if (state.userMetadata === void 0) state.userMetadata = {};
+  for (const [k, v] of Object.entries(dims)) {
+    state.userMetadata[k] = String(v);
+  }
+}
+function startSpan(opts) {
+  const state = getActiveTraceState();
+  if (state === null) return null;
+  const parent = state.spanStack[state.spanStack.length - 1];
+  const span = {
+    trace_id: state.traceId,
+    span_id: generateSpanId(),
+    type: opts.type ?? "custom",
+    name: opts.name,
+    parent_span_id: parent?.span_id,
+    started_at: nowIso(),
+    status: "completed",
+    metadata: opts.metadata
+  };
+  const startMono = nowMonotonic();
+  state.spanStack.push(span);
+  return {
+    span,
+    end(error) {
+      if (state.spanStack[state.spanStack.length - 1] === span) {
+        state.spanStack.pop();
+      }
+      if (error !== void 0) {
+        finalizeSpan(span, startMono, "failed", errToString(error));
+      } else {
+        finalizeSpan(span, startMono);
+      }
+      state.completedSpans.push(span);
+    }
+  };
+}
+function spanSync(opts, fn) {
+  const handle = startSpan(opts);
+  try {
+    const result = handle ? withDbCaptureContext(handle.span.trace_id, handle.span.span_id, () => fn(handle)) : fn(handle);
+    handle?.end();
+    return result;
+  } catch (err) {
+    handle?.end(err);
+    throw err;
+  }
+}
+async function spanAsync(opts, fn) {
+  const handle = startSpan(opts);
+  try {
+    const result = handle ? await withDbCaptureContext(handle.span.trace_id, handle.span.span_id, () => fn(handle)) : await fn(handle);
+    handle?.end();
+    return result;
+  } catch (err) {
+    handle?.end(err);
+    throw err;
+  }
+}
+function _resetForTesting() {
+  browserState = null;
+  lastTrace = null;
+  redactionConfig = buildRedactionConfig();
+}
+var als, alsLoaded, browserState, transport, redactionConfig, _source, lastTrace, SPAN_REDACTABLE_FIELDS, TRACE_REDACTABLE_FIELDS;
+var init_tracing = __esm({
+  "src/_internal/tracing.ts"() {
+    init_env();
+    init_otel_provider_browser();
+    init_redaction();
+    init_spans();
+    als = null;
+    alsLoaded = false;
+    browserState = null;
+    transport = null;
+    redactionConfig = buildRedactionConfig();
+    _source = null;
+    lastTrace = null;
+    SPAN_REDACTABLE_FIELDS = /* @__PURE__ */ new Set([
+      "name",
+      "input_data",
+      "output_data",
+      "error_message",
+      "metadata"
+    ]);
+    TRACE_REDACTABLE_FIELDS = /* @__PURE__ */ new Set(["agent", "outcome", "error_message"]);
+  }
+});
+
+// src/propagation.ts
+var propagation_exports = {};
+__export(propagation_exports, {
+  W3C_FLAGS_SAMPLED: () => W3C_FLAGS_SAMPLED,
+  W3C_TRACEPARENT_HEADER: () => exports.W3C_TRACEPARENT_HEADER,
+  W3C_VERSION: () => W3C_VERSION,
+  extractFromRequest: () => extractFromRequest,
+  extractTraceparent: () => extractTraceparent,
+  formatTraceparent: () => formatTraceparent,
+  injectIntoRequestInit: () => injectIntoRequestInit,
+  injectTraceparent: () => injectTraceparent
+});
+function formatTraceparent(traceId, spanId) {
+  const tid = traceId.slice(0, TRACE_ID_LEN).padStart(TRACE_ID_LEN, "0").toLowerCase();
+  const sid = spanId.slice(0, SPAN_ID_LEN).padStart(SPAN_ID_LEN, "0").toLowerCase();
+  return `${W3C_VERSION}-${tid}-${sid}-${W3C_FLAGS_SAMPLED}`;
+}
+function injectTraceparent(headers) {
+  const state = getActiveTraceState();
+  if (state === null) return headers;
+  const traceId = state.traceId;
+  const span = state.spanStack.length > 0 ? state.spanStack[state.spanStack.length - 1] : state.completedSpans[state.completedSpans.length - 1];
+  const rawSpanId = span?.span_id ?? traceId;
+  const spanId = rawSpanId.slice(0, SPAN_ID_LEN);
+  const value = formatTraceparent(traceId, spanId);
+  setHeader(headers, exports.W3C_TRACEPARENT_HEADER, value);
+  return headers;
+}
+function extractTraceparent(headers) {
+  if (headers === null || headers === void 0) return null;
+  const raw = typeof headers === "string" ? headers : getHeader(headers, exports.W3C_TRACEPARENT_HEADER);
+  if (!raw) return null;
+  const parts = raw.split("-");
+  if (parts.length !== 4) return null;
+  const [version, traceId, spanId] = parts;
+  if (version !== W3C_VERSION) return null;
+  if (traceId.length !== TRACE_ID_LEN) return null;
+  if (spanId.length !== SPAN_ID_LEN) return null;
+  if (!/^[0-9a-f]+$/.test(traceId)) return null;
+  if (!/^[0-9a-f]+$/.test(spanId)) return null;
+  if (/^0+$/.test(traceId)) return null;
+  if (/^0+$/.test(spanId)) return null;
+  return { traceId, parentSpanId: spanId };
+}
+function extractFromRequest(req) {
+  return extractTraceparent(req.headers);
+}
+function injectIntoRequestInit(init) {
+  const merged = new Headers(init?.headers ?? {});
+  injectTraceparent(merged);
+  return { ...init ?? {}, headers: merged };
+}
+function getHeader(headers, name) {
+  if (headers instanceof Headers) {
+    return headers.get(name);
+  }
+  const maybeGet = headers.get;
+  if (typeof maybeGet === "function") {
+    const v = maybeGet.call(headers, name);
+    if (typeof v === "string") return v;
+    if (v === null || v === void 0) return null;
+  }
+  const lower = name.toLowerCase();
+  for (const [k, v] of Object.entries(headers)) {
+    if (k.toLowerCase() === lower) {
+      if (typeof v === "string") return v;
+      if (Array.isArray(v) && v.length > 0 && typeof v[0] === "string") return v[0];
+      return null;
+    }
+  }
+  return null;
+}
+function setHeader(headers, name, value) {
+  if (headers instanceof Headers) {
+    headers.set(name, value);
+    return;
+  }
+  const maybeSet = headers.set;
+  if (typeof maybeSet === "function") {
+    maybeSet.call(headers, name, value);
+    return;
+  }
+  headers[name] = value;
+}
+exports.W3C_TRACEPARENT_HEADER = void 0; var W3C_VERSION, W3C_FLAGS_SAMPLED, TRACE_ID_LEN, SPAN_ID_LEN;
+var init_propagation = __esm({
+  "src/propagation.ts"() {
+    init_tracing();
+    exports.W3C_TRACEPARENT_HEADER = "traceparent";
+    W3C_VERSION = "00";
+    W3C_FLAGS_SAMPLED = "01";
+    TRACE_ID_LEN = 32;
+    SPAN_ID_LEN = 16;
+  }
+});
+
+exports._resetForTesting = _resetForTesting;
+exports.buildRedactionConfig = buildRedactionConfig;
+exports.buildTraceEntry = buildTraceEntry;
+exports.extractTraceparent = extractTraceparent;
+exports.formatTraceparent = formatTraceparent;
+exports.generateSpanId = generateSpanId;
+exports.generateTraceId = generateTraceId;
+exports.getActiveTraceState = getActiveTraceState;
+exports.getApiKey = getApiKey;
+exports.getEndpoint = getEndpoint;
+exports.getEngine = getEngine;
+exports.getFlushIntervalSeconds = getFlushIntervalSeconds;
+exports.getInternalSource = getInternalSource;
+exports.getLastTrace = getLastTrace;
+exports.getMaxBatchSize = getMaxBatchSize;
+exports.getMaxFieldBytes = getMaxFieldBytes;
+exports.getMaxQueueSize = getMaxQueueSize;
+exports.getRedactionConfig = getRedactionConfig;
+exports.getSampleRate = getSampleRate;
+exports.getTransport = getTransport;
+exports.init_env = init_env;
+exports.init_otel_provider_browser = init_otel_provider_browser;
+exports.init_propagation = init_propagation;
+exports.init_redaction = init_redaction;
+exports.init_spans = init_spans;
+exports.init_tracing = init_tracing;
+exports.injectIntoRequestInit = injectIntoRequestInit;
+exports.injectTraceparent = injectTraceparent;
+exports.isDebug = isDebug;
+exports.isDisabled = isDisabled;
+exports.isTelemetryDisabled = isTelemetryDisabled;
+exports.isValidInternalSource = isValidInternalSource;
+exports.nowIso = nowIso;
+exports.redactValue = redactValue;
+exports.runAsync = runAsync;
+exports.runSync = runSync;
+exports.sendTrace = sendTrace;
+exports.setContext = setContext;
+exports.setRedactionConfig = setRedactionConfig;
+exports.setSource = setSource;
+exports.setTransport = setTransport;
+exports.spanAsync = spanAsync;
+exports.spanSync = spanSync;
+exports.startSpan = startSpan;
+//# sourceMappingURL=chunk-O4HG3OSK.cjs.map
+//# sourceMappingURL=chunk-O4HG3OSK.cjs.map