@dvina/sdk 4.0.212 → 4.0.215

package/dist/{chunk-5TAY5I34.js → chunk-Q5XGHH7D.js}

@@ -850,6 +850,26 @@ function hasMultilineItems(maybeArray) {
   return (_maybeArray$some = maybeArray === null || maybeArray === void 0 ? void 0 : maybeArray.some((str) => str.includes("\n"))) !== null && _maybeArray$some !== void 0 ? _maybeArray$some : false;
 }
 
+// src/transport/core/token-refresh.ts
+var inFlightRefreshes = /* @__PURE__ */ new WeakMap();
+async function refreshTokenSingleFlight(getToken, failedToken) {
+  let inFlight = inFlightRefreshes.get(getToken);
+  if (!inFlight) {
+    const refreshPromise = getToken({ forceRefresh: true }).finally(() => {
+      if (inFlightRefreshes.get(getToken) === refreshPromise) {
+        inFlightRefreshes.delete(getToken);
+      }
+    });
+    inFlightRefreshes.set(getToken, refreshPromise);
+    inFlight = refreshPromise;
+  }
+  const refreshedToken = await inFlight;
+  if (failedToken && refreshedToken === failedToken) {
+    throw new DvinaAuthenticationError("Token refresh did not produce a new token", failedToken);
+  }
+  return refreshedToken;
+}
+
 // src/transport/http.ts
 var printCache = /* @__PURE__ */ new WeakMap();
 function printDocument(document) {
@@ -900,11 +920,22 @@ async function doFetch(options, document, variables) {
     query: printDocument(document),
     variables
   });
