@sentry/api 1.0.0 → 1.1.0

package/dist/api-client/index.js

@@ -1,38 +1,39 @@
 // src/api-client/errors.ts
 import { SentryApiError } from "@sentry/api";
-
-class UserInputError extends Error {
+var UserInputError = class extends Error {
   constructor(message, options) {
     super(message, options);
     this.name = "UserInputError";
   }
-}
-
-class ConfigurationError extends Error {
+};
+var ConfigurationError = class extends Error {
   constructor(message, options) {
     super(message, options);
     this.name = "ConfigurationError";
   }
-}
-
-class ApiError extends SentryApiError {
-  detail;
-  responseBody;
-  constructor(message, status, detail, responseBody) {
-    super(status, responseBody, undefined, false, message);
+};
+var ApiError = class _ApiError extends SentryApiError {
+  constructor(message, status, detail, responseBody2) {
+    super(status, responseBody2, void 0, false, message);
     this.detail = detail;
-    this.responseBody = responseBody;
+    this.responseBody = responseBody2;
     this.name = "ApiError";
-    Object.setPrototypeOf(this, ApiError.prototype);
+    Object.setPrototypeOf(this, _ApiError.prototype);
   }
-}
-
-class ApiClientError extends ApiError {
-  constructor(message, status, detail, responseBody) {
-    super(message, status, detail, responseBody);
+  detail;
+  responseBody;
+};
+var ApiClientError = class _ApiClientError extends ApiError {
+  constructor(message, status, detail, responseBody2) {
+    super(message, status, detail, responseBody2);
     this.name = "ApiClientError";
-    Object.setPrototypeOf(this, ApiClientError.prototype);
+    Object.setPrototypeOf(this, _ApiClientError.prototype);
   }
+  /**
+   * Convert to a user-friendly formatted message.
+   * Returns the standard format: "API error (status): message" or just "API error: message" if no status.
+   * For 404 errors, adds helpful context about checking parameters.
+   */
   toUserMessage() {
     const baseMessage = this.status ? `API error (${this.status}): ${this.message}` : `API error: ${this.message}`;
     if (this.status === 404) {
@@ -42,7 +43,9 @@ class ApiClientError extends ApiError {
         "resource does not exist",
         "resource not found"
       ];
-      const isGeneric = genericMessages.some((msg) => this.message.toLowerCase() === msg || this.message.toLowerCase().includes("requested resource"));
+      const isGeneric = genericMessages.some(
+        (msg) => this.message.toLowerCase() === msg || this.message.toLowerCase().includes("requested resource")
+      );
       if (isGeneric) {
         return `${baseMessage}. Please verify that the organization, project, or resource ID is correct and that you have access to it.`;
       }
@@ -50,134 +53,160 @@ class ApiClientError extends ApiError {
     }
     return baseMessage;
   }
+  /**
+   * Check if this is a permission/authorization error (403)
+   */
   isPermissionError() {
     return this.status === 403;
   }
+  /**
+   * Check if this is a not found error (404)
+   */
   isNotFoundError() {
     return this.status === 404;
   }
+  /**
+   * Check if this is a validation error (400 or 422)
+   */
   isValidationError() {
     return this.status === 400 || this.status === 422;
   }
+  /**
+   * Check if this is an authentication error (401)
+   */
   isAuthenticationError() {
     return this.status === 401;
   }
+  /**
+   * Check if this is a rate limit error (429)
+   */
   isRateLimitError() {
     return this.status === 429;
   }
-}
-
-class ApiPermissionError extends ApiClientError {
-  constructor(message, detail, responseBody) {
-    super(message, 403, detail, responseBody);
+};
+var ApiPermissionError = class _ApiPermissionError extends ApiClientError {
+  constructor(message, detail, responseBody2) {
+    super(message, 403, detail, responseBody2);
     this.name = "ApiPermissionError";
-    Object.setPrototypeOf(this, ApiPermissionError.prototype);
+    Object.setPrototypeOf(this, _ApiPermissionError.prototype);
   }
+  /**
+   * Check if this is the specific multi-project access error
+   */
   isMultiProjectAccessError() {
-    return this.message.includes("multiple projects") || this.message.includes("multi project") || this.message.includes("multi-project") || this.message.includes("You do not have access to query across multiple projects");
+    return this.message.includes("multiple projects") || this.message.includes("multi project") || this.message.includes("multi-project") || this.message.includes(
+      "You do not have access to query across multiple projects"
+    );
   }
-}
-
-class ApiNotFoundError extends ApiClientError {
-  resourceType;
-  resourceId;
-  constructor(message, detail, responseBody, resourceType, resourceId) {
-    super(message, 404, detail, responseBody);
+};
+var ApiNotFoundError = class _ApiNotFoundError extends ApiClientError {
+  constructor(message, detail, responseBody2, resourceType, resourceId) {
+    super(message, 404, detail, responseBody2);
     this.resourceType = resourceType;
     this.resourceId = resourceId;
     this.name = "ApiNotFoundError";
-    Object.setPrototypeOf(this, ApiNotFoundError.prototype);
+    Object.setPrototypeOf(this, _ApiNotFoundError.prototype);
   }
-}
-
-class ApiValidationError extends ApiClientError {
-  validationErrors;
-  constructor(message, status, detail, responseBody, validationErrors) {
-    super(message, status, detail, responseBody);
+  resourceType;
+  resourceId;
+};
+var ApiValidationError = class _ApiValidationError extends ApiClientError {
+  constructor(message, status, detail, responseBody2, validationErrors) {
+    super(message, status, detail, responseBody2);
     this.validationErrors = validationErrors;
     this.name = "ApiValidationError";
-    Object.setPrototypeOf(this, ApiValidationError.prototype);
+    Object.setPrototypeOf(this, _ApiValidationError.prototype);
   }
-}
-
-class ApiAuthenticationError extends ApiClientError {
-  constructor(message, detail, responseBody) {
-    super(message, 401, detail, responseBody);
+  validationErrors;
+};
+var ApiAuthenticationError = class _ApiAuthenticationError extends ApiClientError {
+  constructor(message, detail, responseBody2) {
+    super(message, 401, detail, responseBody2);
     this.name = "ApiAuthenticationError";
-    Object.setPrototypeOf(this, ApiAuthenticationError.prototype);
+    Object.setPrototypeOf(this, _ApiAuthenticationError.prototype);
   }
-}
-
-class ApiRateLimitError extends ApiClientError {
-  retryAfterMs;
-  constructor(message, detail, responseBody, retryAfterMs) {
-    super(message, 429, detail, responseBody);
+};
+var ApiRateLimitError = class _ApiRateLimitError extends ApiClientError {
+  constructor(message, detail, responseBody2, retryAfterMs) {
+    super(message, 429, detail, responseBody2);
     this.retryAfterMs = retryAfterMs;
     this.name = "ApiRateLimitError";
-    Object.setPrototypeOf(this, ApiRateLimitError.prototype);
+    Object.setPrototypeOf(this, _ApiRateLimitError.prototype);
   }
+  retryAfterMs;
   toUserMessage() {
-    if (this.retryAfterMs === undefined) {
+    if (this.retryAfterMs === void 0) {
       return `${super.toUserMessage()}. Retry in a few seconds.`;
     }
-    const seconds = Math.max(1, Math.ceil(this.retryAfterMs / 1000));
+    const seconds = Math.max(1, Math.ceil(this.retryAfterMs / 1e3));
     return `${super.toUserMessage()}. Retry in ${seconds} second${seconds === 1 ? "" : "s"}.`;
   }
-}
-
-class ApiServerError extends ApiError {
-  constructor(message, status, detail, responseBody) {
-    super(message, status, detail, responseBody);
+};
+var ApiServerError = class _ApiServerError extends ApiError {
+  constructor(message, status, detail, responseBody2) {
+    super(message, status, detail, responseBody2);
     this.name = "ApiServerError";
-    Object.setPrototypeOf(this, ApiServerError.prototype);
+    Object.setPrototypeOf(this, _ApiServerError.prototype);
   }
+  /**
+   * Check if this is a gateway/proxy error (502, 503, 504)
+   */
   isGatewayError() {
     return this.status === 502 || this.status === 503 || this.status === 504;
   }
+  /**
+   * Check if this is an internal server error (500)
+   */
   isInternalError() {
     return this.status === 500;
   }
-}
-function createApiError(message, status, detail, responseBody, retryAfterMs) {
+};
+function createApiError(message, status, detail, responseBody2, retryAfterMs) {
   let improvedMessage = message;
-  if (message.includes("You do not have the multi project stream feature enabled") || message.includes("You cannot view events from multiple projects")) {
+  if (message.includes(
+    "You do not have the multi project stream feature enabled"
+  ) || message.includes("You cannot view events from multiple projects")) {
     improvedMessage = "You do not have access to query across multiple projects. Please select a project for your query.";
-    return new ApiPermissionError(improvedMessage, detail, responseBody);
+    return new ApiPermissionError(improvedMessage, detail, responseBody2);
   }
   switch (status) {
     case 401:
-      return new ApiAuthenticationError(message, detail, responseBody);
+      return new ApiAuthenticationError(message, detail, responseBody2);
     case 403:
-      return new ApiPermissionError(message, detail, responseBody);
+      return new ApiPermissionError(message, detail, responseBody2);
     case 404:
-      return new ApiNotFoundError(message, detail, responseBody);
+      return new ApiNotFoundError(message, detail, responseBody2);
     case 400:
     case 422: {
       let validationErrors;
-      if (responseBody && typeof responseBody === "object" && "errors" in responseBody) {
-        validationErrors = responseBody.errors;
+      if (responseBody2 && typeof responseBody2 === "object" && "errors" in responseBody2) {
+        validationErrors = responseBody2.errors;
       }
-      return new ApiValidationError(message, status, detail, responseBody, validationErrors);
+      return new ApiValidationError(
+        message,
+        status,
+        detail,
+        responseBody2,
+        validationErrors
+      );
     }
     case 429:
-      return new ApiRateLimitError(message, detail, responseBody, retryAfterMs);
+      return new ApiRateLimitError(message, detail, responseBody2, retryAfterMs);
     default:
       if (status >= 400 && status < 500) {
-        return new ApiClientError(message, status, detail, responseBody);
+        return new ApiClientError(message, status, detail, responseBody2);
       }
       if (status >= 500 && status < 600) {
-        return new ApiServerError(message, status, detail, responseBody);
+        return new ApiServerError(message, status, detail, responseBody2);
       }
-      return new ApiError(message, status, detail, responseBody);
+      return new ApiError(message, status, detail, responseBody2);
   }
 }
 function isApiAuthenticationErrorDeep(error) {
   let current = error;
-  for (let i = 0;i < 3; i++) {
-    if (current instanceof ApiAuthenticationError)
-      return true;
-    if (!(current instanceof Error))
-      return false;
+  for (let i = 0; i < 3; i++) {
+    if (current instanceof ApiAuthenticationError) return true;
+    if (!(current instanceof Error)) return false;
     current = current.cause;
   }
   return false;
@@ -204,7 +233,9 @@ function apiPath(strings, ...values) {
     const value = String(values[index]);
     const encoded = encodeApiPathSegment(value);
     if (encoded === null) {
-      throw new UserInputError(`Invalid identifier "${value}": relative path segments are not allowed.`);
+      throw new UserInputError(
+        `Invalid identifier "${value}": relative path segments are not allowed.`
+      );
     }
     return acc + literal + encoded;
   }, "");
@@ -213,6 +244,7 @@ function withQuery(path, query) {
   const queryString = query.toString();
   return queryString ? `${path}?${queryString}` : path;
 }
+
 // src/api-client/auth-token.ts
 var INVALID_TOKEN_CHARACTER_PATTERN = /[^\x21-\x7e]/;
 var TOKEN_PADDING_PATTERN = /[\s\x00-\x1f\x7f]/;
@@ -235,6 +267,7 @@ function sentryBearerHeader(token) {
   const normalized = normalizeAuthToken(token);
   return normalized === null ? null : `Bearer ${normalized}`;
 }
+
 // src/api-client/core.ts
 import {
   createSentryClient,
@@ -259,9 +292,10 @@ function encodePageCursor(cursor, skip) {
   const next = skip > 0 ? NEXT_CURSOR_RE.exec(server) : null;
   return next ? `${next[1]}:${encodeSkip(skip)}` : server;
 }
-function decodePageCursor(raw, warn = () => {}) {
+function decodePageCursor(raw, warn = () => {
+}) {
   if (!raw) {
-    return { cursor: undefined, skip: 0 };
+    return { cursor: void 0, skip: 0 };
   }
   if (raw.startsWith(CLI_CURSOR_PREFIX)) {
     return decodeCliCursor(raw, warn);
@@ -269,72 +303,86 @@ function decodePageCursor(raw, warn = () => {}) {
   const next = NEXT_CURSOR_RE.exec(raw);
   const cursor = next ? `${next[1]}:0` : raw;
   const position = {
-    cursor: cursor === FIRST_PAGE_CURSOR ? undefined : cursor,
+    cursor: cursor === FIRST_PAGE_CURSOR ? void 0 : cursor,
     skip: next?.[2] ? decodeSkip(next[2]) : 0
   };
   const perPage = serverCursorPageSize(cursor);
-  return perPage === undefined ? position : { ...position, perPage };
+  return perPage === void 0 ? position : { ...position, perPage };
 }
 function decodeCliCursor(raw, warn) {
   const [perPage, skip, ...server] = raw.slice(CLI_CURSOR_PREFIX.length).split("~");
   const position = {
     perPage: Number(perPage),
     skip: Number(skip),
-    cursor: server.join("~") || undefined
+    cursor: server.join("~") || void 0
   };
   if (Number.isInteger(position.perPage) && position.perPage >= 1 && position.perPage <= API_MAX_PER_PAGE && Number.isInteger(position.skip) && position.skip >= 0) {
     return position;
   }
-  warn("Ignoring an unreadable pagination cursor; starting from the first page.");
-  return { cursor: undefined, skip: 0 };
-}
-function consumeCursorPage(page, position, limit = Number.POSITIVE_INFINITY) {
-  const consumed = consumePage({ data: page.data, nextCursor: page.nextCursor || undefined }, { cursor: position.cursor, offset: position.skip }, limit);
+  warn(
+    "Ignoring an unreadable pagination cursor; starting from the first page."
+  );
+  return { cursor: void 0, skip: 0 };
+}
+function consumeCursorPage(page, position, limit2 = Number.POSITIVE_INFINITY) {
+  const consumed = consumePage(
+    { data: page.data, nextCursor: page.nextCursor || void 0 },
+    { cursor: position.cursor, offset: position.skip },
+    limit2
+  );
   return {
     ...page,
     data: consumed.data,
-    nextCursor: consumed.position ? encodePageCursor(consumed.position.cursor, consumed.position.offset) : undefined
+    nextCursor: consumed.position ? encodePageCursor(consumed.position.cursor, consumed.position.offset) : void 0
   };
 }
 function serverCursorPageSize(cursor) {
   const value = Number(PAGE_NUMBER_CURSOR_RE.exec(cursor)?.[1]);
-  return Number.isInteger(value) && value >= 1 && value <= API_MAX_PER_PAGE ? value : undefined;
+  return Number.isInteger(value) && value >= 1 && value <= API_MAX_PER_PAGE ? value : void 0;
 }
-function pageSizeForLimit(limit) {
-  if (limit <= API_MAX_PER_PAGE) {
-    return Math.max(1, limit);
+function pageSizeForLimit(limit2) {
+  if (limit2 <= API_MAX_PER_PAGE) {
+    return Math.max(1, limit2);
   }
-  return Math.ceil(limit / Math.ceil(limit / API_MAX_PER_PAGE));
+  return Math.ceil(limit2 / Math.ceil(limit2 / API_MAX_PER_PAGE));
 }
 async function paginate(options, fetchPage) {
-  const { limit, maxPages, warn = () => {} } = options;
+  const { limit: limit2, maxPages, warn = () => {
+  } } = options;
   const position = decodePageCursor(options.cursor, warn);
-  const perPage = position.perPage ?? pageSizeForLimit(limit + position.skip);
-  const result = await paginateUpTo(async (cursor) => {
-    const page = await fetchPage(perPage, cursor);
-    return { data: page.data, nextCursor: page.nextCursor || undefined };
-  }, {
-    limit,
-    maxPages,
-    resume: {
-      cursor: position.cursor,
-      offset: position.skip,
-      requestBudget: limit + position.skip
-    }
-  }, "paginate");
+  const perPage = position.perPage ?? pageSizeForLimit(limit2 + position.skip);
+  const result = await paginateUpTo(
+    async (cursor) => {
+      const page = await fetchPage(perPage, cursor);
+      return { data: page.data, nextCursor: page.nextCursor || void 0 };
+    },
+    {
+      limit: limit2,
+      maxPages,
+      resume: {
+        cursor: position.cursor,
+        offset: position.skip,
+        requestBudget: limit2 + position.skip
+      }
+    },
+    "paginate"
+  );
   return {
     data: result.data,
     ...result.continuation ? {
-      nextCursor: encodePageCursor(result.continuation.cursor, result.continuation.offset)
+      nextCursor: encodePageCursor(
+        result.continuation.cursor,
+        result.continuation.offset
+      )
     } : {},
     stoppedAtPageCap: result.stopReason === "maxPages"
   };
 }
 async function fetchAllPages(fetchPage, parse, maxPages) {
   const items = [];
-  const seen = new Set;
+  const seen = /* @__PURE__ */ new Set();
   let cursor;
-  for (let page = 0;page < maxPages; page += 1) {
+  for (let page = 0; page < maxPages; page += 1) {
     const { data, nextCursor } = await fetchPage(cursor);
     const rows = parse(data);
     if (!rows) {
@@ -354,25 +402,25 @@ async function fetchAllPages(fetchPage, parse, maxPages) {
 }
 
 // src/api-client/retry.ts
-var IDEMPOTENT_METHODS = new Set([
+var IDEMPOTENT_METHODS = /* @__PURE__ */ new Set([
   "GET",
   "HEAD",
   "OPTIONS"
 ]);
-var RETRYABLE_STATUSES = new Map([
+var RETRYABLE_STATUSES = /* @__PURE__ */ new Map([
   [429, "any"],
   [500, "idempotent"],
   [502, "idempotent"],
   [503, "idempotent"],
   [504, "idempotent"]
 ]);
-var DATE_RESOLUTION_MS = 1000;
+var DATE_RESOLUTION_MS = 1e3;
 function isIdempotentRequest(method, idempotent = false) {
   return idempotent || IDEMPOTENT_METHODS.has(method.toUpperCase());
 }
 function isRetryable(method, status, idempotent = false) {
-  const replays = status === undefined ? "idempotent" : RETRYABLE_STATUSES.get(status);
-  if (replays === undefined) {
+  const replays = status === void 0 ? "idempotent" : RETRYABLE_STATUSES.get(status);
+  if (replays === void 0) {
     return false;
   }
   return replays === "any" || isIdempotentRequest(method, idempotent);
@@ -381,19 +429,19 @@ function parseRetryDelayMs(status, headers, now = Date.now()) {
   const retryAfter = headers.get("retry-after")?.trim();
   if (retryAfter) {
     if (/^\d+$/.test(retryAfter)) {
-      return Number(retryAfter) * 1000;
+      return Number(retryAfter) * 1e3;
     }
     const date = Date.parse(retryAfter);
-    return Number.isNaN(date) ? undefined : delayUntil(date, headers, now);
+    return Number.isNaN(date) ? void 0 : delayUntil(date, headers, now);
   }
   if (status !== 429 || !isWindowLimited(headers)) {
-    return;
+    return void 0;
   }
   const reset = Number(headers.get("x-sentry-rate-limit-reset"));
   if (!Number.isFinite(reset) || reset <= 0) {
-    return;
+    return void 0;
   }
-  return delayUntil(reset * 1000, headers, now);
+  return delayUntil(reset * 1e3, headers, now);
 }
 function nextRetryDelayMs({
   policy,
@@ -406,19 +454,19 @@ function nextRetryDelayMs({
   random = Math.random
 }) {
   if (attempt >= policy.maxRetries || !isRetryable(method, status, idempotent)) {
-    return;
+    return void 0;
   }
   let delayMs;
-  if (serverDelayMs !== undefined) {
+  if (serverDelayMs !== void 0) {
     if (serverDelayMs > policy.maxDelayMs) {
-      return;
+      return void 0;
     }
     delayMs = serverDelayMs + random() * (policy.baseDelayMs / 2);
   } else {
     const step = Math.min(policy.baseDelayMs * 2 ** attempt, policy.maxDelayMs);
     delayMs = step / 2 + random() * (step / 2);
   }
-  return waitedMs + delayMs > policy.maxTotalDelayMs ? undefined : delayMs;
+  return waitedMs + delayMs > policy.maxTotalDelayMs ? void 0 : delayMs;
 }
 function sleep(ms, signal) {
   return new Promise((resolve, reject) => {
@@ -453,9 +501,9 @@ function isWindowLimited(headers) {
 // src/api-client/response.ts
 function readDetail(json) {
   if (json === null || typeof json !== "object" || !("detail" in json)) {
-    return;
+    return void 0;
   }
-  return typeof json.detail === "string" ? json.detail : undefined;
+  return typeof json.detail === "string" ? json.detail : void 0;
 }
 function looksLikeHtml(text) {
   return text.includes("<!DOCTYPE") || text.includes("<html");
@@ -466,7 +514,7 @@ async function readErrorResponse(response) {
   try {
     text = await response.text();
   } catch {
-    return { text: undefined, isHtml: false, retryAfterMs };
+    return { text: void 0, isHtml: false, retryAfterMs };
   }
   try {
     const json = JSON.parse(text);
@@ -494,24 +542,31 @@ async function readJsonResponse(response) {
   if (!contentType?.includes("application/json")) {
     const text = await response.text();
     if (contentType?.includes("text/html") || looksLikeHtml(text)) {
-      throw new Error(`Expected JSON response but received HTML (${response.status} ${response.statusText}). This may indicate you're not authenticated, the URL is incorrect, or there's a server issue.`);
+      throw new Error(
+        `Expected JSON response but received HTML (${response.status} ${response.statusText}). This may indicate you're not authenticated, the URL is incorrect, or there's a server issue.`
+      );
     }
-    throw new Error(`Expected JSON response but received ${contentType || "unknown content type"} ` + `(${response.status} ${response.statusText})`);
+    throw new Error(
+      `Expected JSON response but received ${contentType || "unknown content type"} (${response.status} ${response.statusText})`
+    );
   }
   try {
     return await response.json();
   } catch (error) {
-    throw new Error(`Failed to parse JSON response: ${error instanceof Error ? error.message : String(error)}`);
+    throw new Error(
+      `Failed to parse JSON response: ${error instanceof Error ? error.message : String(error)}`
+    );
   }
 }
 
 // src/api-client/validate.ts
 var MAX_LISTED_ISSUES = 3;
 function issuePath(issue) {
-  return (issue.path ?? []).map((segment) => String(typeof segment === "object" ? segment.key : segment)).join(".");
+  return (issue.path ?? []).map(
+    (segment) => String(typeof segment === "object" ? segment.key : segment)
+  ).join(".");
 }
-
-class ApiResponseValidationError extends Error {
+var ApiResponseValidationError = class extends Error {
   issues;
   constructor(issues) {
     const listed = issues.slice(0, MAX_LISTED_ISSUES).map((issue) => {
@@ -523,7 +578,7 @@ class ApiResponseValidationError extends Error {
     this.name = "ApiResponseValidationError";
     this.issues = issues;
   }
-}
+};
 function validateResponse(schema, data) {
   const result = schema["~standard"].validate(data);
   if (result instanceof Promise) {
@@ -548,7 +603,7 @@ var NETWORK_ERROR_MESSAGES = {
   ECONNRESET: "Connection reset. Try again in a moment."
 };
 var API_PREFIX = "/api/0";
-var CONFIGURATION_ERROR_CODES = new Set([
+var CONFIGURATION_ERROR_CODES = /* @__PURE__ */ new Set([
   "ENOTFOUND",
   "EAI_AGAIN",
   "ECONNREFUSED",
@@ -560,7 +615,9 @@ function networkError(url, error) {
     rootCause = rootCause.cause;
   }
   const errorMessage = rootCause instanceof Error ? rootCause.message : String(rootCause);
-  const errorCode = Object.keys(NETWORK_ERROR_MESSAGES).find((code) => errorMessage.includes(code));
+  const errorCode = Object.keys(NETWORK_ERROR_MESSAGES).find(
+    (code) => errorMessage.includes(code)
+  );
   const friendlyMessage = `Unable to connect to ${url} - ${errorCode ? NETWORK_ERROR_MESSAGES[errorCode] : errorMessage}`;
   if (errorCode && CONFIGURATION_ERROR_CODES.has(errorCode) || errorMessage.includes("Connect Timeout Error")) {
     return new ConfigurationError(friendlyMessage, { cause: error });
@@ -570,14 +627,20 @@ function networkError(url, error) {
 function errorFromResponse(logger, response, body, logExtra) {
   const { retryAfterMs } = body;
   const errorText = body.text ?? "";
-  const bodyPreview = errorText.length > 256 ? `${errorText.slice(0, 253)}…` : errorText;
-  if (body.parseError !== undefined) {
+  const bodyPreview = errorText.length > 256 ? `${errorText.slice(0, 253)}\u2026` : errorText;
+  if (body.parseError !== void 0) {
     if (body.isHtml) {
       logger.warn("Received HTML error page instead of JSON", {
         ...logExtra,
         parseErrorMessage: body.parseError
       });
-      return createApiError(`Server error: Received HTML instead of JSON (${response.status} ${response.statusText}). This may indicate an invalid URL or server issue.`, response.status, errorText, undefined, retryAfterMs);
+      return createApiError(
+        `Server error: Received HTML instead of JSON (${response.status} ${response.statusText}). This may indicate an invalid URL or server issue.`,
+        response.status,
+        errorText,
+        void 0,
+        retryAfterMs
+      );
     }
     logger.warn("Failed to parse JSON error response", {
       ...logExtra,
@@ -585,8 +648,14 @@ function errorFromResponse(logger, response, body, logExtra) {
       parseErrorMessage: body.parseError
     });
   } else if (body.json) {
-    if (body.detail !== undefined) {
-      return createApiError(body.detail, response.status, body.detail, body.json, retryAfterMs);
+    if (body.detail !== void 0) {
+      return createApiError(
+        body.detail,
+        response.status,
+        body.detail,
+        body.json,
+        retryAfterMs
+      );
     }
     logger.warn("Failed to parse validated API error response", {
       ...logExtra,
@@ -594,8 +663,14 @@ function errorFromResponse(logger, response, body, logExtra) {
       validationErrorMessage: "Error response has no string detail"
     });
   }
-  return createApiError(`API request failed: ${response.statusText}
-${errorText}`, response.status, errorText, undefined, retryAfterMs);
+  return createApiError(
+    `API request failed: ${response.statusText}
+${errorText}`,
+    response.status,
+    errorText,
+    void 0,
+    retryAfterMs
+  );
 }
 function createApiClientCore({
   transport,
@@ -609,7 +684,9 @@ function createApiClientCore({
       ...headers()
     };
     if (typeof globalThis.fetch === "undefined") {
-      throw new ConfigurationError("fetch is not available. Please use Node.js >= 18 or ensure fetch is available in your environment.");
+      throw new ConfigurationError(
+        "fetch is not available. Please use Node.js >= 18 or ensure fetch is available in your environment."
+      );
     }
     let response;
     try {
@@ -626,12 +703,17 @@ function createApiClientCore({
     if (response.ok || allowStatuses?.includes(response.status)) {
       return response;
     }
-    throw errorFromResponse(logger, response, await readErrorResponse(response), {
-      status: response.status,
-      statusText: response.statusText,
-      host: new URL(origin).host,
-      path
-    });
+    throw errorFromResponse(
+      logger,
+      response,
+      await readErrorResponse(response),
+      {
+        status: response.status,
+        statusText: response.statusText,
+        host: new URL(origin).host,
+        path
+      }
+    );
   }
   return {
     request,
@@ -646,9 +728,15 @@ function createApiClientCore({
         }
         const url = new URL(sdkRequest.url);
         if (url.origin !== base || url.pathname !== API_PREFIX.concat(expectedPath) || sdkRequest.method !== "GET") {
-          throw new ConfigurationError("Unexpected SDK request target or method");
+          throw new ConfigurationError(
+            "Unexpected SDK request target or method"
+          );
         }
-        const response = await request(origin, `${url.pathname.slice(API_PREFIX.length)}${url.search}`, { method: "GET", signal: sdkRequest.signal });
+        const response = await request(
+          origin,
+          `${url.pathname.slice(API_PREFIX.length)}${url.search}`,
+          { method: "GET", signal: sdkRequest.signal }
+        );
         const contentType = response.headers.get("content-type");
         if (!contentType?.includes("application/json")) {
           await readJsonResponse(response);
@@ -659,15 +747,17 @@ function createApiClientCore({
     }
   };
 }
-async function listPage(fetchPage, schema, limit, initialCursor) {
-  if (!Number.isSafeInteger(limit) || limit < 1 || limit > API_MAX_PER_PAGE * MAX_LIST_PAGES) {
-    throw new ApiValidationError(`limit must be an integer between 1 and ${API_MAX_PER_PAGE * MAX_LIST_PAGES}`);
+async function listPage(fetchPage, schema, limit2, initialCursor) {
+  if (!Number.isSafeInteger(limit2) || limit2 < 1 || limit2 > API_MAX_PER_PAGE * MAX_LIST_PAGES) {
+    throw new ApiValidationError(
+      `limit must be an integer between 1 and ${API_MAX_PER_PAGE * MAX_LIST_PAGES}`
+    );
   }
   const items = [];
-  const seenCursors = new Set;
-  let cursor = initialCursor ?? undefined;
-  for (let page = 0;page < MAX_LIST_PAGES; page += 1) {
-    const perPage = Math.min(API_MAX_PER_PAGE, limit - items.length);
+  const seenCursors = /* @__PURE__ */ new Set();
+  let cursor = initialCursor ?? void 0;
+  for (let page = 0; page < MAX_LIST_PAGES; page += 1) {
+    const perPage = Math.min(API_MAX_PER_PAGE, limit2 - items.length);
     const { data, response } = await fetchPage(perPage, cursor);
     const rows = validateResponse(schema, data);
     if (rows.length > perPage) {
@@ -675,7 +765,7 @@ async function listPage(fetchPage, schema, limit, initialCursor) {
     }
     items.push(...rows);
     const nextCursor = nextPageCursor(response);
-    if (items.length >= limit || !nextCursor) {
+    if (items.length >= limit2 || !nextCursor) {
       return { items, nextCursor };
     }
     if (seenCursors.has(nextCursor) || nextCursor === cursor) {
@@ -686,14 +776,19 @@ async function listPage(fetchPage, schema, limit, initialCursor) {
   }
   throw new Error("API pagination exceeded its page limit");
 }
+
 // src/api-client/idempotent-operations.ts
 function selectIdempotentWrites(operations) {
-  return operations.filter((op) => op.idempotent && !isIdempotentRequest(op.method)).map((op) => ({ method: op.method, path: op.path })).sort((a, b) => a.path.localeCompare(b.path) || a.method.localeCompare(b.method));
+  return operations.filter((op) => op.idempotent && !isIdempotentRequest(op.method)).map((op) => ({ method: op.method, path: op.path })).sort(
+    (a, b) => a.path.localeCompare(b.path) || a.method.localeCompare(b.method)
+  );
 }
 var TEMPLATE_SEGMENT = /^\{[^/]+\}$/;
 var REGEXP_SPECIAL = /[.*+?^${}()|[\]\\]/g;
 function toMatcher({ method, path }) {
-  const source = path.split("/").map((segment) => TEMPLATE_SEGMENT.test(segment) ? "[^/]+" : segment.replace(REGEXP_SPECIAL, "\\$&")).join("/");
+  const source = path.split("/").map(
+    (segment) => TEMPLATE_SEGMENT.test(segment) ? "[^/]+" : segment.replace(REGEXP_SPECIAL, "\\$&")
+  ).join("/");
   return { method: method.toUpperCase(), pattern: new RegExp(`^${source}$`) };
 }
 function createIdempotentOperationMatcher(operations) {
@@ -711,25 +806,39 @@ function createIdempotentOperationMatcher(operations) {
     const normalized = apiPath2.endsWith("/") ? apiPath2 : `${apiPath2}/`;
     const upper = method.toUpperCase();
     matchers ??= operations().map(toMatcher);
-    return matchers.some((matcher) => matcher.method === upper && matcher.pattern.test(normalized));
+    return matchers.some(
+      (matcher) => matcher.method === upper && matcher.pattern.test(normalized)
+    );
   };
 }
+
 // src/api-client/response-cache/invalidation.ts
 var API_V0_SEGMENT = "/api/0/";
 var TRAILING_SLASH_RE = /\/$/;
 var SKIP_INVALIDATION_PATTERNS = [
+  // Sourcemap chunk upload + bundle assemble. Both are write-only in the
+  // sense that no GET endpoint reads cacheable state under these paths.
   /\/chunk-upload\//,
   /\/artifactbundle\/assemble\//
 ];
 var CROSS_ENDPOINT_RULES = [
+  // `POST teams/{org}/{team}/projects/` (create project in team) also
+  // invalidates the org project list at `organizations/{org}/projects/`.
   {
     match: /^teams\/([^/]+)\/[^/]+\/projects\/?$/,
     extra: ([, org]) => [`organizations/${org}/projects/`]
   },
+  // `DELETE projects/{org}/{project}/` also invalidates the org project list.
   {
     match: /^projects\/([^/]+)\/[^/]+\/?$/,
     extra: ([, org]) => [`organizations/${org}/projects/`]
   },
+  // Org-scoped issue mutations at `organizations/{org}/issues/{id}/`
+  // also affect the legacy global endpoint at `issues/{id}/`, which
+  // `getIssue()` hits under the control-silo base URL (potentially a
+  // DIFFERENT origin than the org's region URL). Must clear the
+  // legacy cache too, or subsequent `getIssue()` calls serve stale
+  // data.
   {
     match: /^organizations\/[^/]+\/issues\/([^/]+)\/?$/,
     extraAbsolute: ([, issueId], { apiBaseUrl }) => [
@@ -756,7 +865,7 @@ function computeInvalidationPrefixes(fullUrl, apiBaseUrl) {
   if (relPath === "") {
     return [];
   }
-  const prefixes = new Set;
+  const prefixes = /* @__PURE__ */ new Set();
   for (const segments of ancestorSegments(relPath)) {
     prefixes.add(`${base}${segments}`);
   }
@@ -786,23 +895,26 @@ function* ancestorSegments(relPath) {
   }
   const parts = trimmed.split("/");
   const floor = parts.length > 2 ? 2 : 1;
-  for (let i = parts.length;i >= floor; i--) {
+  for (let i = parts.length; i >= floor; i--) {
     yield `${parts.slice(0, i).join("/")}/`;
   }
 }
+
 // src/api-client/response-cache/keys.ts
-var encoder = new TextEncoder;
+var encoder = new TextEncoder();
 function normalizeUrl(method, url) {
   const parsed = new URL(url);
-  const sortedParams = new URLSearchParams([...parsed.searchParams.entries()].sort(([a], [b]) => {
-    if (a < b) {
-      return -1;
-    }
-    if (a > b) {
-      return 1;
-    }
-    return 0;
-  }));
+  const sortedParams = new URLSearchParams(
+    [...parsed.searchParams.entries()].sort(([a], [b]) => {
+      if (a < b) {
+        return -1;
+      }
+      if (a > b) {
+        return 1;
+      }
+      return 0;
+    })
+  );
   parsed.search = sortedParams.toString() ? `?${sortedParams.toString()}` : "";
   return `${method.toUpperCase()}|${parsed.toString()}`;
 }
@@ -811,15 +923,29 @@ async function buildCacheKey(method, url, identity) {
     throw new TypeError("A cache key needs a non-empty identity");
   }
   const normalized = normalizeUrl(method, url);
-  const key = await crypto.subtle.importKey("raw", encoder.encode(identity), { name: "HMAC", hash: "SHA-256" }, false, ["sign"]);
-  const signature = await crypto.subtle.sign("HMAC", key, encoder.encode(normalized));
-  return Array.from(new Uint8Array(signature), (byte) => byte.toString(16).padStart(2, "0")).join("");
+  const key = await crypto.subtle.importKey(
+    "raw",
+    encoder.encode(identity),
+    { name: "HMAC", hash: "SHA-256" },
+    false,
+    ["sign"]
+  );
+  const signature = await crypto.subtle.sign(
+    "HMAC",
+    key,
+    encoder.encode(normalized)
+  );
+  return Array.from(
+    new Uint8Array(signature),
+    (byte) => byte.toString(16).padStart(2, "0")
+  ).join("");
 }
+
 // src/api-client/response-cache/memory-store.ts
 var MIB = 1024 * 1024;
 var ENTRY_OVERHEAD_BYTES = 1024;
 function limit(name, value, fallback) {
-  if (value === undefined) {
+  if (value === void 0) {
     return fallback;
   }
   if (!(Number.isFinite(value) && value > 0)) {
@@ -834,7 +960,7 @@ function createMemoryStore(options = {}) {
   const maxBytes = limit("maxBytes", options.maxBytes, 24 * MIB);
   const maxEntryBytes = limit("maxEntryBytes", options.maxEntryBytes, MIB);
   const maxRawBytes = limit("maxRawBytes", options.maxRawBytes, 32 * MIB);
-  const slots = new Map;
+  const slots = /* @__PURE__ */ new Map();
   let bytes = 0;
   function remove(key) {
     const slot = slots.get(key);
@@ -890,24 +1016,32 @@ function createMemoryStore(options = {}) {
     }
   };
 }
+
 // src/api-client/response-cache/policy.ts
 import CachePolicy from "http-cache-semantics";
 
 // src/api-client/response-cache/tiers.ts
 var FALLBACK_TTL_MS = {
-  stable: 5 * 60 * 1000,
-  volatile: 60 * 1000,
+  stable: 5 * 60 * 1e3,
+  volatile: 60 * 1e3,
   "no-cache": 0
 };
 var URL_TIER_PATTERNS = [
+  // Polling endpoints where state changes rapidly
   ["no-cache", [/\/(?:autofix|root-cause)\//]],
   [
     "volatile",
     [
+      // Issue endpoints: lists, detail views, and issue events such as
+      // `/issues/{id}/events/latest/`
       /\/issues\//,
       /[?&]dataset=(?:logs|spans)/,
       /\/trace-logs\//,
+      // Full traces gain spans as they arrive
       /\/trace\/[0-9a-f]{32}\//,
+      // Project event details embed user reports (and `nextEventID`/
+      // `previousEventID` unless collapsed), and reprocessing can change them
+      // for the same ID
       /\/projects\/[^/]+\/[^/]+\/events\/[^/?]+\/?(?:\?|$)/
     ]
   ]
@@ -922,13 +1056,13 @@ function classifyUrl(url) {
 }
 
 // src/api-client/response-cache/policy.ts
-var REVALIDATION_WINDOW_MS = 24 * 60 * 60 * 1000;
+var REVALIDATION_WINDOW_MS = 24 * 60 * 60 * 1e3;
 var POLICY_OPTIONS = {
   shared: false,
   cacheHeuristic: 0.1
 };
 var PRESERVED_HEADERS = ["link"];
-var encoder2 = new TextEncoder;
+var encoder2 = new TextEncoder();
 function pickHeaders(headers) {
   const result = {};
   for (const name of PRESERVED_HEADERS) {
@@ -948,7 +1082,10 @@ async function policyRequestHeaders(headers) {
 }
 async function sha256Hex(value) {
   const digest = await crypto.subtle.digest("SHA-256", encoder2.encode(value));
-  return Array.from(new Uint8Array(digest), (byte) => byte.toString(16).padStart(2, "0")).join("");
+  return Array.from(
+    new Uint8Array(digest),
+    (byte) => byte.toString(16).padStart(2, "0")
+  ).join("");
 }
 function headersToObject(headers) {
   return Object.fromEntries(headers.entries());
@@ -968,12 +1105,12 @@ function isEntryFresh(policy, entry, request) {
 }
 function retentionMs(policy, tier) {
   const freshMs = hasServerCacheDirectives(policy) ? policy.timeToLive() : FALLBACK_TTL_MS[tier];
-  return policy.responseHeaders().etag === undefined ? freshMs : freshMs + REVALIDATION_WINDOW_MS;
+  return policy.responseHeaders().etag === void 0 ? freshMs : freshMs + REVALIDATION_WINDOW_MS;
 }
 function buildResponseHeaders(policy, entry) {
   const result = {};
   for (const [name, value] of Object.entries(policy.responseHeaders())) {
-    if (value !== undefined) {
+    if (value !== void 0) {
       result[name] = Array.isArray(value) ? value.join(", ") : value;
     }
   }
@@ -1030,7 +1167,9 @@ async function lookupResponse(options) {
   if (!entry) {
     return;
   }
-  const policy = CachePolicy.fromObject(entry.policy);
+  const policy = CachePolicy.fromObject(
+    entry.policy
+  );
   const request = {
     url,
     method: "GET",
@@ -1059,11 +1198,15 @@ async function storeResponse(options) {
   if (!response.ok || tier === "no-cache") {
     return 0;
   }
-  const policy = new CachePolicy({
-    url,
-    method: "GET",
-    headers: await policyRequestHeaders(requestHeaders)
-  }, { status: response.status, headers: headersToObject(response.headers) }, POLICY_OPTIONS);
+  const policy = new CachePolicy(
+    {
+      url,
+      method: "GET",
+      headers: await policyRequestHeaders(requestHeaders)
+    },
+    { status: response.status, headers: headersToObject(response.headers) },
+    POLICY_OPTIONS
+  );
   if (!policy.storable()) {
     return 0;
   }
@@ -1071,22 +1214,27 @@ async function storeResponse(options) {
   JSON.parse(text);
   const createdAt = Date.now();
   const body = await codec.encode(encoder2.encode(text));
-  await store.set(key, {
-    url,
-    identity,
-    tier,
-    status: response.status,
-    headers: pickHeaders(response.headers),
-    body,
-    policy: policy.toObject(),
-    createdAt
-  }, retentionMs(policy, tier));
+  await store.set(
+    key,
+    {
+      url,
+      identity,
+      tier,
+      status: response.status,
+      headers: pickHeaders(response.headers),
+      body,
+      policy: policy.toObject(),
+      createdAt
+    },
+    retentionMs(policy, tier)
+  );
   return body.bytes.byteLength;
 }
+
 // src/api-client/time-params.ts
 function normalizeStatsPeriod(statsPeriod) {
   const normalized = statsPeriod?.trim();
-  return normalized || undefined;
+  return normalized || void 0;
 }
 function defaultStatsPeriod({
   statsPeriod,
@@ -1099,7 +1247,9 @@ function defaultStatsPeriod({
 function parseStatsPeriod(statsPeriod) {
   const match = /^(\d+)([smhdw])$/.exec(statsPeriod);
   if (!match?.[2]) {
-    throw new ApiValidationError("statsPeriod must use a supported relative time format, such as `24h`, `7d`, or `2w`.");
+    throw new ApiValidationError(
+      "statsPeriod must use a supported relative time format, such as `24h`, `7d`, or `2w`."
+    );
   }
   return {
     amount: Number(match[1]),
@@ -1108,10 +1258,14 @@ function parseStatsPeriod(statsPeriod) {
 }
 function applyTimeParams(queryParams, statsPeriod, start, end) {
   if (statsPeriod && (start || end)) {
-    throw new ApiValidationError("Cannot use both statsPeriod and start/end parameters. Use either statsPeriod for relative time or start/end for absolute time.");
+    throw new ApiValidationError(
+      "Cannot use both statsPeriod and start/end parameters. Use either statsPeriod for relative time or start/end for absolute time."
+    );
   }
   if (start && !end || !start && end) {
-    throw new ApiValidationError("Both start and end parameters must be provided together for absolute time ranges.");
+    throw new ApiValidationError(
+      "Both start and end parameters must be provided together for absolute time ranges."
+    );
   }
   if (statsPeriod) {
     queryParams.set("statsPeriod", statsPeriod);
@@ -1122,10 +1276,14 @@ function applyTimeParams(queryParams, statsPeriod, start, end) {
 }
 function applyStatsMixinTimeParams(queryParams, statsPeriod, start, end, resolutionSeconds) {
   if (statsPeriod && (start || end)) {
-    throw new ApiValidationError("Cannot use both statsPeriod and start/end parameters. Use either statsPeriod for relative time or start/end for absolute time.");
+    throw new ApiValidationError(
+      "Cannot use both statsPeriod and start/end parameters. Use either statsPeriod for relative time or start/end for absolute time."
+    );
   }
   if (start && !end || !start && end) {
-    throw new ApiValidationError("Both start and end parameters must be provided together for absolute time ranges.");
+    throw new ApiValidationError(
+      "Both start and end parameters must be provided together for absolute time ranges."
+    );
   }
   let since;
   let until;
@@ -1133,10 +1291,12 @@ function applyStatsMixinTimeParams(queryParams, statsPeriod, start, end, resolut
     const startMs = Date.parse(start);
     const endMs = Date.parse(end);
     if (!Number.isFinite(startMs) || !Number.isFinite(endMs)) {
-      throw new ApiValidationError("start and end parameters must be valid ISO 8601 date strings.");
+      throw new ApiValidationError(
+        "start and end parameters must be valid ISO 8601 date strings."
+      );
     }
-    since = Math.floor(startMs / 1000);
-    until = Math.floor(endMs / 1000);
+    since = Math.floor(startMs / 1e3);
+    until = Math.floor(endMs / 1e3);
   } else {
     const period = statsPeriod ?? "24h";
     const { amount, unit } = parseStatsPeriod(period);
@@ -1158,31 +1318,34 @@ function applyStatsMixinTimeParams(queryParams, statsPeriod, start, end, resolut
         unitSeconds = 60 * 60 * 24 * 7;
         break;
       default:
-        throw new ApiValidationError("statsPeriod must use a supported relative time format, such as `24h`, `7d`, or `2w`.");
+        throw new ApiValidationError(
+          "statsPeriod must use a supported relative time format, such as `24h`, `7d`, or `2w`."
+        );
     }
-    until = Math.floor(Date.now() / 1000);
+    until = Math.floor(Date.now() / 1e3);
     since = until - amount * unitSeconds;
   }
   queryParams.set("since", String(since));
   queryParams.set("until", String(until));
-  if (resolutionSeconds !== undefined) {
+  if (resolutionSeconds !== void 0) {
     queryParams.set("resolution", `${resolutionSeconds}s`);
   }
 }
+
 // src/api-client/transport.ts
-class ApiTimeoutError extends Error {
+var ApiTimeoutError = class extends Error {
   timeoutMs;
   idempotent;
   constructor(timeoutMs, idempotent) {
-    super(`Request timed out after ${Math.round(timeoutMs / 1000)}s`);
+    super(`Request timed out after ${Math.round(timeoutMs / 1e3)}s`);
     this.name = "ApiTimeoutError";
     this.timeoutMs = timeoutMs;
     this.idempotent = idempotent;
   }
-}
+};
 var MAX_REDIRECTS = 20;
 var ANONYMOUS = { token: "", identity: "" };
-var validatedSources = new WeakMap;
+var validatedSources = /* @__PURE__ */ new WeakMap();
 function getValidatedResponseSource(response) {
   return validatedSources.get(response);
 }
@@ -1203,13 +1366,12 @@ function extractUrlPath(input) {
     return raw;
   }
 }
-
-class Rejection {
-  error;
+var Rejection = class {
   constructor(error) {
     this.error = error;
   }
-}
+  error;
+};
 function createApiTransport(config) {
   const { credentials, retry, logger } = config;
   const cache = credentials && config.cache;
@@ -1239,7 +1401,9 @@ function createApiTransport(config) {
     return typeof config.timeoutMs === "function" ? config.timeoutMs(url) : config.timeoutMs;
   }
   function buildHeaders(input, init, credential) {
-    const headers = new Headers(init?.headers ?? (input instanceof Request ? input.headers : undefined));
+    const headers = new Headers(
+      init?.headers ?? (input instanceof Request ? input.headers : void 0)
+    );
     config.prepareHeaders?.(headers, { input, credential });
     setAuthorization(headers, authorization(credential));
     if (config.userAgent && !headers.has("User-Agent")) {
@@ -1255,9 +1419,9 @@ function createApiTransport(config) {
     }
   }
   async function fetchOnce(input, init, signal, timeoutMs, mode) {
-    const controller = new AbortController;
+    const controller = new AbortController();
     let timedOut = false;
-    const timer = timeoutMs === undefined ? undefined : setTimeout(() => {
+    const timer = timeoutMs === void 0 ? void 0 : setTimeout(() => {
       timedOut = true;
       controller.abort();
     }, timeoutMs);
@@ -1288,7 +1452,9 @@ function createApiTransport(config) {
   }
   async function rejectRedirect(response, destination, credential) {
     cancelBody(response);
-    throw new Rejection(config.origins?.reject(destination, credential) ?? new Error(`Refusing to follow a redirect to ${destination}`));
+    throw new Rejection(
+      config.origins?.reject(destination, credential) ?? new Error(`Refusing to follow a redirect to ${destination}`)
+    );
   }
   function trusts(url, credential, original) {
     return config.origins ? config.origins.trusts(url, credential) : url.origin === original.origin;
@@ -1305,7 +1471,10 @@ function createApiTransport(config) {
     try {
       next = new URL(location, request2.url);
     } catch (error) {
-      logger?.debug("Rejected malformed redirect location", error instanceof Error ? error.name : "unknown error");
+      logger?.debug(
+        "Rejected malformed redirect location",
+        error instanceof Error ? error.name : "unknown error"
+      );
       return await rejectRedirect(response, "<invalid host>", credential);
     }
     if (!trusts(next, credential, original)) {
@@ -1321,11 +1490,17 @@ function createApiTransport(config) {
   async function fetchValidated(input, init, headers, credential, timeoutMs, mode) {
     const original = new Request(input, init);
     const originalUrl = new URL(original.url);
-    const visited = new Set([redirectKey(originalUrl)]);
+    const visited = /* @__PURE__ */ new Set([redirectKey(originalUrl)]);
     let request2 = original;
     let requestHeaders = new Headers(headers);
-    for (;; ) {
-      const result = await fetchOnce(request2.clone(), { headers: requestHeaders, redirect: "manual" }, init?.signal ?? original.signal, timeoutMs, mode);
+    for (; ; ) {
+      const result = await fetchOnce(
+        request2.clone(),
+        { headers: requestHeaders, redirect: "manual" },
+        init?.signal ?? original.signal,
+        timeoutMs,
+        mode
+      );
       if (!("response" in result) || !isRedirect(result.response.status)) {
         const origin = httpOrigin(request2.url);
         if ("response" in result && origin) {
@@ -1338,8 +1513,19 @@ function createApiTransport(config) {
       }
       const { response } = result;
       try {
-        const next = await nextRedirect(response, request2, credential, visited, originalUrl);
-        ({ request: request2, headers: requestHeaders } = await redirectRequest(request2, requestHeaders, next, response.status));
+        const next = await nextRedirect(
+          response,
+          request2,
+          credential,
+          visited,
+          originalUrl
+        );
+        ({ request: request2, headers: requestHeaders } = await redirectRequest(
+          request2,
+          requestHeaders,
+          next,
+          response.status
+        ));
       } finally {
         cancelBody(response);
       }
@@ -1349,14 +1535,16 @@ function createApiTransport(config) {
     const { input, init, method, url, path, options } = sendArgs;
     let credential = credentials?.prepare ? await credentials.prepare(sendArgs.credential) : sendArgs.credential;
     const headers = buildHeaders(input, init, credential);
-    for (const [name, value] of Object.entries(sendArgs.conditionalHeaders ?? {})) {
+    for (const [name, value] of Object.entries(
+      sendArgs.conditionalHeaders ?? {}
+    )) {
       headers.set(name, value);
     }
     const nextInput = await replayableInput(input, init);
     const timeoutMs = timeoutFor(url);
     const idempotent = options.idempotent === true || (config.isIdempotent?.(method, url) ?? false);
     const mode = options.responseBody ?? "stream";
-    const signal = init?.signal !== undefined ? init.signal : input instanceof Request ? input.signal : undefined;
+    const signal = init?.signal !== void 0 ? init.signal : input instanceof Request ? input.signal : void 0;
     let refreshed = false;
     let waitedMs = 0;
     const retryDelay = (attempt, status, serverDelayMs) => nextRetryDelayMs({
@@ -1370,7 +1558,7 @@ function createApiTransport(config) {
     });
     async function onResponse(response, attempt) {
       if (response.status === 401) {
-        const next = refreshed || !credentials?.refresh ? undefined : await credentials.refresh(credential);
+        const next = refreshed || !credentials?.refresh ? void 0 : await credentials.refresh(credential);
         if (!next) {
           return { action: "done", response };
         }
@@ -1383,9 +1571,12 @@ function createApiTransport(config) {
         cancelBody(response);
         return { action: "replay" };
       }
-      const serverDelayMs = parseRetryDelayMs(response.status, response.headers);
+      const serverDelayMs = parseRetryDelayMs(
+        response.status,
+        response.headers
+      );
       const delayMs = retryDelay(attempt, response.status, serverDelayMs);
-      if (delayMs !== undefined) {
+      if (delayMs !== void 0) {
         cancelBody(response);
         return { action: "retry", delayMs };
       }
@@ -1411,11 +1602,11 @@ function createApiTransport(config) {
       if (fatal) {
         return { action: "throw", error: fatal };
       }
-      const delayMs = retryDelay(attempt, undefined, undefined);
-      if (delayMs !== undefined) {
+      const delayMs = retryDelay(attempt, void 0, void 0);
+      if (delayMs !== void 0) {
         return { action: "retry", delayMs };
       }
-      if (timedOutAfterMs === undefined) {
+      if (timedOutAfterMs === void 0) {
         return { action: "throw", error: failed };
       }
       const replayable = isIdempotentRequest(method, idempotent);
@@ -1427,28 +1618,54 @@ function createApiTransport(config) {
         }) ?? new ApiTimeoutError(timedOutAfterMs, replayable)
       };
     }
-    for (let attempt = 0;; ) {
+    for (let attempt = 0; ; ) {
       const { input: attemptInput, init: attemptInit } = nextInput();
       let outcome;
       try {
-        outcome = options.validateRedirects ? await fetchValidated(attemptInput, attemptInit, headers, credential, timeoutMs, mode) : await fetchOnce(attemptInput, { ...attemptInit, headers }, signal, timeoutMs, mode);
+        outcome = options.validateRedirects ? await fetchValidated(
+          attemptInput,
+          attemptInit,
+          headers,
+          credential,
+          timeoutMs,
+          mode
+        ) : await fetchOnce(
+          attemptInput,
+          { ...attemptInit, headers },
+          signal,
+          timeoutMs,
+          mode
+        );
       } catch (error) {
         outcome = { failed: error };
       }
       const result = "response" in outcome ? await onResponse(outcome.response, attempt) : onFailure(outcome, attempt);
       if (result.action === "done") {
-        storeInCache(method, url, sendArgs.credential.identity, headers, result.response);
-        await invalidateAfterWrite(method, url, sendArgs.credential.identity, result.response);
+        storeInCache(
+          method,
+          url,
+          sendArgs.credential.identity,
+          headers,
+          result.response
+        );
+        await invalidateAfterWrite(
+          method,
+          url,
+          sendArgs.credential.identity,
+          result.response
+        );
         return result.response;
       }
       if (result.action === "throw") {
         throw result.error;
       }
       if (result.action === "replay") {
-        logger?.debug(`${method} ${path} → replay with a refreshed credential`);
+        logger?.debug(`${method} ${path} \u2192 replay with a refreshed credential`);
         continue;
       }
-      logger?.debug(`${method} ${path} → retry ${attempt + 1}/${retry.maxRetries} after ${Math.round(result.delayMs)}ms`);
+      logger?.debug(
+        `${method} ${path} \u2192 retry ${attempt + 1}/${retry.maxRetries} after ${Math.round(result.delayMs)}ms`
+      );
       await sleep(result.delayMs, signal);
       waitedMs += result.delayMs;
       attempt++;
@@ -1458,11 +1675,14 @@ function createApiTransport(config) {
     if (!cache || method !== "GET" || !response.ok) {
       return;
     }
-    cache.store({
-      url,
-      requestHeaders: { authorization: headers.get("Authorization") ?? "" },
-      identity
-    }, response.clone()).catch((error) => {
+    cache.store(
+      {
+        url,
+        requestHeaders: { authorization: headers.get("Authorization") ?? "" },
+        identity
+      },
+      response.clone()
+    ).catch((error) => {
       logger?.debug("Response cache write failed", error);
     });
   }
@@ -1488,9 +1708,11 @@ function createApiTransport(config) {
         url,
         requestHeaders: lookupHeaders(credential),
         identity: credential.identity
-      }) : undefined;
+      }) : void 0;
       if (lookup?.kind === "hit") {
-        logger?.debug(`${method} ${path} → ${lookup.response.status} (cache hit, ${elapsed()}ms)`);
+        logger?.debug(
+          `${method} ${path} \u2192 ${lookup.response.status} (cache hit, ${elapsed()}ms)`
+        );
         return lookup.response;
       }
       const sendArgs = { input, init, method, url, path, credential, options };
@@ -1501,12 +1723,14 @@ function createApiTransport(config) {
       if (lookup?.kind === "stale" && response.status === 304) {
         const revalidated = await lookup.revalidate(response);
         if (revalidated) {
-          logger?.debug(`${method} ${path} → 304 (revalidated cache entry, ${elapsed()}ms)`);
+          logger?.debug(
+            `${method} ${path} \u2192 304 (revalidated cache entry, ${elapsed()}ms)`
+          );
           return revalidated;
         }
         response = await send(sendArgs);
       }
-      logger?.debug(`${method} ${path} → ${response.status} (${elapsed()}ms)`);
+      logger?.debug(`${method} ${path} \u2192 ${response.status} (${elapsed()}ms)`);
       return response;
     };
     return config.span ? await config.span({ method, path }, run) : await run();
@@ -1514,7 +1738,7 @@ function createApiTransport(config) {
   return { request };
 }
 async function drainBody(response, signal) {
-  const drained = response.body?.pipeTo(new WritableStream);
+  const drained = response.body?.pipeTo(new WritableStream());
   if (!drained) {
     return;
   }
@@ -1533,7 +1757,8 @@ async function drainBody(response, signal) {
     if (onAbort) {
       signal.removeEventListener("abort", onAbort);
     }
-    drained.catch(() => {});
+    drained.catch(() => {
+    });
   }
 }
 function isAbort(error, signal) {
@@ -1558,13 +1783,13 @@ async function replayableInput(input, init) {
   return () => ({ input, init });
 }
 function setAuthorization(headers, value) {
-  if (value !== undefined) {
+  if (value !== void 0) {
     headers.set("Authorization", value);
   }
 }
 function httpOrigin(raw) {
   const url = new URL(raw);
-  return (url.protocol === "http:" || url.protocol === "https:") && !url.username && !url.password ? url.origin : undefined;
+  return (url.protocol === "http:" || url.protocol === "https:") && !url.username && !url.password ? url.origin : void 0;
 }
 function isRedirect(status) {
   return [301, 302, 303, 307, 308].includes(status);
@@ -1583,65 +1808,65 @@ async function redirectRequest(request, requestHeaders, next, status) {
     headers.delete("content-type");
     headers.delete("transfer-encoding");
   }
-  const body = method === current && request.body ? await request.clone().arrayBuffer() : undefined;
+  const body = method === current && request.body ? await request.clone().arrayBuffer() : void 0;
   return { request: new Request(next, { method, headers, body }), headers };
 }
 export {
-  withQuery,
-  validateResponse,
-  trimAuthToken,
-  storeResponse,
-  sleep,
-  sentryBearerHeader,
-  selectIdempotentWrites,
-  readJsonResponse,
-  readErrorResponse,
-  parseStatsPeriod,
-  parseRetryDelayMs,
-  paginate,
-  normalizeUrl,
-  normalizeStatsPeriod,
-  normalizeAuthToken,
-  nextRetryDelayMs,
-  nextPageCursor,
-  lookupResponse,
-  listPage,
-  isIdempotentRequest,
-  isApiAuthenticationErrorDeep,
-  getValidatedResponseSource,
-  fetchAllPages,
-  extractUrlPath,
-  extractInputUrl,
-  encodeApiPathSegment,
-  defaultStatsPeriod,
-  decodePageCursor,
-  createMemoryStore,
-  createIdempotentOperationMatcher,
-  createApiTransport,
-  createApiError,
-  createApiClientCore,
-  consumeCursorPage,
-  computeInvalidationPrefixes,
-  classifyUrl,
-  buildSentryApiUrl,
-  buildCacheKey,
-  applyTimeParams,
-  applyStatsMixinTimeParams,
-  apiPath,
-  UserInputError,
-  REVALIDATION_WINDOW_MS,
-  MAX_LIST_PAGES,
-  FALLBACK_TTL_MS,
-  ConfigurationError,
-  ApiValidationError,
-  ApiTimeoutError,
-  ApiServerError,
-  ApiResponseValidationError,
-  ApiRateLimitError,
-  ApiPermissionError,
-  ApiNotFoundError,
-  ApiError,
-  ApiClientError,
+  API_MAX_PER_PAGE,
   ApiAuthenticationError,
-  API_MAX_PER_PAGE
+  ApiClientError,
+  ApiError,
+  ApiNotFoundError,
+  ApiPermissionError,
+  ApiRateLimitError,
+  ApiResponseValidationError,
+  ApiServerError,
+  ApiTimeoutError,
+  ApiValidationError,
+  ConfigurationError,
+  FALLBACK_TTL_MS,
+  MAX_LIST_PAGES,
+  REVALIDATION_WINDOW_MS,
+  UserInputError,
+  apiPath,
+  applyStatsMixinTimeParams,
+  applyTimeParams,
+  buildCacheKey,
+  buildSentryApiUrl,
+  classifyUrl,
+  computeInvalidationPrefixes,
+  consumeCursorPage,
+  createApiClientCore,
+  createApiError,
+  createApiTransport,
+  createIdempotentOperationMatcher,
+  createMemoryStore,
+  decodePageCursor,
+  defaultStatsPeriod,
+  encodeApiPathSegment,
+  extractInputUrl,
+  extractUrlPath,
+  fetchAllPages,
+  getValidatedResponseSource,
+  isApiAuthenticationErrorDeep,
+  isIdempotentRequest,
+  listPage,
+  lookupResponse,
+  nextPageCursor,
+  nextRetryDelayMs,
+  normalizeAuthToken,
+  normalizeStatsPeriod,
+  normalizeUrl,
+  paginate,
+  parseRetryDelayMs,
+  parseStatsPeriod,
+  readErrorResponse,
+  readJsonResponse,
+  selectIdempotentWrites,
+  sentryBearerHeader,
+  sleep,
+  storeResponse,
+  trimAuthToken,
+  validateResponse,
+  withQuery
 };