@morsehq-dev/sdk 0.4.0-rc.1

package/dist/chunk-FJUNILZT.cjs

@@ -0,0 +1,1324 @@
+'use strict';
+
+var crypto = require('crypto');
+var api = require('@opentelemetry/api');
+var core = require('@opentelemetry/core');
+var exporterTraceOtlpProto = require('@opentelemetry/exporter-trace-otlp-proto');
+var otlpExporterBase = require('@opentelemetry/otlp-exporter-base');
+var sdkTraceBase = require('@opentelemetry/sdk-trace-base');
+var sdkTraceNode = require('@opentelemetry/sdk-trace-node');
+var instrumentation = require('@opentelemetry/instrumentation');
+var contextAsyncHooks = require('@opentelemetry/context-async-hooks');
+
+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 isAutoDetectDisabled() {
+  return truthy(readEnv("MORSE_DISABLE_AUTO_DETECT"));
+}
+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"));
+}
+function isDbCaptureEnabled() {
+  return truthy(readEnv("MORSE_CAPTURE_DB")) || truthy(readEnv("MORSE_CAPTURE_INFRA"));
+}
+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/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/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;
+  }
+});
+function ensureGlobalContextManager() {
+  if (contextManagerRegistered) return;
+  contextManagerRegistered = true;
+  try {
+    api.context.setGlobalContextManager(new contextAsyncHooks.AsyncHooksContextManager().enable());
+  } catch {
+  }
+}
+function withOtelSpanContext(traceIdHex, spanIdHex, fn) {
+  const eng = getEngine();
+  if (eng.provider === null) return fn();
+  ensureGlobalContextManager();
+  const sampled = eng.resolveSampled(traceIdHex);
+  const spanCtx = {
+    traceId: traceIdHex,
+    spanId: spanIdHex,
+    isRemote: true,
+    traceFlags: sampled ? api.TraceFlags.SAMPLED : api.TraceFlags.NONE
+  };
+  const withCtx = api.trace.setSpanContext(api.context.active(), spanCtx);
+  return api.context.with(withCtx, fn);
+}
+function capBytes(value, maxBytes) {
+  if (maxBytes <= 0) return value;
+  const encoded = Buffer.from(value, "utf-8");
+  if (encoded.length <= maxBytes) return value;
+  const markerBytes = Buffer.byteLength(TRUNCATION_MARKER, "utf-8");
+  const budget = Math.max(maxBytes - markerBytes, 0);
+  let truncated = encoded.subarray(0, budget);
+  const decoder = new TextDecoder("utf-8", { fatal: true });
+  while (truncated.length > 0) {
+    try {
+      return decoder.decode(truncated) + TRUNCATION_MARKER;
+    } catch {
+      truncated = truncated.subarray(0, truncated.length - 1);
+    }
+  }
+  return TRUNCATION_MARKER;
+}
+function jsonCapped(value, maxBytes) {
+  if (value === null || value === void 0) return null;
+  if (typeof value === "string") {
+    return JSON.stringify(capBytes(value, maxBytes));
+  }
+  let encoded;
+  try {
+    encoded = JSON.stringify(value, (_k, v) => typeof v === "bigint" ? String(v) : v) ?? "null";
+  } catch {
+    encoded = JSON.stringify(String(value));
+  }
+  return capBytes(encoded, maxBytes);
+}
+function decorrelateTraceIdForSampling(traceIdHex) {
+  const traceIdBytes = Buffer.from(traceIdHex.padStart(32, "0").slice(0, 32), "hex");
+  return crypto.createHash("sha256").update(traceIdBytes).digest();
+}
+function ratioSample(traceIdHex, rate) {
+  if (rate <= 0) return false;
+  if (rate >= 1) return true;
+  const digest = decorrelateTraceIdForSampling(traceIdHex);
+  const low64 = digest.subarray(8, 16).readBigUInt64BE();
+  const threshold = BigInt(Math.round(rate * Number(MAX_U64)));
+  return low64 < threshold;
+}
+function redactAttrValue(value, config) {
+  if (typeof value === "string") return redactString(value, config);
+  if (Array.isArray(value)) {
+    return value.map((v) => typeof v === "string" ? redactString(v, config) : v);
+  }
+  return value;
+}
+function getEngine() {
+  if (engine === null) engine = new OtelEngine();
+  return engine;
+}
+function spanDictToOtelAttributes(spanDict, traceDict, resourceDict, opts) {
+  const attrs = {};
+  const spanType = spanDict.type;
+  if (typeof spanType === "string" && spanType) attrs["av.span_type"] = spanType;
+  const model = spanDict.model;
+  if (model !== void 0 && model !== null) attrs["gen_ai.request.model"] = String(model);
+  const tokenFields = [
+    ["input_tokens", "gen_ai.usage.input_tokens"],
+    ["output_tokens", "gen_ai.usage.output_tokens"],
+    ["cached_input_tokens", "gen_ai.usage.cache_read_input_tokens"],
+    ["cache_write_tokens", "gen_ai.usage.cache_creation_input_tokens"],
+    ["reasoning_tokens", "gen_ai.usage.reasoning_tokens"]
+  ];
+  for (const [src, otelKey] of tokenFields) {
+    const v = spanDict[src];
+    if (v !== void 0 && v !== null) {
+      const n = Number(v);
+      if (Number.isFinite(n)) attrs[otelKey] = Math.trunc(n);
+    }
+  }
+  const costUsd = spanDict.cost_usd;
+  if (costUsd !== void 0 && costUsd !== null) {
+    attrs["av.cost_usd"] = String(costUsd);
+  }
+  for (const [src, otelKey] of [
+    ["input_data", "av.input_data"],
+    ["output_data", "av.output_data"],
+    ["context_segments", "av.context_segments"]
+  ]) {
+    const v = spanDict[src];
+    if (v !== void 0 && v !== null) {
+      const encoded = jsonCapped(v, opts.maxFieldBytes);
+      if (encoded !== null) attrs[otelKey] = encoded;
+    }
+  }
+  const metadata = spanDict.metadata;
+  if (metadata && typeof metadata === "object") {
+    for (const [key, value] of Object.entries(metadata)) {
+      const encoded = jsonCapped(value, opts.maxFieldBytes);
+      if (encoded !== null) attrs[`av.metadata.${key}`] = encoded;
+    }
+  }
+  const errorMessage = spanDict.error_message;
+  if (opts.isRoot) {
+    const threadId = traceDict.thread_id;
+    if (threadId !== void 0 && threadId !== null) attrs["av.thread_id"] = String(threadId);
+    const userId = traceDict.user_id;
+    if (userId !== void 0 && userId !== null) attrs["av.user_id"] = String(userId);
+    const userMetadata = traceDict.user_metadata;
+    if (userMetadata && typeof userMetadata === "object") {
+      const entries = Object.entries(userMetadata);
+      if (entries.length > 0) {
+        attrs["av.user_metadata"] = JSON.stringify(
+          Object.fromEntries(entries.map(([k, v]) => [k, String(v)]))
+        );
+      }
+    }
+    const success = traceDict.success;
+    if (success !== void 0 && success !== null) attrs["av.outcome.success"] = Boolean(success);
+    const outcome = traceDict.outcome;
+    if (outcome !== void 0 && outcome !== null) attrs["av.outcome.label"] = String(outcome);
+    const framework = resourceDict["morse_ai.framework"];
+    if (typeof framework === "string" && framework) attrs["av.framework"] = framework;
+    const source = resourceDict["morse_ai.source"];
+    if (typeof source === "string" && source) attrs["av.source"] = source;
+  }
+  if (errorMessage && spanDict.status === "failed") {
+    attrs["av.error_message"] = String(errorMessage);
+  }
+  return attrs;
+}
+function isoToTimeInputMillis(value) {
+  if (typeof value !== "string" || !value) return void 0;
+  const ms = Date.parse(value);
+  return Number.isNaN(ms) ? void 0 : ms;
+}
+function emitTraceEntry(entry) {
+  const eng = getEngine();
+  const tracer = eng.tracer;
+  if (tracer === null) return;
+  const traceDict = entry.trace ?? {};
+  const spanDicts = entry.spans ?? [];
+  const resourceDict = entry.resource ?? {};
+  if (spanDicts.length === 0) return;
+  const traceIdHexRaw = traceDict.trace_id;
+  if (typeof traceIdHexRaw !== "string" || traceIdHexRaw.length === 0) return;
+  const traceIdHex = traceIdHexRaw.toLowerCase().padStart(32, "0").slice(0, 32);
+  if (!/^[0-9a-f]{32}$/.test(traceIdHex) || /^0+$/.test(traceIdHex)) return;
+  const sampled = eng.resolveSampled(traceIdHex);
+  const syntheticParentContext = {
+    traceId: traceIdHex,
+    // Placeholder — only traceId/traceFlags matter here; every real span
+    // in the trace gets its own OTel-minted spanId via startSpan().
+    spanId: "0000000000000001",
+    isRemote: true,
+    traceFlags: sampled ? api.TraceFlags.SAMPLED : api.TraceFlags.NONE
+  };
+  const rootParentCtx = api.trace.setSpanContext(api.ROOT_CONTEXT, syntheticParentContext);
+  let rootSpanId;
+  for (const s of spanDicts) {
+    if (!s.parent_span_id) {
+      rootSpanId = s.span_id;
+      break;
+    }
+  }
+  if (rootSpanId === void 0 && spanDicts.length > 0) {
+    rootSpanId = spanDicts[0].span_id;
+  }
+  const ordered = [...spanDicts].sort((a, b) => {
+    const aIsRoot = a.span_id === rootSpanId ? 0 : 1;
+    const bIsRoot = b.span_id === rootSpanId ? 0 : 1;
+    return aIsRoot - bIsRoot;
+  });
+  const spanCtxById = /* @__PURE__ */ new Map();
+  const maxFieldBytes = eng.maxFieldBytes;
+  for (const spanDict of ordered) {
+    const spanIdHex = typeof spanDict.span_id === "string" ? spanDict.span_id : void 0;
+    const parentIdHex = typeof spanDict.parent_span_id === "string" ? spanDict.parent_span_id : void 0;
+    let parentCtx = rootParentCtx;
+    if (parentIdHex && spanCtxById.has(parentIdHex)) {
+      parentCtx = api.trace.setSpanContext(api.ROOT_CONTEXT, spanCtxById.get(parentIdHex));
+    }
+    const attributes = spanDictToOtelAttributes(spanDict, traceDict, resourceDict, {
+      isRoot: spanDict.span_id === rootSpanId,
+      maxFieldBytes
+    });
+    const startTime = isoToTimeInputMillis(spanDict.started_at);
+    const endTime = isoToTimeInputMillis(spanDict.ended_at) ?? startTime;
+    try {
+      const otelSpan = tracer.startSpan(
+        typeof spanDict.name === "string" && spanDict.name ? spanDict.name : "span",
+        {
+          kind: api.SpanKind.INTERNAL,
+          attributes,
+          startTime
+        },
+        parentCtx
+      );
+      if (spanIdHex) {
+        spanCtxById.set(spanIdHex, otelSpan.spanContext());
+      }
+      if (spanDict.status === "failed") {
+        otelSpan.setStatus({
+          code: api.SpanStatusCode.ERROR,
+          message: String(spanDict.error_message ?? "")
+        });
+      }
+      otelSpan.end(endTime);
+    } catch {
+    }
+  }
+}
+var INSTRUMENTATION_NAME, DEFAULT_MAX_FIELD_BYTES, TRUNCATION_MARKER, contextManagerRegistered, MAX_U64, RedactingSpanExporter, RecordingSpanExporter, ResultCapturingExporter, OtelEngine, engine;
+var init_otel_provider = __esm({
+  "src/_internal/otel-provider.ts"() {
+    init_redaction();
+    INSTRUMENTATION_NAME = "morse-typescript";
+    DEFAULT_MAX_FIELD_BYTES = 65536;
+    TRUNCATION_MARKER = "\u2026[truncated]";
+    contextManagerRegistered = false;
+    MAX_U64 = (1n << 64n) - 1n;
+    RedactingSpanExporter = class {
+      constructor(inner, redactionConfig2) {
+        this.inner = inner;
+        this.redactionConfig = redactionConfig2;
+      }
+      inner;
+      redactionConfig;
+      export(spans, resultCallback) {
+        const config = this.redactionConfig;
+        if (config && (config.enabled || config.extraCompiled.length > 0)) {
+          for (const span of spans) {
+            const attrs = span.attributes;
+            if (!attrs) continue;
+            for (const key of Object.keys(attrs)) {
+              attrs[key] = redactAttrValue(attrs[key], config);
+            }
+          }
+        }
+        this.inner.export(spans, resultCallback);
+      }
+      shutdown() {
+        return this.inner.shutdown();
+      }
+      forceFlush() {
+        return this.inner.forceFlush ? this.inner.forceFlush() : Promise.resolve();
+      }
+    };
+    RecordingSpanExporter = class {
+      spans = [];
+      export(spans, resultCallback) {
+        this.spans.push(...spans);
+        resultCallback({ code: core.ExportResultCode.SUCCESS });
+      }
+      shutdown() {
+        return Promise.resolve();
+      }
+      forceFlush() {
+        return Promise.resolve();
+      }
+      clear() {
+        this.spans = [];
+      }
+    };
+    ResultCapturingExporter = class {
+      constructor(inner, sink) {
+        this.inner = inner;
+        this.sink = sink;
+      }
+      inner;
+      sink;
+      export(spans, resultCallback) {
+        this.inner.export(spans, (result) => {
+          this.sink(result);
+          resultCallback(result);
+        });
+      }
+      shutdown() {
+        return this.inner.shutdown();
+      }
+      forceFlush() {
+        return this.inner.forceFlush ? this.inner.forceFlush() : Promise.resolve();
+      }
+    };
+    OtelEngine = class {
+      provider = null;
+      tracer = null;
+      sampleRate = 1;
+      recorder = null;
+      maxFieldBytes = DEFAULT_MAX_FIELD_BYTES;
+      exitHookRegistered = false;
+      /**
+       * (Re)build the provider. Mirrors Python's `_Client.__init__` semantics:
+       * calling this again (e.g. a second `init()`) tears down the previous
+       * provider first (fire-and-forget — Node has no synchronous blocking
+       * shutdown equivalent to Python's `atexit`).
+       */
+      configure(opts) {
+        if (this.provider !== null) {
+          const prior = this.provider;
+          void prior.shutdown().catch(() => {
+          });
+        }
+        this.maxFieldBytes = opts.maxFieldBytes;
+        this.sampleRate = Math.min(1, Math.max(0, opts.sampleRate));
+        const sampler = new sdkTraceBase.ParentBasedSampler({
+          root: new sdkTraceBase.TraceIdRatioBasedSampler(this.sampleRate)
+        });
+        const otlpExporter = new exporterTraceOtlpProto.OTLPTraceExporter({
+          url: opts.endpoint,
+          headers: { Authorization: `Bearer ${opts.apiKey}` },
+          compression: otlpExporterBase.CompressionAlgorithm.GZIP,
+          timeoutMillis: opts.timeoutMillis
+        });
+        let exporter = new RedactingSpanExporter(otlpExporter, opts.redactionConfig);
+        if (opts.resultSink) {
+          exporter = new ResultCapturingExporter(exporter, opts.resultSink);
+        }
+        this.recorder = opts.captureForTests ? new RecordingSpanExporter() : null;
+        const spanProcessors = [
+          new sdkTraceBase.BatchSpanProcessor(exporter, {
+            maxQueueSize: opts.maxQueueSize,
+            scheduledDelayMillis: opts.scheduleDelayMillis,
+            maxExportBatchSize: opts.maxExportBatchSize
+          })
+        ];
+        if (this.recorder !== null) {
+          spanProcessors.push(new sdkTraceBase.BatchSpanProcessor(this.recorder));
+        }
+        this.provider = new sdkTraceNode.NodeTracerProvider({ sampler, spanProcessors });
+        this.tracer = this.provider.getTracer(INSTRUMENTATION_NAME);
+        if (!this.exitHookRegistered) {
+          process.once("beforeExit", () => {
+            this.shutdown();
+          });
+          this.exitHookRegistered = true;
+        }
+      }
+      shutdown() {
+        if (this.provider !== null) {
+          const provider = this.provider;
+          void provider.shutdown().catch(() => {
+          });
+          this.provider = null;
+          this.tracer = null;
+        }
+      }
+      /**
+       * Test-only fast reset: drop the provider reference WITHOUT blocking on
+       * `shutdown()`. Mirrors Python's `reset_for_testing` — the OTLP
+       * exporter's retry-with-backoff behavior against an unreachable test
+       * endpoint would otherwise make every test file's teardown slow. The
+       * queued background work is not awaited; it either finishes or is
+       * abandoned with the process, same trade-off as Python's daemon worker
+       * thread.
+       */
+      resetForTesting() {
+        this.provider = null;
+        this.tracer = null;
+        this.recorder = null;
+      }
+      /** Block until in-flight exports finish (or the timeout elapses). */
+      async flush() {
+        const provider = this.provider;
+        if (provider !== null) {
+          try {
+            await provider.forceFlush();
+          } catch {
+          }
+        }
+      }
+      /**
+       * Run the deterministic ratio sampler directly for a trace id with no
+       * real parent. See `ratioSample` for the decorrelation rationale — feeding
+       * a raw uuid4 trace id straight to a ratio sampler produces a hard
+       * 0%/100% step function because of uuid4's fixed variant bits.
+       */
+      resolveSampled(traceIdHex) {
+        return ratioSample(traceIdHex, this.sampleRate);
+      }
+      /**
+       * Register OTel `Instrumentation` instances (e.g. the community DB-driver
+       * auto-instrumentation packages, see `./db-capture.ts`, MHQ-482) against
+       * THIS engine's `NodeTracerProvider` — so spans they emit flow through
+       * the same `BatchSpanProcessor` -> `RedactingSpanExporter` ->
+       * `OTLPTraceExporter` pipeline `configure()` built, landing in the same
+       * OTLP stream (and, when nested inside an active OTel context, the same
+       * trace) as the rest of the SDK's spans.
+       *
+       * No-op (silently, returns `null`) if `configure()` hasn't run yet —
+       * mirrors `emitTraceEntry`'s "no transport configured -> silent"
+       * contract. Callers (`index.ts::buildSingleton`) must call this AFTER
+       * `configure()`.
+       */
+      registerInstrumentations(instrumentations) {
+        if (this.provider === null) return null;
+        return instrumentation.registerInstrumentations({
+          tracerProvider: this.provider,
+          instrumentations
+        });
+      }
+    };
+    engine = null;
+  }
+});
+
+// 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() || false) {
+    if (transport !== null) {
+      try {
+        transport.track({ traces: [entry] });
+      } catch {
+      }
+    }
+    return;
+  }
+  try {
+    emitTraceEntry(entry);
+  } catch {
+  }
+}
+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();
+    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 = init_otel_provider;
+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.isAutoDetectDisabled = isAutoDetectDisabled;
+exports.isDbCaptureEnabled = isDbCaptureEnabled;
+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-FJUNILZT.cjs.map
+//# sourceMappingURL=chunk-FJUNILZT.cjs.map