@neetru/sdk 3.5.0 → 3.7.0

package/dist/telemetry.mjs

@@ -1,5 +1,5 @@
 // src/errors.ts
-var NeetruError = class _NeetruError extends Error {
+var a = class e extends Error {
   code;
   status;
   requestId;
@@ -12,233 +12,184 @@ var NeetruError = class _NeetruError extends Error {
    * para um `NeetruDbErrorCode` mais específico (recuperável vs não).
    */
   reason;
-  constructor(code, message, status, requestId, reason) {
-    super(message);
-    this.name = "NeetruError";
-    this.code = code;
-    this.status = status;
-    this.requestId = requestId;
-    this.reason = reason;
-    Object.setPrototypeOf(this, _NeetruError.prototype);
+  constructor(r, n, d, m, c) {
+    super(n), this.name = "NeetruError", this.code = r, this.status = d, this.requestId = m, this.reason = c, Object.setPrototypeOf(this, e.prototype);
   }
 };
 
 // src/idempotency.ts
-function generateIdempotencyKey() {
-  const cryptoObj = typeof globalThis !== "undefined" && "crypto" in globalThis ? globalThis.crypto : void 0;
-  if (cryptoObj && typeof cryptoObj.randomUUID === "function") {
-    return cryptoObj.randomUUID();
-  }
-  throw new NeetruError(
+function R() {
+  let e = typeof globalThis < "u" && "crypto" in globalThis ? globalThis.crypto : void 0;
+  if (e && typeof e.randomUUID == "function")
+    return e.randomUUID();
+  throw new a(
     "runtime_unsupported",
     "crypto.randomUUID not available in this runtime. SDK 3.0 requires Node \u226520 or modern browser/Edge."
   );
 }
 
 // src/http.ts
-var COMPAT_MATRIX = {
+var L = {
   // SDK major 3.x requer Core ≥ 2026.05.1 (suporte a X-Neetru-Version header,
   // runTransaction write-after-read, verifyWebhookRequest, webhooks 3.0+)
   3: "2026.05.1"
 };
-function stripRevision(v) {
-  return v.split("+")[0] ?? v;
+function v(e) {
+  return e.split("+")[0] ?? e;
 }
-function compareCalVer(a, b) {
-  const partsA = stripRevision(a).split(".").map(Number);
-  const partsB = stripRevision(b).split(".").map(Number);
-  const len = Math.max(partsA.length, partsB.length);
-  for (let i = 0; i < len; i++) {
-    const pa = partsA[i] ?? 0;
-    const pb = partsB[i] ?? 0;
-    if (pa !== pb) return pa - pb;
+function O(e, r) {
+  let n = v(e).split(".").map(Number), d = v(r).split(".").map(Number), m = Math.max(n.length, d.length);
+  for (let c = 0; c < m; c++) {
+    let t = n[c] ?? 0, i = d[c] ?? 0;
+    if (t !== i) return t - i;
   }
   return 0;
 }
-function readInjectedSdkVersion() {
+function D() {
   try {
-    return "3.5.0";
+    return "3.7.0";
   } catch {
-    return void 0;
+    return;
   }
 }
-function getSdkMajor() {
-  const ver = readInjectedSdkVersion();
-  if (ver) return parseInt(ver.split(".")[0] ?? "3", 10);
-  return 3;
+function U() {
+  let e = D();
+  return e ? parseInt(e.split(".")[0] ?? "3", 10) : 3;
 }
-var _warnedCoreTooOld = /* @__PURE__ */ new Set();
-function checkCoreVersionCompat(coreVersion) {
-  if (!coreVersion) return;
-  const sdkMajor = getSdkMajor();
-  const minCore = COMPAT_MATRIX[sdkMajor];
-  if (!minCore) return;
-  const stripped = stripRevision(coreVersion);
-  if (compareCalVer(stripped, minCore) < 0) {
-    const key = `${sdkMajor}:${stripped}`;
-    if (!_warnedCoreTooOld.has(key)) {
-      _warnedCoreTooOld.add(key);
-      console.warn(
-        `[Neetru SDK] Aten\xE7\xE3o: Core vers\xE3o "${coreVersion}" \xE9 anterior ao m\xEDnimo recomendado "${minCore}" para SDK major ${sdkMajor}. Alguns recursos podem n\xE3o funcionar corretamente. Atualize o Core para a vers\xE3o mais recente.`
-      );
-    }
+var A = /* @__PURE__ */ new Set();
+function j(e) {
+  if (!e) return;
+  let r = U(), n = L[r];
+  if (!n) return;
+  let d = v(e);
+  if (O(d, n) < 0) {
+    let m = `${r}:${d}`;
+    A.has(m) || (A.add(m), console.warn(
+      `[Neetru SDK] Aten\xE7\xE3o: Core vers\xE3o "${e}" \xE9 anterior ao m\xEDnimo recomendado "${n}" para SDK major ${r}. Alguns recursos podem n\xE3o funcionar corretamente. Atualize o Core para a vers\xE3o mais recente.`
+    ));
   }
 }
-var DEFAULT_RETRIES_READ = 2;
-var DEFAULT_RETRIES_WRITE = 0;
-var READ_METHODS = /* @__PURE__ */ new Set(["GET", "HEAD"]);
-var RETRYABLE_CODES = /* @__PURE__ */ new Set([
+var $ = 2, K = 0, H = /* @__PURE__ */ new Set(["GET", "HEAD"]), F = /* @__PURE__ */ new Set([
   "rate_limited",
   "server_error",
   "network_error"
 ]);
-function backoffMs(attempt) {
-  const base = 200 * Math.pow(4, attempt);
-  const jitter = base * 0.2 * (Math.random() * 2 - 1);
-  return Math.max(50, Math.round(base + jitter));
+function I(e) {
+  let r = 200 * Math.pow(4, e), n = r * 0.2 * (Math.random() * 2 - 1);
+  return Math.max(50, Math.round(r + n));
 }
-var MAX_RETRY_AFTER_MS = 6e4;
-function parseRetryAfter(value) {
-  if (!value) return null;
-  const secs = Number(value);
-  if (Number.isFinite(secs) && secs >= 0) return Math.min(Math.round(secs * 1e3), MAX_RETRY_AFTER_MS);
-  const dateMs = Date.parse(value);
-  if (Number.isFinite(dateMs)) {
-    const delta = dateMs - Date.now();
-    if (delta > 0) return Math.min(delta, MAX_RETRY_AFTER_MS);
+var S = 6e4;
+function V(e) {
+  if (!e) return null;
+  let r = Number(e);
+  if (Number.isFinite(r) && r >= 0) return Math.min(Math.round(r * 1e3), S);
+  let n = Date.parse(e);
+  if (Number.isFinite(n)) {
+    let d = n - Date.now();
+    if (d > 0) return Math.min(d, S);
   }
   return null;
 }
-function sleep(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
+function q(e) {
+  return new Promise((r) => setTimeout(r, e));
 }
-function statusToCode(status) {
-  if (status === 401) return "unauthorized";
-  if (status === 403) return "forbidden";
-  if (status === 404) return "not_found";
-  if (status === 409) return "conflict";
-  if (status === 422 || status === 400) return "validation_failed";
-  if (status === 429) return "rate_limited";
-  if (status >= 500) return "server_error";
-  return "unknown";
+function G(e) {
+  return e === 401 ? "unauthorized" : e === 403 ? "forbidden" : e === 404 ? "not_found" : e === 409 ? "conflict" : e === 410 ? "gone" : e === 422 || e === 400 ? "validation_failed" : e === 429 ? "rate_limited" : e >= 500 ? "server_error" : "unknown";
 }
-function buildUrl(baseUrl, path, query) {
-  const base = baseUrl.replace(/\/+$/, "");
-  const p = path.startsWith("/") ? path : `/${path}`;
-  const url = new URL(`${base}${p}`);
-  if (query) {
-    for (const [k, v] of Object.entries(query)) {
-      if (v === void 0) continue;
-      url.searchParams.set(k, String(v));
-    }
-  }
-  return url.toString();
+function z(e, r, n) {
+  let d = e.replace(/\/+$/, ""), m = r.startsWith("/") ? r : `/${r}`, c = new URL(`${d}${m}`);
+  if (n)
+    for (let [t, i] of Object.entries(n))
+      i !== void 0 && c.searchParams.set(t, String(i));
+  return c.toString();
 }
-async function safeJson(res) {
-  const text = await res.text();
-  if (!text) return void 0;
-  try {
-    return JSON.parse(text);
-  } catch {
-    return void 0;
-  }
+async function x(e) {
+  let r = await e.text();
+  if (r)
+    try {
+      return JSON.parse(r);
+    } catch {
+      return;
+    }
 }
-async function httpRequest(config, opts) {
-  const method = opts.method ?? "GET";
-  const url = buildUrl(config.baseUrl, opts.path, opts.query);
-  const defaultRetries = READ_METHODS.has(method) ? DEFAULT_RETRIES_READ : DEFAULT_RETRIES_WRITE;
-  const maxRetries = opts.retries ?? defaultRetries;
-  const headers = {
+async function _(e, r) {
+  let n = r.method ?? "GET", d = z(e.baseUrl, r.path, r.query), m = H.has(n) ? $ : K, c = r.retries ?? m, t = {
     accept: "application/json",
-    ...opts.headers
-  };
-  const sdkVersion = readInjectedSdkVersion();
-  if (sdkVersion) {
-    headers["x-neetru-sdk-version"] = sdkVersion;
-  }
-  if (opts.requireAuth) {
-    if (!config.apiKey) {
-      throw new NeetruError(
+    ...r.headers
+  }, i = D();
+  if (i && (t["x-neetru-sdk-version"] = i), r.requireAuth) {
+    if (!e.apiKey)
+      throw new a(
         "missing_api_key",
         "This operation requires an apiKey. Pass it to createNeetruClient({ apiKey }) or set NEETRU_API_KEY env var."
       );
-    }
-    headers.authorization = `Bearer ${config.apiKey}`;
-  }
-  if (opts.idempotencyKey) {
-    const key = typeof opts.idempotencyKey === "string" ? opts.idempotencyKey : generateIdempotencyKey();
-    headers["idempotency-key"] = key;
+    t.authorization = `Bearer ${e.apiKey}`;
   }
-  const bodyString = opts.body !== void 0 && method !== "GET" && method !== "DELETE" ? JSON.stringify(opts.body) : void 0;
-  if (bodyString !== void 0) {
-    headers["content-type"] = "application/json";
+  if (r.idempotencyKey) {
+    let f = typeof r.idempotencyKey == "string" ? r.idempotencyKey : R();
+    t["idempotency-key"] = f;
   }
-  let lastError = null;
-  for (let attempt = 0; attempt <= maxRetries; attempt++) {
-    const init = { method, headers };
-    if (bodyString !== void 0) init.body = bodyString;
-    init.signal = AbortSignal.timeout(3e4);
-    let res;
+  let l = r.body !== void 0 && n !== "GET" && n !== "DELETE" ? JSON.stringify(r.body) : void 0;
+  l !== void 0 && (t["content-type"] = "application/json");
+  let s = null, u = r.deadlineMs != null ? Date.now() + r.deadlineMs : null;
+  for (let f = 0; f <= c; f++) {
+    if (u != null && Date.now() >= u)
+      throw s ?? new a("network_error", "Deadline excedido antes de completar a request");
+    let y = { method: n, headers: t };
+    l !== void 0 && (y.body = l);
+    let M = u != null ? Math.max(1, Math.min(3e4, u - Date.now())) : 3e4;
+    y.signal = AbortSignal.timeout(M);
+    let p;
     try {
-      res = await config.fetch(url, init);
-    } catch (err2) {
-      const message2 = err2 instanceof DOMException && err2.name === "TimeoutError" ? "Network error: timeout after 30s" : `Network error: ${err2 instanceof Error ? err2.message : "fetch failed"}`;
-      lastError = new NeetruError("network_error", message2);
-      if (attempt < maxRetries) {
-        await sleep(backoffMs(attempt));
-        continue;
+      p = await e.fetch(d, y);
+    } catch (o) {
+      let w = o instanceof DOMException && o.name === "TimeoutError" ? "Network error: timeout after 30s" : `Network error: ${o instanceof Error ? o.message : "fetch failed"}`;
+      if (s = new a("network_error", w), f < c) {
+        let k = I(f);
+        if (u == null || Date.now() + k < u) {
+          await q(k);
+          continue;
+        }
       }
-      throw lastError;
+      throw s;
     }
-    const requestId = res.headers.get("x-request-id") ?? res.headers.get("x-correlation-id") ?? void 0;
-    if (res.ok) {
-      const coreVersion = res.headers.get("x-neetru-version");
-      if (coreVersion) checkCoreVersionCompat(coreVersion);
-      const parsed = await safeJson(res);
-      return parsed;
+    let P = p.headers.get("x-request-id") ?? p.headers.get("x-correlation-id") ?? void 0;
+    if (p.ok) {
+      let o = p.headers.get("x-neetru-version");
+      return o && j(o), await x(p);
     }
-    const body = await safeJson(res);
-    let code = statusToCode(res.status);
-    let message = `HTTP ${res.status}`;
-    let reason;
-    if (body && typeof body === "object") {
-      const errField = body.error;
-      if (typeof errField === "string") {
-        message = errField;
-      } else if (errField && typeof errField === "object") {
-        if (typeof errField.code === "string") code = errField.code;
-        if (typeof errField.message === "string") message = errField.message;
-        if (typeof errField.reason === "string") reason = errField.reason;
-      } else {
-        if (typeof body.code === "string") code = body.code;
-        if (typeof body.message === "string") message = body.message;
-      }
-      if (typeof body.reason === "string") reason = body.reason;
+    let g = await x(p), b = G(p.status), h = `HTTP ${p.status}`, T;
+    if (g && typeof g == "object") {
+      let o = g.error;
+      typeof o == "string" ? h = o : o && typeof o == "object" ? (typeof o.code == "string" && (b = o.code), typeof o.message == "string" && (h = o.message), typeof o.reason == "string" && (T = o.reason)) : (typeof g.code == "string" && (b = g.code), typeof g.message == "string" && (h = g.message)), typeof g.reason == "string" && (T = g.reason);
+    }
+    if (p.status === 410) {
+      let o = p.headers.get("x-neetru-replacement");
+      h === `HTTP ${p.status}` && (h = `Endpoint ${r.path} foi removido do Core (HTTP 410 Gone) \u2014 atualize o @neetru/sdk e migre para a API substituta.`), o && !h.includes(o) && (h += ` Substituto: ${o}.`);
     }
-    const err = new NeetruError(code, message, res.status, requestId, reason);
-    lastError = err;
-    const isRetryable = RETRYABLE_CODES.has(code);
-    if (isRetryable && attempt < maxRetries) {
-      const retryAfter = parseRetryAfter(res.headers.get("retry-after"));
-      const delay = retryAfter ?? backoffMs(attempt);
-      await sleep(delay);
-      continue;
+    let E = new a(b, h, p.status, P, T);
+    if (s = E, F.has(b) && f < c) {
+      let w = V(p.headers.get("retry-after")) ?? I(f);
+      if (u == null || Date.now() + w < u) {
+        await q(w);
+        continue;
+      }
     }
-    throw err;
+    throw E;
   }
-  throw lastError ?? new NeetruError("unknown", "unexpected httpRequest exit");
+  throw s ?? new a("unknown", "unexpected httpRequest exit");
 }
 
 // src/telemetry.ts
-var VALID_LOG_LEVELS = ["debug", "info", "warn", "error", "fatal"];
-function isBrowserContext() {
-  return typeof globalThis !== "undefined" && typeof globalThis.window !== "undefined";
+var N = ["debug", "info", "warn", "error", "fatal"];
+function B() {
+  return typeof globalThis < "u" && typeof globalThis.window < "u";
 }
-function resolveEventTransport() {
-  return isBrowserContext() ? { path: "/api/sdk/v1/telemetry/event/public", requireAuth: false } : { path: "/api/sdk/v1/telemetry/event", requireAuth: true };
+function C() {
+  return B() ? { path: "/api/sdk/v1/telemetry/event/public", requireAuth: false } : { path: "/api/sdk/v1/telemetry/event", requireAuth: true };
 }
-function consoleFor(level) {
-  switch (level) {
+function J(e) {
+  switch (e) {
     case "debug":
       return console.debug.bind(console);
     case "info":
@@ -253,58 +204,41 @@ function consoleFor(level) {
       return console.log.bind(console);
   }
 }
-var TRACK_FLUSH_MS = 500;
-var TRACK_MAX_QUEUE = 50;
-function createTelemetryNamespace(config) {
-  const queue = [];
-  let flushTimer = null;
-  let _inflightDrain = null;
-  async function drainQueue() {
-    if (queue.length === 0) return;
-    const batch = queue.splice(0, queue.length);
-    const work = Promise.allSettled(
-      batch.map(async (ev) => {
+var X = 500, Y = 50;
+function se(e) {
+  let r = [], n = null, d = null;
+  async function m() {
+    if (r.length === 0) return;
+    let t = r.splice(0, r.length), i = Promise.allSettled(
+      t.map(async (l) => {
         try {
-          const body = { name: ev.name };
-          const productSlug = ev.productSlug ?? config.productId;
-          if (productSlug) body.productSlug = productSlug;
-          if (ev.properties && typeof ev.properties === "object") {
-            body.properties = ev.properties;
-          }
-          if (ev.timestamp) body.timestamp = ev.timestamp;
-          const transport = resolveEventTransport();
-          await httpRequest(config, {
+          let s = { name: l.name }, u = l.productSlug ?? e.productId;
+          u && (s.productSlug = u), l.properties && typeof l.properties == "object" && (s.properties = l.properties), l.timestamp && (s.timestamp = l.timestamp);
+          let f = C();
+          await _(e, {
             method: "POST",
-            path: transport.path,
-            body,
-            requireAuth: transport.requireAuth,
+            path: f.path,
+            body: s,
+            requireAuth: f.requireAuth,
             retries: 1,
             // caça-bruxas: retry sem Idempotency-Key duplicava o evento se o
             // servidor já tinha persistido antes da falha transiente. Mesmo
             // padrão do usage.report (key estável por chamada, reusada no retry).
-            idempotencyKey: true
+            idempotencyKey: !0
           });
-        } catch (err) {
-          if (typeof console !== "undefined") {
-            console.warn("[neetru-sdk] telemetry.track flush failed for event", ev.name, err);
-          }
+        } catch (s) {
+          typeof console < "u" && console.warn("[neetru-sdk] telemetry.track flush failed for event", l.name, s);
         }
       })
     );
-    _inflightDrain = work.then(() => {
-      _inflightDrain = null;
-    });
-    await work;
-    flushTimer = null;
-    if (queue.length > 0) {
-      scheduleFlush();
-    }
+    d = i.then(() => {
+      d = null;
+    }), await i, n = null, r.length > 0 && c();
   }
-  function scheduleFlush() {
-    if (flushTimer) return;
-    flushTimer = setTimeout(() => {
-      void drainQueue();
-    }, TRACK_FLUSH_MS);
+  function c() {
+    n || (n = setTimeout(() => {
+      m();
+    }, X));
   }
   return {
     /**
@@ -319,34 +253,24 @@ function createTelemetryNamespace(config) {
      * });
      * ```
      */
-    async event(input) {
-      if (!input || typeof input !== "object") {
-        throw new NeetruError("validation_failed", "event input is required");
-      }
-      if (typeof input.name !== "string" || input.name.length === 0) {
-        throw new NeetruError("validation_failed", "event.name is required");
-      }
-      if (input.name.length > 128) {
-        throw new NeetruError("validation_failed", "event.name max 128 chars");
-      }
-      const body = { name: input.name };
-      const productSlug = input.productSlug ?? config.productId;
-      if (productSlug) body.productSlug = productSlug;
-      if (input.properties && typeof input.properties === "object") {
-        body.properties = input.properties;
-      }
-      if (input.timestamp) body.timestamp = input.timestamp;
-      const transport = resolveEventTransport();
-      const raw = await httpRequest(config, {
+    async event(t) {
+      if (!t || typeof t != "object")
+        throw new a("validation_failed", "event input is required");
+      if (typeof t.name != "string" || t.name.length === 0)
+        throw new a("validation_failed", "event.name is required");
+      if (t.name.length > 128)
+        throw new a("validation_failed", "event.name max 128 chars");
+      let i = { name: t.name }, l = t.productSlug ?? e.productId;
+      l && (i.productSlug = l), t.properties && typeof t.properties == "object" && (i.properties = t.properties), t.timestamp && (i.timestamp = t.timestamp);
+      let s = C(), u = await _(e, {
         method: "POST",
-        path: transport.path,
-        body,
-        requireAuth: transport.requireAuth
+        path: s.path,
+        body: i,
+        requireAuth: s.requireAuth
       });
-      if (!raw || raw.ok !== true || typeof raw.eventId !== "string") {
-        throw new NeetruError("invalid_response", "Telemetry response missing eventId");
-      }
-      return { ok: true, eventId: raw.eventId };
+      if (!u || u.ok !== true || typeof u.eventId != "string")
+        throw new a("invalid_response", "Telemetry response missing eventId");
+      return { ok: true, eventId: u.eventId };
     },
     /**
      * Fire-and-forget: enqueue + flush 500ms debounce. Não retorna `eventId`
@@ -358,32 +282,15 @@ function createTelemetryNamespace(config) {
      * // segue execução; flush async em background
      * ```
      */
-    track(input) {
-      if (!input || typeof input !== "object") return;
-      if (typeof input.name !== "string" || input.name.length === 0) return;
-      if (input.name.length > 128) return;
-      queue.push(input);
-      if (queue.length >= TRACK_MAX_QUEUE) {
-        if (flushTimer) {
-          clearTimeout(flushTimer);
-          flushTimer = null;
-        }
-        void drainQueue();
-      } else {
-        scheduleFlush();
-      }
+    track(t) {
+      !t || typeof t != "object" || typeof t.name != "string" || t.name.length === 0 || t.name.length > 128 || (r.push(t), r.length >= Y ? (n && (clearTimeout(n), n = null), m()) : c());
     },
     /**
      * Força flush imediato da queue de `track()`. Resolva antes de
      * page unload / SSR boundary pra não perder eventos.
      */
     async flush() {
-      if (flushTimer) {
-        clearTimeout(flushTimer);
-        flushTimer = null;
-      }
-      if (_inflightDrain) await _inflightDrain;
-      await drainQueue();
+      n && (clearTimeout(n), n = null), d && await d, await m();
     },
     /**
      * Registra um log estruturado per-product (Sprint 6).
@@ -400,60 +307,49 @@ function createTelemetryNamespace(config) {
      * });
      * ```
      */
-    async log(input) {
-      if (!input || typeof input !== "object") {
-        throw new NeetruError("validation_failed", "log input is required");
-      }
-      if (!VALID_LOG_LEVELS.includes(input.level)) {
-        throw new NeetruError("validation_failed", `level must be one of ${VALID_LOG_LEVELS.join(", ")}`);
-      }
-      if (typeof input.message !== "string" || input.message.length === 0) {
-        throw new NeetruError("validation_failed", "message is required");
-      }
-      if (input.message.length > 4e3) {
-        throw new NeetruError("validation_failed", "message max 4000 chars");
-      }
-      if (config.env === "dev") {
-        const fn = consoleFor(input.level);
-        fn(`[neetru-sdk] ${input.level}: ${input.message}`, input.metadata ?? {});
-        return { ok: true, mode: "mock" };
-      }
-      const body = {
-        level: input.level,
-        message: input.message
+    async log(t) {
+      if (!t || typeof t != "object")
+        throw new a("validation_failed", "log input is required");
+      if (!N.includes(t.level))
+        throw new a("validation_failed", `level must be one of ${N.join(", ")}`);
+      if (typeof t.message != "string" || t.message.length === 0)
+        throw new a("validation_failed", "message is required");
+      if (t.message.length > 4e3)
+        throw new a("validation_failed", "message max 4000 chars");
+      if (e.env === "dev")
+        return J(t.level)(`[neetru-sdk] ${t.level}: ${t.message}`, t.metadata ?? {}), { ok: true, mode: "mock" };
+      let i = {
+        level: t.level,
+        message: t.message
       };
-      if (input.metadata) body.metadata = input.metadata;
-      const productSlug = input.productSlug ?? config.productId;
-      if (productSlug) body.productSlug = productSlug;
-      let cid = input.correlationId;
-      if (!cid) {
+      t.metadata && (i.metadata = t.metadata);
+      let l = t.productSlug ?? e.productId;
+      l && (i.productSlug = l);
+      let s = t.correlationId;
+      if (!s)
         try {
-          const g = globalThis.NEETRU_CORRELATION_ID;
-          if (typeof g === "string" && g.length > 0) cid = g;
+          let y = globalThis.NEETRU_CORRELATION_ID;
+          typeof y == "string" && y.length > 0 && (s = y);
         } catch {
         }
-      }
-      const headers = {};
-      if (cid) headers["x-correlation-id"] = cid;
-      const raw = await httpRequest(config, {
+      let u = {};
+      s && (u["x-correlation-id"] = s);
+      let f = await _(e, {
         method: "POST",
         path: "/api/sdk/v1/telemetry/log",
-        body,
+        body: i,
         requireAuth: true,
-        headers
+        headers: u
       });
-      if (!raw || raw.ok !== true) {
-        throw new NeetruError("invalid_response", "Telemetry log response missing ok");
-      }
+      if (!f || f.ok !== true)
+        throw new a("invalid_response", "Telemetry log response missing ok");
       return {
         ok: true,
-        logId: typeof raw.logId === "string" ? raw.logId : void 0,
+        logId: typeof f.logId == "string" ? f.logId : void 0,
         mode: "http"
       };
     }
   };
 }
 
-export { createTelemetryNamespace };
-//# sourceMappingURL=telemetry.mjs.map
-//# sourceMappingURL=telemetry.mjs.map
+export { se as createTelemetryNamespace };