@neetru/sdk 1.1.1 → 1.2.0

package/dist/auth.mjs

@@ -17,6 +17,31 @@ var NeetruError = class _NeetruError extends Error {
 var DEFAULT_BASE_URL = "https://api.neetru.com";
 
 // src/http.ts
+var DEFAULT_RETRIES = 2;
+var RETRYABLE_CODES = /* @__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 parseRetryAfter(value) {
+  if (!value) return null;
+  const secs = Number(value);
+  if (Number.isFinite(secs) && secs >= 0) return Math.round(secs * 1e3);
+  const dateMs = Date.parse(value);
+  if (Number.isFinite(dateMs)) {
+    const delta = dateMs - Date.now();
+    if (delta > 0) return delta;
+  }
+  return null;
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
 function statusToCode(status) {
   if (status === 401) return "unauthorized";
   if (status === 403) return "forbidden";
@@ -50,6 +75,7 @@ async function safeJson(res) {
 async function httpRequest(config, opts) {
   const method = opts.method ?? "GET";
   const url = buildUrl(config.baseUrl, opts.path, opts.query);
+  const maxRetries = opts.retries ?? DEFAULT_RETRIES;
   const headers = {
     accept: "application/json",
     ...opts.headers
@@ -63,24 +89,32 @@ async function httpRequest(config, opts) {
     }
     headers.authorization = `Bearer ${config.apiKey}`;
   }
-  const init = { method, headers };
-  if (opts.body !== void 0 && method !== "GET" && method !== "DELETE") {
+  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";
-    init.body = JSON.stringify(opts.body);
   }
-  init.signal = AbortSignal.timeout(3e4);
-  let res;
-  try {
-    res = await config.fetch(url, init);
-  } catch (err) {
-    if (err instanceof DOMException && err.name === "TimeoutError") {
-      throw new NeetruError("network_error", "Network error: timeout after 30s");
+  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;
+    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;
+      }
+      throw lastError;
+    }
+    const requestId = res.headers.get("x-request-id") ?? res.headers.get("x-correlation-id") ?? void 0;
+    if (res.ok) {
+      const parsed = await safeJson(res);
+      return parsed;
     }
-    const message = err instanceof Error ? err.message : "fetch failed";
-    throw new NeetruError("network_error", `Network error: ${message}`);
-  }
-  const requestId = res.headers.get("x-request-id") ?? res.headers.get("x-correlation-id") ?? void 0;
-  if (!res.ok) {
     const body = await safeJson(res);
     let code = statusToCode(res.status);
     let message = `HTTP ${res.status}`;
@@ -93,10 +127,18 @@ async function httpRequest(config, opts) {
         if (typeof errField.message === "string") message = errField.message;
       }
     }
-    throw new NeetruError(code, message, res.status, requestId);
+    const err = new NeetruError(code, message, res.status, requestId);
+    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;
+    }
+    throw err;
   }
-  const parsed = await safeJson(res);
-  return parsed;
+  throw lastError ?? new NeetruError("unknown", "unexpected httpRequest exit");
 }
 
 // src/catalog.ts
@@ -136,12 +178,10 @@ function createCatalogNamespace(config) {
      * Lista produtos publicados. Por default só `published=true`; staff
      * pode passar `includeDrafts: true` (requer Bearer com role admin/operator).
      */
-    async list(opts = {}) {
+    async list(_opts = {}) {
       const raw = await httpRequest(config, {
         method: "GET",
-        path: "/api/v1/cli/catalog",
-        query: opts.includeDrafts ? { drafts: "true" } : void 0,
-        requireAuth: true
+        path: "/api/sdk/v1/catalog"
       });
       if (!raw || !Array.isArray(raw.products)) {
         throw new NeetruError(
@@ -165,8 +205,7 @@ function createCatalogNamespace(config) {
       }
       const raw = await httpRequest(config, {
         method: "GET",
-        path: `/api/v1/cli/catalog/${encodeURIComponent(slug)}`,
-        requireAuth: true
+        path: `/api/sdk/v1/catalog/${encodeURIComponent(slug)}`
       });
       if (!raw || !raw.product) {
         throw new NeetruError(
@@ -195,30 +234,65 @@ function toEntitlementCheck(raw) {
     reason: typeof r.reason === "string" ? r.reason : void 0
   };
 }
+var CACHE_TTL_MS = 6e4;
+var CACHE_MAX = 100;
 function createEntitlementsNamespace(config) {
-  async function checkDetailed(productSlug, feature) {
+  const cache = /* @__PURE__ */ new Map();
+  function cacheKey(productSlug, feature) {
+    return `${productSlug}::${feature}`;
+  }
+  function readCache(key) {
+    const entry = cache.get(key);
+    if (!entry) return null;
+    if (entry.expiresAt < Date.now()) {
+      cache.delete(key);
+      return null;
+    }
+    cache.delete(key);
+    cache.set(key, entry);
+    return entry.value;
+  }
+  function writeCache(key, value) {
+    if (cache.size >= CACHE_MAX) {
+      const oldest = cache.keys().next().value;
+      if (oldest !== void 0) cache.delete(oldest);
+    }
+    cache.set(key, { value, expiresAt: Date.now() + CACHE_TTL_MS });
+  }
+  async function checkDetailed(productSlug, feature, opts = {}) {
     if (!productSlug) throw new NeetruError("validation_failed", "productSlug is required");
     if (!feature) throw new NeetruError("validation_failed", "feature is required");
+    const key = cacheKey(productSlug, feature);
+    if (!opts.cacheBust) {
+      const cached = readCache(key);
+      if (cached) return cached;
+    }
     const raw = await httpRequest(config, {
       method: "GET",
       path: "/api/v1/sdk/entitlements/check",
       query: { slug: productSlug, feature },
       requireAuth: true
     });
-    return toEntitlementCheck(raw);
+    const result = toEntitlementCheck(raw);
+    writeCache(key, result);
+    return result;
   }
   return {
     /**
      * Verifica se o caller pode usar `feature` no produto `productSlug`.
-     * Retorno simples: `true` libera, `false` bloqueia.
+     * Retorno simples: `true` libera, `false` bloqueia. Cache 60s automático.
      *
      * Use `checkDetailed` se precisar do `reason` pra mensagem de upgrade.
      */
-    async check(productSlug, feature) {
-      const result = await checkDetailed(productSlug, feature);
+    async check(productSlug, feature, opts) {
+      const result = await checkDetailed(productSlug, feature, opts);
       return result.allowed;
     },
-    checkDetailed
+    checkDetailed,
+    /** Test helper: limpa o cache LRU. */
+    __resetCache() {
+      cache.clear();
+    }
   };
 }
 
@@ -240,7 +314,44 @@ 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;
+  async function drainQueue() {
+    if (queue.length === 0) return;
+    const batch = queue.splice(0, queue.length);
+    flushTimer = null;
+    await Promise.allSettled(
+      batch.map(async (ev) => {
+        try {
+          const body = { name: ev.name };
+          if (ev.properties && typeof ev.properties === "object") {
+            body.properties = ev.properties;
+          }
+          if (ev.timestamp) body.timestamp = ev.timestamp;
+          await httpRequest(config, {
+            method: "POST",
+            path: "/api/v1/sdk/telemetry/event",
+            body,
+            requireAuth: true,
+            retries: 1
+          });
+        } catch (err) {
+          if (typeof console !== "undefined") {
+            console.warn("[neetru-sdk] telemetry.track flush failed for event", ev.name, err);
+          }
+        }
+      })
+    );
+  }
+  function scheduleFlush() {
+    if (flushTimer) return;
+    flushTimer = setTimeout(() => {
+      void drainQueue();
+    }, TRACK_FLUSH_MS);
+  }
   return {
     /**
      * Persiste um evento de uso. Lança `NeetruError` em qualquer falha
@@ -280,6 +391,38 @@ function createTelemetryNamespace(config) {
       }
       return { ok: true, eventId: raw.eventId };
     },
+    /**
+     * Fire-and-forget: enqueue + flush 500ms debounce. Não retorna `eventId`
+     * — falhas são logadas como warning. Ideal pra alta frequência.
+     *
+     * @example
+     * ```ts
+     * client.telemetry.track({ name: 'page_view', properties: { path: '/' } });
+     * // 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) {
+        void drainQueue();
+      } else {
+        scheduleFlush();
+      }
+    },
+    /**
+     * 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;
+      }
+      await drainQueue();
+    },
     /**
      * Registra um log estruturado per-product (Sprint 6).
      *
@@ -331,7 +474,7 @@ function createTelemetryNamespace(config) {
       if (cid) headers["x-correlation-id"] = cid;
       const raw = await httpRequest(config, {
         method: "POST",
-        path: "/sdk/v1/telemetry/log",
+        path: "/api/sdk/v1/telemetry/log",
         body,
         requireAuth: true,
         headers
@@ -592,8 +735,7 @@ function createDbNamespace(config) {
       if (config.tenantId) headers["x-neetru-tenant"] = config.tenantId;
       return {
         async list(opts) {
-          if (opts?.limit !== void 0) opts.limit;
-          let path = `/sdk/v1/datastore/${name}`;
+          let path = `/api/sdk/v1/datastore/${name}`;
           const params = new URLSearchParams();
           if (opts?.limit !== void 0) params.set("limit", String(opts.limit));
           if (opts?.where && opts.where.length > 0) {
@@ -625,7 +767,7 @@ function createDbNamespace(config) {
           try {
             const raw = await httpRequest(config, {
               method: "GET",
-              path: `/sdk/v1/datastore/${name}/${encodeURIComponent(id)}`,
+              path: `/api/sdk/v1/datastore/${name}/${encodeURIComponent(id)}`,
               requireAuth: true,
               headers
             });
@@ -641,7 +783,7 @@ function createDbNamespace(config) {
           }
           const raw = await httpRequest(config, {
             method: "POST",
-            path: `/sdk/v1/datastore/${name}`,
+            path: `/api/sdk/v1/datastore/${name}`,
             body: { data },
             requireAuth: true,
             headers
@@ -657,7 +799,7 @@ function createDbNamespace(config) {
           }
           await httpRequest(config, {
             method: "PUT",
-            path: `/sdk/v1/datastore/${name}/${encodeURIComponent(id)}`,
+            path: `/api/sdk/v1/datastore/${name}/${encodeURIComponent(id)}`,
             body: { data },
             requireAuth: true,
             headers
@@ -670,7 +812,7 @@ function createDbNamespace(config) {
           }
           await httpRequest(config, {
             method: "PATCH",
-            path: `/sdk/v1/datastore/${name}/${encodeURIComponent(id)}`,
+            path: `/api/sdk/v1/datastore/${name}/${encodeURIComponent(id)}`,
             body: { data },
             requireAuth: true,
             headers
@@ -683,7 +825,7 @@ function createDbNamespace(config) {
           }
           await httpRequest(config, {
             method: "DELETE",
-            path: `/sdk/v1/datastore/${name}/${encodeURIComponent(id)}`,
+            path: `/api/sdk/v1/datastore/${name}/${encodeURIComponent(id)}`,
             requireAuth: true,
             headers
           });
@@ -869,6 +1011,297 @@ function createCheckoutNamespace(config) {
   return createHttpCheckoutNamespace(config);
 }
 
+// src/webhooks.ts
+var VALID_EVENTS = [
+  "subscription.activated",
+  "subscription.cancelled",
+  "subscription.payment_failed",
+  "subscription.trial_ending",
+  "usage.quota_exceeded",
+  "account.suspended",
+  "account.reactivated",
+  "support.ticket_replied"
+];
+function toEndpoint(raw) {
+  if (!raw || typeof raw !== "object") {
+    throw new NeetruError("invalid_response", "Webhook response is not an object");
+  }
+  const r = raw;
+  if (typeof r.id !== "string") {
+    throw new NeetruError("invalid_response", "Webhook missing id");
+  }
+  return {
+    id: r.id,
+    url: typeof r.url === "string" ? r.url : "",
+    events: Array.isArray(r.events) ? r.events.filter(
+      (e) => VALID_EVENTS.includes(e)
+    ) : [],
+    hasSecret: r.hasSecret === true,
+    status: r.status === "active" || r.status === "degraded" || r.status === "disabled" ? r.status : "active",
+    lastDeliveryAt: typeof r.lastDeliveryAt === "string" ? r.lastDeliveryAt : void 0,
+    consecutiveFailures: typeof r.consecutiveFailures === "number" ? r.consecutiveFailures : void 0,
+    createdAt: typeof r.createdAt === "string" ? r.createdAt : (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function validateInput(input) {
+  if (!input.url || typeof input.url !== "string") {
+    throw new NeetruError("validation_failed", "url \xE9 obrigat\xF3ria");
+  }
+  try {
+    const parsed = new URL(input.url);
+    if (parsed.protocol !== "https:" && parsed.protocol !== "http:") {
+      throw new Error("invalid protocol");
+    }
+  } catch {
+    throw new NeetruError("validation_failed", `url inv\xE1lida: ${input.url}`);
+  }
+  if (!Array.isArray(input.events) || input.events.length === 0) {
+    throw new NeetruError("validation_failed", "events deve ter pelo menos 1 evento");
+  }
+  for (const ev of input.events) {
+    if (!VALID_EVENTS.includes(ev)) {
+      throw new NeetruError("validation_failed", `evento desconhecido: ${ev}`);
+    }
+  }
+  if (input.secret !== void 0 && input.secret.length < 16) {
+    throw new NeetruError("validation_failed", "secret deve ter \u226516 chars (recomendado 32+)");
+  }
+}
+function createWebhooksNamespace(config) {
+  return {
+    async register(input) {
+      validateInput(input);
+      const raw = await httpRequest(config, {
+        method: "POST",
+        path: "/api/sdk/v1/webhooks",
+        body: input,
+        requireAuth: true
+      });
+      return toEndpoint(raw);
+    },
+    async list() {
+      const raw = await httpRequest(config, {
+        method: "GET",
+        path: "/api/sdk/v1/webhooks",
+        requireAuth: true
+      });
+      const list = Array.isArray(raw?.endpoints) ? raw.endpoints : [];
+      return list.map(toEndpoint);
+    },
+    async unregister(id) {
+      if (!id) throw new NeetruError("validation_failed", "id obrigat\xF3rio");
+      await httpRequest(config, {
+        method: "DELETE",
+        path: `/api/sdk/v1/webhooks/${encodeURIComponent(id)}`,
+        requireAuth: true
+      });
+      return { ok: true };
+    },
+    async test(id) {
+      if (!id) throw new NeetruError("validation_failed", "id obrigat\xF3rio");
+      const raw = await httpRequest(config, {
+        method: "POST",
+        path: `/api/sdk/v1/webhooks/${encodeURIComponent(id)}/test`,
+        requireAuth: true
+      });
+      if (!raw || typeof raw !== "object") {
+        return { ok: false, error: "invalid response" };
+      }
+      const r = raw;
+      return {
+        ok: r.ok === true,
+        statusCode: typeof r.statusCode === "number" ? r.statusCode : void 0,
+        durationMs: typeof r.durationMs === "number" ? r.durationMs : void 0,
+        error: typeof r.error === "string" ? r.error : void 0
+      };
+    }
+  };
+}
+var MockWebhooks = class {
+  endpoints = /* @__PURE__ */ new Map();
+  nextId = 1;
+  async register(input) {
+    validateInput(input);
+    const id = `mock_wh_${this.nextId++}`;
+    const endpoint = {
+      id,
+      url: input.url,
+      events: input.events,
+      hasSecret: !!input.secret,
+      status: "active",
+      createdAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    this.endpoints.set(id, endpoint);
+    return endpoint;
+  }
+  async list() {
+    return [...this.endpoints.values()];
+  }
+  async unregister(id) {
+    if (!this.endpoints.has(id)) {
+      throw new NeetruError("not_found", `Webhook ${id} n\xE3o encontrado`);
+    }
+    this.endpoints.delete(id);
+    return { ok: true };
+  }
+  async test(id) {
+    if (!this.endpoints.has(id)) {
+      throw new NeetruError("not_found", `Webhook ${id} n\xE3o encontrado`);
+    }
+    return { ok: true, statusCode: 200, durationMs: 42 };
+  }
+};
+
+// src/notifications.ts
+var VALID_SEVERITIES2 = [
+  "info",
+  "success",
+  "warning",
+  "error"
+];
+function toNotification(raw) {
+  if (!raw || typeof raw !== "object") {
+    throw new NeetruError("invalid_response", "Notification response is not an object");
+  }
+  const r = raw;
+  if (typeof r.id !== "string") {
+    throw new NeetruError("invalid_response", "Notification missing id");
+  }
+  const sev = VALID_SEVERITIES2.includes(r.severity) ? r.severity : "info";
+  return {
+    id: r.id,
+    userId: typeof r.userId === "string" ? r.userId : "",
+    kind: typeof r.kind === "string" ? r.kind : "unknown",
+    severity: sev,
+    title: typeof r.title === "string" ? r.title : "",
+    body: typeof r.body === "string" ? r.body : void 0,
+    link: typeof r.link === "string" ? r.link : void 0,
+    metadata: r.metadata && typeof r.metadata === "object" ? r.metadata : void 0,
+    createdAt: typeof r.createdAt === "string" ? r.createdAt : (/* @__PURE__ */ new Date()).toISOString(),
+    readAt: typeof r.readAt === "string" ? r.readAt : void 0,
+    dismissedAt: typeof r.dismissedAt === "string" ? r.dismissedAt : void 0
+  };
+}
+function validateInput2(input) {
+  if (!input.userId) throw new NeetruError("validation_failed", "userId obrigat\xF3rio");
+  if (!input.kind) throw new NeetruError("validation_failed", "kind obrigat\xF3rio");
+  if (!input.title) throw new NeetruError("validation_failed", "title obrigat\xF3rio");
+  if (input.severity && !VALID_SEVERITIES2.includes(input.severity)) {
+    throw new NeetruError(
+      "validation_failed",
+      `severity inv\xE1lida: ${input.severity} (use ${VALID_SEVERITIES2.join("|")})`
+    );
+  }
+  if (input.title.length > 200) {
+    throw new NeetruError("validation_failed", "title m\xE1x 200 chars");
+  }
+  if (input.body && input.body.length > 2e3) {
+    throw new NeetruError("validation_failed", "body m\xE1x 2000 chars");
+  }
+}
+function createNotificationsNamespace(config) {
+  return {
+    async send(input) {
+      validateInput2(input);
+      const raw = await httpRequest(config, {
+        method: "POST",
+        path: "/api/sdk/v1/notifications",
+        body: input,
+        requireAuth: true
+      });
+      return toNotification(raw);
+    },
+    async list(userId, options) {
+      if (!userId) throw new NeetruError("validation_failed", "userId obrigat\xF3rio");
+      const params = new URLSearchParams();
+      if (options?.includeDismissed) params.set("includeDismissed", "true");
+      if (options?.onlyUnread) params.set("onlyUnread", "true");
+      if (options?.limit) {
+        params.set("limit", Math.min(Math.max(1, options.limit), 200).toString());
+      }
+      const qs = params.toString();
+      const raw = await httpRequest(config, {
+        method: "GET",
+        path: `/api/sdk/v1/notifications/user/${encodeURIComponent(userId)}${qs ? `?${qs}` : ""}`,
+        requireAuth: true
+      });
+      const list = Array.isArray(raw?.notifications) ? raw.notifications : [];
+      return list.map(toNotification);
+    },
+    async markRead(id) {
+      if (!id) throw new NeetruError("validation_failed", "id obrigat\xF3rio");
+      await httpRequest(config, {
+        method: "POST",
+        path: `/api/sdk/v1/notifications/${encodeURIComponent(id)}/read`,
+        requireAuth: true
+      });
+      return { ok: true };
+    },
+    async dismiss(id) {
+      if (!id) throw new NeetruError("validation_failed", "id obrigat\xF3rio");
+      await httpRequest(config, {
+        method: "POST",
+        path: `/api/sdk/v1/notifications/${encodeURIComponent(id)}/dismiss`,
+        requireAuth: true
+      });
+      return { ok: true };
+    }
+  };
+}
+var MockNotifications = class {
+  notifications = /* @__PURE__ */ new Map();
+  nextId = 1;
+  async send(input) {
+    validateInput2(input);
+    if (input.fingerprint) {
+      const dayAgo = Date.now() - 864e5;
+      for (const existing of this.notifications.values()) {
+        const meta = existing.metadata ?? {};
+        if (meta.fingerprint === input.fingerprint && existing.userId === input.userId && new Date(existing.createdAt).getTime() > dayAgo) {
+          return existing;
+        }
+      }
+    }
+    const id = `mock_notif_${this.nextId++}`;
+    const notif = {
+      id,
+      userId: input.userId,
+      kind: input.kind,
+      severity: input.severity ?? "info",
+      title: input.title,
+      body: input.body,
+      link: input.link,
+      metadata: input.fingerprint ? { ...input.metadata ?? {}, fingerprint: input.fingerprint } : input.metadata,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    this.notifications.set(id, notif);
+    return notif;
+  }
+  async list(userId, options) {
+    if (!userId) throw new NeetruError("validation_failed", "userId obrigat\xF3rio");
+    const limit = Math.min(Math.max(1, options?.limit ?? 50), 200);
+    return [...this.notifications.values()].filter((n) => n.userId === userId).filter((n) => options?.includeDismissed || !n.dismissedAt).filter((n) => !options?.onlyUnread || !n.readAt).sort((a, b) => b.createdAt.localeCompare(a.createdAt)).slice(0, limit);
+  }
+  async markRead(id) {
+    const n = this.notifications.get(id);
+    if (!n) throw new NeetruError("not_found", `Notification ${id} n\xE3o encontrada`);
+    if (!n.readAt) {
+      n.readAt = (/* @__PURE__ */ new Date()).toISOString();
+      this.notifications.set(id, n);
+    }
+    return { ok: true };
+  }
+  async dismiss(id) {
+    const n = this.notifications.get(id);
+    if (!n) throw new NeetruError("not_found", `Notification ${id} n\xE3o encontrada`);
+    if (!n.dismissedAt) {
+      n.dismissedAt = (/* @__PURE__ */ new Date()).toISOString();
+      this.notifications.set(id, n);
+    }
+    return { ok: true };
+  }
+};
+
 // src/mocks.ts
 var DEV_FIXTURE_USER = Object.freeze({
   uid: "dev-fixture-uid-0001",
@@ -1004,14 +1437,14 @@ var MockUsage = class {
     this._counters.clear();
   }
 };
-var mockTicketSeq = 0;
 var MockSupport = class {
   _tickets = [];
+  _ticketSeq = 0;
   async createTicket(input) {
     if (!input?.subject) throw new Error("subject required");
     if (!input?.message) throw new Error("message required");
     const ticket = {
-      id: `mock-ticket-${++mockTicketSeq}`,
+      id: `mock-ticket-${++this._ticketSeq}`,
       subject: input.subject,
       message: input.message,
       severity: input.severity ?? "normal",
@@ -1028,6 +1461,7 @@ var MockSupport = class {
   /** Test helper. */
   __reset() {
     this._tickets = [];
+    this._ticketSeq = 0;
   }
 };
 var MockEntitlements = class {
@@ -1250,7 +1684,9 @@ function createOidcAuthNamespace(config) {
       if (storage) storage.removeItem(STORAGE_KEY);
       cachedUser = null;
       try {
-        await config.fetch(`${config.baseUrl}/oauth/revoke`, {
+        const overrideAuthUrl = typeof globalThis.NEETRU_AUTH_URL === "string" ? globalThis.NEETRU_AUTH_URL : null;
+        const idpOrigin = overrideAuthUrl ?? config.baseUrl.replace(/^https?:\/\/api\./, "https://auth.");
+        await config.fetch(`${idpOrigin}/api/v1/oauth/revoke`, {
           method: "POST",
           headers: { "content-type": "application/json" }
         });
@@ -1298,6 +1734,8 @@ function createNeetruClient(config = {}) {
   const support = config.mocks?.support ?? (isDev ? new MockSupport() : createSupportNamespace(resolved));
   const entitlements = config.mocks?.entitlements ?? (isDev ? new MockEntitlements() : createEntitlementsNamespace(resolved));
   const db = config.mocks?.db ?? (isDev ? new MockDb() : createDbNamespace(resolved));
+  const webhooks = config.mocks?.webhooks ?? (isDev ? new MockWebhooks() : createWebhooksNamespace(resolved));
+  const notifications = config.mocks?.notifications ?? (isDev ? new MockNotifications() : createNotificationsNamespace(resolved));
   const client = Object.freeze({
     config: resolved,
     auth,
@@ -1307,7 +1745,9 @@ function createNeetruClient(config = {}) {
     usage,
     support,
     db,
-    checkout: createCheckoutNamespace(resolved)
+    checkout: createCheckoutNamespace(resolved),
+    webhooks,
+    notifications
   });
   return client;
 }