-  const response = await fetch(options.url, {
-    method: "POST",
-    headers,
-    body
-  });
+  let response;
+  try {
+    response = await fetch(options.url, {
+      method: "POST",
+      headers,
+      body
+    });
+  } catch (error) {
+    if (error instanceof Error && error.name === "AbortError") {
+      throw error;
+    }
+    throw new DvinaNetworkError(
+      error instanceof Error ? error.message : "Network request failed before reaching the server",
+      0
+    );
+  }
   if (!response.ok) {
     if (response.status === 401 || response.status === 403) {
       throw new DvinaAuthenticationError(`Authentication failed with status ${response.status}`, token);
@@ -963,10 +994,7 @@ async function handleAuthRefresh(document, variables, refreshState, options, fai
   if (!refreshState.isRefreshing) {
     refreshState.isRefreshing = true;
     try {
-      const newToken = await options.getToken({ forceRefresh: true });
-      if (failedToken && newToken === failedToken) {
-        throw new DvinaAuthenticationError("Token refresh did not produce a new token");
-      }
+      await refreshTokenSingleFlight(options.getToken, failedToken);
       refreshState.pendingRequests.forEach((req) => req.resolve());
       refreshState.pendingRequests = [];
       refreshState.isRefreshing = false;
@@ -1003,15 +1031,430 @@ function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
 
+// src/transport/core/connection-supervisor.ts
+var DEFAULT_AUTH_RETRY_DELAY_MS = 1e3;
+var DEFAULT_BASE_RECONNECT_DELAY_MS = 1e3;
+var DEFAULT_MAX_CONSECUTIVE_AUTH_FAILURES = 3;
+var DEFAULT_MAX_RECONNECT_DELAY_MS = 3e4;
+function isAbortError(error) {
+  return error instanceof Error && error.name === "AbortError";
+}
+function now() {
+  return Date.now();
+}
+var ConnectionSupervisor = class {
+  constructor(options) {
+    this.options = options;
+  }
+  abortController;
+  abortReason;
+  attemptPromise;
+  closed = false;
+  consecutiveAuthFailures = 0;
+  forceRefreshNext = false;
+  lastActivityAt = null;
+  lastConnectedAt = null;
+  lastError;
+  reconnectAttempt = 0;
+  reconnectTimer;
+  restartAfterCurrentAttempt = false;
+  state = "idle";
+  staleTimer;
+  shouldRun = false;
+  get snapshot() {
+    return {
+      consecutiveAuthFailures: this.consecutiveAuthFailures,
+      id: this.options.id,
+      kind: this.options.kind,
+      lastActivityAt: this.lastActivityAt,
+      lastConnectedAt: this.lastConnectedAt,
+      lastError: this.lastError,
+      reconnectAttempt: this.reconnectAttempt,
+      state: this.state
+    };
+  }
+  async start() {
+    if (this.closed) {
+      throw new Error(`Connection '${this.options.kind}:${this.options.id}' is closed`);
+    }
+    this.shouldRun = true;
+    this.clearReconnectTimer();
+    if (this.attemptPromise && this.abortReason) {
+      this.restartAfterCurrentAttempt = true;
+    }
+    return this.ensureAttempt();
+  }
+  stop() {
+    this.shouldRun = false;
+    this.restartAfterCurrentAttempt = false;
+    this.clearReconnectTimer();
+    this.clearStaleTimer();
+    this.abort("manual");
+    this.setState("idle");
+  }
+  close() {
+    this.closed = true;
+    this.shouldRun = false;
+    this.restartAfterCurrentAttempt = false;
+    this.clearReconnectTimer();
+    this.clearStaleTimer();
+    this.abort("manual");
+    this.setState("closed");
+  }
+  reconnect() {
+    if (this.closed) {
+      return;
+    }
+    this.shouldRun = true;
+    this.clearReconnectTimer();
+    this.clearStaleTimer();
+    if (this.abortController) {
+      this.restartAfterCurrentAttempt = true;
+      this.abort("restart");
+      return;
+    }
+    void this.ensureAttempt();
+  }
+  ensureAttempt() {
+    if (!this.shouldRun || this.closed) {
+      return Promise.resolve();
+    }
+    if (!this.attemptPromise) {
+      const attemptPromise = this.runAttempt().finally(() => {
+        if (this.attemptPromise === attemptPromise) {
+          this.attemptPromise = void 0;
+        }
+      });
+      this.attemptPromise = attemptPromise;
+    }
+    return this.attemptPromise;
+  }
+  async runAttempt() {
+    if (!this.shouldRun || this.closed) {
+      return;
+    }
+    const isReconnect = this.lastConnectedAt !== null || this.reconnectAttempt > 0;
+    this.setState("connecting");
+    this.lastError = void 0;
+    this.abortReason = void 0;
+    const abortController = new AbortController();
+    this.abortController = abortController;
+    try {
+      const token = this.forceRefreshNext ? await refreshTokenSingleFlight(this.options.getToken) : await this.options.getToken(void 0);
+      this.forceRefreshNext = false;
+      await this.options.dial({
+        isReconnect,
+        markActivity: () => this.markActivity(),
+        markConnected: () => this.markConnected(),
+        requestTokenRefresh: () => {
+          this.forceRefreshNext = true;
+        },
+        signal: abortController.signal,
+        token
+      });
+      if (!this.shouldRun || this.closed) {
+        return;
+      }
+      this.scheduleReconnect("end");
+    } catch (error) {
+      if (isAbortError(error)) {
+        if (this.abortReason === "stale" && this.shouldRun && !this.closed) {
+          this.scheduleReconnect("end");
+        }
+        return;
+      }
+      if (!this.shouldRun || this.closed) {
+        return;
+      }
+      this.handleFailure(error);
+    } finally {
+      if (this.abortController === abortController) {
+        this.abortController = void 0;
+      }
+      this.abortReason = void 0;
+      if (this.restartAfterCurrentAttempt && this.shouldRun && !this.closed) {
+        this.restartAfterCurrentAttempt = false;
+        queueMicrotask(() => {
+          if (!this.closed && this.shouldRun) {
+            void this.ensureAttempt();
+          }
+        });
+      }
+    }
+  }
+  handleFailure(error) {
+    this.lastError = error;
+    const isAuthError2 = this.options.isAuthError?.(error) ?? false;
+    if (isAuthError2) {
+      this.consecutiveAuthFailures += 1;
+      this.forceRefreshNext = true;
+      this.setState("reconnecting");
+      if (this.consecutiveAuthFailures >= (this.options.maxConsecutiveAuthFailures ?? DEFAULT_MAX_CONSECUTIVE_AUTH_FAILURES)) {
+        this.shouldRun = false;
+        this.clearReconnectTimer();
+        this.clearStaleTimer();
+        this.setState("failed");
+        this.options.onFatalError?.(error);
+        return;
+      }
+      this.scheduleReconnect("auth");
+      return;
+    }
+    this.consecutiveAuthFailures = 0;
+    if (typeof navigator !== "undefined" && "onLine" in navigator && navigator.onLine === false) {
+      this.setState("offline");
+    } else {
+      this.setState("reconnecting");
+    }
+    this.scheduleReconnect("failure");
+  }
+  scheduleReconnect(reason) {
+    if (!this.shouldRun || this.closed) {
+      return;
+    }
+    this.clearReconnectTimer();
+    this.clearStaleTimer();
+    const delay = reason === "auth" ? this.options.authRetryDelayMs ?? DEFAULT_AUTH_RETRY_DELAY_MS : reason === "failure" ? this.nextReconnectDelay() : this.options.baseReconnectDelayMs ?? DEFAULT_BASE_RECONNECT_DELAY_MS;
+    this.reconnectTimer = setTimeout(() => {
+      this.reconnectTimer = void 0;
+      void this.ensureAttempt();
+    }, delay);
+  }
+  nextReconnectDelay() {
+    const baseDelay = this.options.baseReconnectDelayMs ?? DEFAULT_BASE_RECONNECT_DELAY_MS;
+    const maxDelay = this.options.maxReconnectDelayMs ?? DEFAULT_MAX_RECONNECT_DELAY_MS;
+    const cappedDelay = Math.min(baseDelay * Math.pow(2, this.reconnectAttempt), maxDelay);
+    this.reconnectAttempt += 1;
+    if (this.options.jitter === "full") {
+      return Math.floor(Math.random() * cappedDelay);
+    }
+    return cappedDelay;
+  }
+  markConnected() {
+    this.consecutiveAuthFailures = 0;
+    this.reconnectAttempt = 0;
+    this.lastConnectedAt = now();
+    this.setState("connected");
+    this.markActivity();
+  }
+  markActivity() {
+    this.lastActivityAt = now();
+    this.armStaleTimer();
+  }
+  armStaleTimer() {
+    this.clearStaleTimer();
+    const staleTimeoutMs = this.options.staleTimeoutMs;
+    if (!staleTimeoutMs || staleTimeoutMs <= 0 || this.state !== "connected") {
+      return;
+    }
+    this.staleTimer = setTimeout(() => {
+      if (!this.shouldRun || this.closed || !this.abortController) {
+        return;
+      }
+      this.setState("stale");
+      this.abort("stale");
+    }, staleTimeoutMs);
+  }
+  clearReconnectTimer() {
+    if (!this.reconnectTimer) {
+      return;
+    }
+    clearTimeout(this.reconnectTimer);
+    this.reconnectTimer = void 0;
+  }
+  clearStaleTimer() {
+    if (!this.staleTimer) {
+      return;
+    }
+    clearTimeout(this.staleTimer);
+    this.staleTimer = void 0;
+  }
+  abort(reason) {
+    if (!this.abortController) {
+      return;
+    }
+    this.abortReason = reason;
+    this.abortController.abort();
+    this.abortController = void 0;
+  }
+  setState(nextState) {
+    if (this.state === nextState) {
+      return;
+    }
+    this.state = nextState;
+    this.options.onStateChange?.(this.snapshot);
+  }
+};
+
+// src/transport/core/sse-stream.ts
+async function consumeSseStream(body, signal, handlers) {
+  const reader = body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = "";
+  try {
+    while (!signal.aborted) {
+      const { done, value } = await reader.read();
+      if (done) {
+        break;
+      }
+      handlers.onChunk?.();
+      buffer += decoder.decode(value, { stream: true });
+      const parts = buffer.split(/(?:\r\n|\r|\n){2}/);
+      buffer = parts.pop() ?? "";
+      for (const part of parts) {
+        handlers.onEventBlock(part.trim());
+      }
+    }
+  } finally {
+    reader.releaseLock();
+  }
+}
+
 // src/billing/client.ts
 var INITIAL_RECONNECT_DELAY_MS = 1e3;
 var MAX_RECONNECT_DELAY_MS = 3e4;
-var RECONNECT_BACKOFF_MULTIPLIER = 2;
 var MAX_CONSECUTIVE_AUTH_FAILURES = 3;
+var STALE_CONNECTION_TIMEOUT_MS = 6e4;
+var BillingAuthStreamError = class extends Error {
+  constructor(status) {
+    super(`Billing SSE auth failed: ${status}`);
+    this.status = status;
+    this.name = "BillingAuthStreamError";
+  }
+};
+var BillingSubscriptionStream = class {
+  constructor(options, onClose) {
+    this.options = options;
+    this.onClose = onClose;
+    this.supervisor = new ConnectionSupervisor({
+      authRetryDelayMs: INITIAL_RECONNECT_DELAY_MS,
+      baseReconnectDelayMs: INITIAL_RECONNECT_DELAY_MS,
+      getToken: options.getToken,
+      id: `billing-${Math.random().toString(36).slice(2)}`,
+      isAuthError: (error) => error instanceof BillingAuthStreamError,
+      kind: "billing-sse",
+      maxConsecutiveAuthFailures: MAX_CONSECUTIVE_AUTH_FAILURES,
+      maxReconnectDelayMs: MAX_RECONNECT_DELAY_MS,
+      onFatalError: () => {
+        this.options.onError?.(
+          new DvinaAuthenticationError("Billing SSE stream authentication failed permanently")
+        );
+        this.close();
+      },
+      staleTimeoutMs: STALE_CONNECTION_TIMEOUT_MS,
+      dial: async (context) => {
+        const response = await fetch(this.options.billingSseUrl, {
+          method: "GET",
+          headers: {
+            Authorization: `Bearer ${context.token}`,
+            Accept: "text/event-stream",
+            "Cache-Control": "no-cache"
+          },
+          signal: context.signal
+        });
+        if (!response.ok) {
+          if (response.status === 401 || response.status === 403) {
+            throw new BillingAuthStreamError(response.status);
+          }
+          throw new Error(`Billing SSE failed: ${response.status} ${response.statusText}`);
+        }
+        if (!response.body) {
+          throw new Error("Billing SSE response has no body");
+        }
+        context.markConnected();
+        await consumeSseStream(response.body, context.signal, {
+          onChunk: () => context.markActivity(),
+          onEventBlock: (block2) => this.processEventBlock(block2, context.requestTokenRefresh)
+        });
+      }
+    });
+  }
+  abortFinished = false;
+  queue = [];
+  pendingResolve = null;
+  supervisor;
+  start() {
+    void this.supervisor.start();
+  }
+  reconnect() {
+    if (this.abortFinished) {
+      return;
+    }
+    this.supervisor.reconnect();
+  }
+  next() {
+    if (this.queue.length > 0) {
+      return Promise.resolve({ value: this.queue.shift(), done: false });
+    }
+    if (this.abortFinished) {
+      return Promise.resolve({ value: void 0, done: true });
+    }
+    return new Promise((resolve) => {
+      this.pendingResolve = resolve;
+    });
+  }
+  return() {
+    this.close();
+    return Promise.resolve({ value: void 0, done: true });
+  }
+  [Symbol.asyncIterator]() {
+    return this;
+  }
+  close() {
+    if (this.abortFinished) {
+      return;
+    }
+    this.abortFinished = true;
+    this.supervisor.close();
+    if (this.pendingResolve) {
+      this.pendingResolve({ value: void 0, done: true });
+      this.pendingResolve = null;
+    }
+    this.onClose(this);
+  }
+  push(value) {
+    if (this.abortFinished) {
+      return;
+    }
+    if (this.pendingResolve) {
+      this.pendingResolve({ value, done: false });
+      this.pendingResolve = null;
+      return;
+    }
+    this.queue.length = 0;
+    this.queue.push(value);
+  }
+  processEventBlock(block2, requestTokenRefresh) {
+    if (!block2 || block2.startsWith(":")) {
+      return;
+    }
+    let eventType;
+    const dataLines = [];
+    for (const line of block2.split(/\r\n|\r|\n/)) {
+      if (line.startsWith("event: ")) {
+        eventType = line.slice(7).trim();
+      } else if (line.startsWith("data: ")) {
+        dataLines.push(line.slice(6));
+      }
+    }
+    if (eventType === "token-expired") {
+      requestTokenRefresh();
+      throw new BillingAuthStreamError(401);
+    }
+    if (eventType !== "subscription" || dataLines.length === 0) {
+      return;
+    }
+    try {
+      const parsed = JSON.parse(dataLines.join("\n"));
+      this.push(parsed);
+    } catch {
+    }
+  }
+};
 var BillingClient = class {
   http;
   options;
-  activeAbortControllers = /* @__PURE__ */ new Set();
+  activeUpdateStreams = /* @__PURE__ */ new Set();
   constructor(options) {
     this.options = options;
     this.http = createHttpTransport({
@@ -1026,12 +1469,16 @@ var BillingClient = class {
    * Call this on logout or SDK teardown to prevent lingering connections.
    */
   destroy() {
-    for (const controller of this.activeAbortControllers) {
-      controller.abort();
+    for (const stream of Array.from(this.activeUpdateStreams)) {
+      stream.close();
+    }
+    this.activeUpdateStreams.clear();
+  }
+  reconnectAll() {
+    for (const stream of this.activeUpdateStreams) {
+      stream.reconnect();
     }
-    this.activeAbortControllers.clear();
   }
-  // ─── Plans ───────────────────────────────────────────────────────────────
   get plans() {
     return {
       list: async () => {
@@ -1052,7 +1499,6 @@ var BillingClient = class {
       }
     };
   }
-  // ─── Subscription ────────────────────────────────────────────────────────
   get subscription() {
     return {
       get: async () => {
@@ -1091,17 +1537,16 @@ var BillingClient = class {
         const result = await this.request(ReleaseScheduleDocument);
         return result.releaseSchedule;
       },
-      /**
-       * Subscribe to real-time subscription updates via SSE.
-       * Returns an AsyncIterable that yields WorkspaceSubscription snapshots.
-       * Automatically reconnects with exponential backoff and token refresh on auth errors.
-       */
       updates: () => {
-        return this.createSseStream();
+        const stream = new BillingSubscriptionStream(this.options, (closedStream) => {
+          this.activeUpdateStreams.delete(closedStream);
+        });
+        this.activeUpdateStreams.add(stream);
+        stream.start();
+        return stream;
       }
     };
   }
-  // ─── Seats ───────────────────────────────────────────────────────────────
   get seats() {
     return {
       add: async (variables) => {
@@ -1114,7 +1559,6 @@ var BillingClient = class {
       }
     };
   }
-  // ─── Sessions ────────────────────────────────────────────────────────────
   get session() {
     return {
       createSession: async (variables) => {
@@ -1127,7 +1571,6 @@ var BillingClient = class {
       }
     };
   }
-  // ─── Management ──────────────────────────────────────────────────────────
   get management() {
     return {
       subscription: async (variables) => {
@@ -1152,192 +1595,11 @@ var BillingClient = class {
       }
     };
   }
-  // ─── Private ─────────────────────────────────────────────────────────────
   request(document, variables) {
     return this.http.request(document, variables);
   }
-  /**
-   * Create an SSE stream that connects to the billing SSE endpoint.
-   * Reconnects automatically with exponential backoff.
-   * On 401/403, refreshes the token and retries with a short delay.
-   */
-  createSseStream() {
-    const options = this.options;
-    const activeAbortControllers = this.activeAbortControllers;
-    return {
-      [Symbol.asyncIterator]() {
-        const queue = [];
-        let resolve = null;
-        let done = false;
-        let abortController;
-        let reconnectTimer;
-        let reconnectDelay = INITIAL_RECONNECT_DELAY_MS;
-        let shouldReconnect = true;
-        let needsForceRefresh = false;
-        let consecutiveAuthFailures = 0;
-        function push(value) {
-          if (resolve) {
-            resolve({ value, done: false });
-            resolve = null;
-          } else {
-            queue.length = 0;
-            queue.push(value);
-          }
-        }
-        async function connect() {
-          if (!shouldReconnect) return;
-          if (abortController) {
-            activeAbortControllers.delete(abortController);
-          }
-          abortController = new AbortController();
-          activeAbortControllers.add(abortController);
-          try {
-            const forceRefresh = needsForceRefresh;
-            needsForceRefresh = false;
-            const token = await options.getToken(forceRefresh ? { forceRefresh: true } : void 0);
-            const response = await fetch(options.billingSseUrl, {
-              method: "GET",
-              headers: {
-                Authorization: `Bearer ${token}`,
-                Accept: "text/event-stream",
-                "Cache-Control": "no-cache"
-              },
-              signal: abortController.signal
-            });
-            if (!response.ok) {
-              if (response.status === 401 || response.status === 403) {
-                consecutiveAuthFailures++;
-                if (consecutiveAuthFailures >= MAX_CONSECUTIVE_AUTH_FAILURES) {
-                  done = true;
-                  shouldReconnect = false;
-                  options.onError?.(
-                    new DvinaAuthenticationError(
-                      "Billing SSE stream authentication failed permanently"
-                    )
-                  );
-                  if (resolve) {
-                    resolve({ value: void 0, done: true });
-                    resolve = null;
-                  }
-                  return;
-                }
-                needsForceRefresh = true;
-                scheduleReconnect(INITIAL_RECONNECT_DELAY_MS);
-                return;
-              }
-              throw new Error(`Billing SSE failed: ${response.status} ${response.statusText}`);
-            }
-            if (!response.body) {
-              throw new Error("Billing SSE response has no body");
-            }
-            consecutiveAuthFailures = 0;
-            reconnectDelay = INITIAL_RECONNECT_DELAY_MS;
-            await parseSseStream(response.body, abortController.signal);
-          } catch (err) {
-            if (err.name === "AbortError") return;
-            if (shouldReconnect) {
-              scheduleReconnect(reconnectDelay);
-              reconnectDelay = Math.min(
-                reconnectDelay * RECONNECT_BACKOFF_MULTIPLIER,
-                MAX_RECONNECT_DELAY_MS
-              );
-            }
-          }
-        }
-        async function parseSseStream(body, signal) {
-          const reader = body.getReader();
-          const decoder = new TextDecoder();
-          let buffer = "";
-          try {
-            while (!signal.aborted && shouldReconnect) {
-              const { done: streamDone, value } = await reader.read();
-              if (streamDone) break;
-              buffer += decoder.decode(value, { stream: true });
-              const parts = buffer.split(/(?:\r\n|\r|\n){2}/);
-              buffer = parts.pop() ?? "";
-              for (const part of parts) {
-                processEventBlock(part.trim());
-              }
-            }
-          } finally {
-            reader.releaseLock();
-          }
-          if (shouldReconnect) {
-            scheduleReconnect(reconnectDelay);
-          }
-        }
-        function processEventBlock(block2) {
-          if (!block2 || block2.startsWith(":")) return;
-          let eventType;
-          let eventData;
-          for (const line of block2.split(/\r\n|\r|\n/)) {
-            if (line.startsWith("event: ")) {
-              eventType = line.slice(7).trim();
-            } else if (line.startsWith("data: ")) {
-              eventData = line.slice(6);
-            }
-          }
-          if (eventType === "token-expired") {
-            needsForceRefresh = true;
-            return;
-          }
-          if (eventType === "subscription" && eventData) {
-            try {
-              const parsed = JSON.parse(eventData);
-              push(parsed);
-            } catch {
-            }
-          }
-        }
-        function scheduleReconnect(delay) {
-          if (!shouldReconnect) return;
-          reconnectTimer = setTimeout(() => {
-            connect();
-          }, delay);
-        }
-        connect();
-        return {
-          next() {
-            if (queue.length > 0) {
-              return Promise.resolve({ value: queue.shift(), done: false });
-            }
-            if (done) {
-              return Promise.resolve({
-                value: void 0,
-                done: true
-              });
-            }
-            return new Promise((r) => {
-              resolve = r;
-            });
-          },
-          return() {
-            shouldReconnect = false;
-            done = true;
-            if (reconnectTimer) {
-              clearTimeout(reconnectTimer);
-              reconnectTimer = void 0;
-            }
-            if (abortController) {
-              activeAbortControllers.delete(abortController);
-              abortController.abort();
-              abortController = void 0;
-            }
-            if (resolve) {
-              resolve({ value: void 0, done: true });
-              resolve = null;
-            }
-            return Promise.resolve({ value: void 0, done: true });
-          },
-          [Symbol.asyncIterator]() {
-            return this;
-          }
-        };
-      }
-    };
-  }
 };
 
-export { BillingClient, EntitlementTier, Kind, SubscriptionCycle, SubscriptionProvider, createHttpTransport, print };
-//# sourceMappingURL=chunk-5TAY5I34.js.map
-//# sourceMappingURL=chunk-5TAY5I34.js.map
+export { BillingClient, ConnectionSupervisor, EntitlementTier, Kind, SubscriptionCycle, SubscriptionProvider, consumeSseStream, createHttpTransport, print, refreshTokenSingleFlight };
+//# sourceMappingURL=chunk-Q5XGHH7D.js.map
+//# sourceMappingURL=chunk-Q5XGHH7D.js.map