@sentry/api 0.445.0 → 0.446.0

package/dist/api-client/index.js

@@ -0,0 +1,1647 @@
+// src/api-client/errors.ts
+import { SentryApiError } from "@sentry/api";
+
+class UserInputError extends Error {
+  constructor(message, options) {
+    super(message, options);
+    this.name = "UserInputError";
+  }
+}
+
+class ConfigurationError 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);
+    this.detail = detail;
+    this.responseBody = responseBody;
+    this.name = "ApiError";
+    Object.setPrototypeOf(this, ApiError.prototype);
+  }
+}
+
+class ApiClientError extends ApiError {
+  constructor(message, status, detail, responseBody) {
+    super(message, status, detail, responseBody);
+    this.name = "ApiClientError";
+    Object.setPrototypeOf(this, ApiClientError.prototype);
+  }
+  toUserMessage() {
+    const baseMessage = this.status ? `API error (${this.status}): ${this.message}` : `API error: ${this.message}`;
+    if (this.status === 404) {
+      const genericMessages = [
+        "not found",
+        "the requested resource does not exist",
+        "resource does not exist",
+        "resource not found"
+      ];
+      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.`;
+      }
+      return `${baseMessage}. Please verify the parameters are correct.`;
+    }
+    return baseMessage;
+  }
+  isPermissionError() {
+    return this.status === 403;
+  }
+  isNotFoundError() {
+    return this.status === 404;
+  }
+  isValidationError() {
+    return this.status === 400 || this.status === 422;
+  }
+  isAuthenticationError() {
+    return this.status === 401;
+  }
+  isRateLimitError() {
+    return this.status === 429;
+  }
+}
+
+class ApiPermissionError extends ApiClientError {
+  constructor(message, detail, responseBody) {
+    super(message, 403, detail, responseBody);
+    this.name = "ApiPermissionError";
+    Object.setPrototypeOf(this, ApiPermissionError.prototype);
+  }
+  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");
+  }
+}
+
+class ApiNotFoundError extends ApiClientError {
+  resourceType;
+  resourceId;
+  constructor(message, detail, responseBody, resourceType, resourceId) {
+    super(message, 404, detail, responseBody);
+    this.resourceType = resourceType;
+    this.resourceId = resourceId;
+    this.name = "ApiNotFoundError";
+    Object.setPrototypeOf(this, ApiNotFoundError.prototype);
+  }
+}
+
+class ApiValidationError extends ApiClientError {
+  validationErrors;
+  constructor(message, status, detail, responseBody, validationErrors) {
+    super(message, status, detail, responseBody);
+    this.validationErrors = validationErrors;
+    this.name = "ApiValidationError";
+    Object.setPrototypeOf(this, ApiValidationError.prototype);
+  }
+}
+
+class ApiAuthenticationError extends ApiClientError {
+  constructor(message, detail, responseBody) {
+    super(message, 401, detail, responseBody);
+    this.name = "ApiAuthenticationError";
+    Object.setPrototypeOf(this, ApiAuthenticationError.prototype);
+  }
+}
+
+class ApiRateLimitError extends ApiClientError {
+  retryAfterMs;
+  constructor(message, detail, responseBody, retryAfterMs) {
+    super(message, 429, detail, responseBody);
+    this.retryAfterMs = retryAfterMs;
+    this.name = "ApiRateLimitError";
+    Object.setPrototypeOf(this, ApiRateLimitError.prototype);
+  }
+  toUserMessage() {
+    if (this.retryAfterMs === undefined) {
+      return `${super.toUserMessage()}. Retry in a few seconds.`;
+    }
+    const seconds = Math.max(1, Math.ceil(this.retryAfterMs / 1000));
+    return `${super.toUserMessage()}. Retry in ${seconds} second${seconds === 1 ? "" : "s"}.`;
+  }
+}
+
+class ApiServerError extends ApiError {
+  constructor(message, status, detail, responseBody) {
+    super(message, status, detail, responseBody);
+    this.name = "ApiServerError";
+    Object.setPrototypeOf(this, ApiServerError.prototype);
+  }
+  isGatewayError() {
+    return this.status === 502 || this.status === 503 || this.status === 504;
+  }
+  isInternalError() {
+    return this.status === 500;
+  }
+}
+function createApiError(message, status, detail, responseBody, 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")) {
+    improvedMessage = "You do not have access to query across multiple projects. Please select a project for your query.";
+    return new ApiPermissionError(improvedMessage, detail, responseBody);
+  }
+  switch (status) {
+    case 401:
+      return new ApiAuthenticationError(message, detail, responseBody);
+    case 403:
+      return new ApiPermissionError(message, detail, responseBody);
+    case 404:
+      return new ApiNotFoundError(message, detail, responseBody);
+    case 400:
+    case 422: {
+      let validationErrors;
+      if (responseBody && typeof responseBody === "object" && "errors" in responseBody) {
+        validationErrors = responseBody.errors;
+      }
+      return new ApiValidationError(message, status, detail, responseBody, validationErrors);
+    }
+    case 429:
+      return new ApiRateLimitError(message, detail, responseBody, retryAfterMs);
+    default:
+      if (status >= 400 && status < 500) {
+        return new ApiClientError(message, status, detail, responseBody);
+      }
+      if (status >= 500 && status < 600) {
+        return new ApiServerError(message, status, detail, responseBody);
+      }
+      return new ApiError(message, status, detail, responseBody);
+  }
+}
+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;
+    current = current.cause;
+  }
+  return false;
+}
+
+// src/api-client/api-path.ts
+function encodeApiPathSegment(value) {
+  const text = String(value);
+  return text === "." || text === ".." ? null : encodeURIComponent(text);
+}
+function buildSentryApiUrl(baseUrl, endpoint) {
+  const path = endpoint.startsWith("/") ? endpoint.slice(1) : endpoint;
+  let end = baseUrl.length;
+  while (end > 0 && baseUrl.charAt(end - 1) === "/") {
+    end -= 1;
+  }
+  return `${baseUrl.slice(0, end)}/api/0/${path}`;
+}
+function apiPath(strings, ...values) {
+  return strings.reduce((acc, literal, index) => {
+    if (index >= values.length) {
+      return acc + literal;
+    }
+    const value = String(values[index]);
+    const encoded = encodeApiPathSegment(value);
+    if (encoded === null) {
+      throw new UserInputError(`Invalid identifier "${value}": relative path segments are not allowed.`);
+    }
+    return acc + literal + encoded;
+  }, "");
+}
+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]/;
+function trimAuthToken(token) {
+  let start = 0;
+  let end = token.length;
+  while (start < end && TOKEN_PADDING_PATTERN.test(token.charAt(start))) {
+    start += 1;
+  }
+  while (end > start && TOKEN_PADDING_PATTERN.test(token.charAt(end - 1))) {
+    end -= 1;
+  }
+  return token.slice(start, end);
+}
+function normalizeAuthToken(token) {
+  const normalized = trimAuthToken(token);
+  return normalized && !INVALID_TOKEN_CHARACTER_PATTERN.test(normalized) ? normalized : null;
+}
+function sentryBearerHeader(token) {
+  const normalized = normalizeAuthToken(token);
+  return normalized === null ? null : `Bearer ${normalized}`;
+}
+// src/api-client/core.ts
+import {
+  createSentryClient,
+  parseSentryLinkHeader
+} from "@sentry/api";
+
+// src/api-client/pagination.ts
+import { consumePage, paginateUpTo } from "@sentry/api";
+var API_MAX_PER_PAGE = 100;
+var NEXT_CURSOR_RE = /^(.*:\d+):(0(?:_?0)*)$/;
+var FIRST_PAGE_CURSOR = "0:0:0";
+var PAGE_NUMBER_CURSOR_RE = /^(\d+):\d+:[01]$/;
+var CLI_CURSOR_PREFIX = "cli1~";
+function encodeSkip(skip) {
+  return `0${skip.toString(2).replaceAll("1", "_0")}`;
+}
+function decodeSkip(isPrev) {
+  return Number.parseInt(isPrev.slice(1).replaceAll("_0", "1"), 2) || 0;
+}
+function encodePageCursor(cursor, skip) {
+  const server = cursor ?? FIRST_PAGE_CURSOR;
+  const next = skip > 0 ? NEXT_CURSOR_RE.exec(server) : null;
+  return next ? `${next[1]}:${encodeSkip(skip)}` : server;
+}
+function decodePageCursor(raw, warn = () => {}) {
+  if (!raw) {
+    return { cursor: undefined, skip: 0 };
+  }
+  if (raw.startsWith(CLI_CURSOR_PREFIX)) {
+    return decodeCliCursor(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,
+    skip: next?.[2] ? decodeSkip(next[2]) : 0
+  };
+  const perPage = serverCursorPageSize(cursor);
+  return perPage === undefined ? 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
+  };
+  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);
+  return {
+    ...page,
+    data: consumed.data,
+    nextCursor: consumed.position ? encodePageCursor(consumed.position.cursor, consumed.position.offset) : undefined
+  };
+}
+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;
+}
+function pageSizeForLimit(limit) {
+  if (limit <= API_MAX_PER_PAGE) {
+    return Math.max(1, limit);
+  }
+  return Math.ceil(limit / Math.ceil(limit / API_MAX_PER_PAGE));
+}
+async function paginate(options, fetchPage) {
+  const { limit, 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");
+  return {
+    data: result.data,
+    ...result.continuation ? {
+      nextCursor: encodePageCursor(result.continuation.cursor, result.continuation.offset)
+    } : {},
+    stoppedAtPageCap: result.stopReason === "maxPages"
+  };
+}
+async function fetchAllPages(fetchPage, parse, maxPages) {
+  const items = [];
+  const seen = new Set;
+  let cursor;
+  for (let page = 0;page < maxPages; page += 1) {
+    const { data, nextCursor } = await fetchPage(cursor);
+    const rows = parse(data);
+    if (!rows) {
+      return { ok: false, reason: "invalid-page" };
+    }
+    items.push(...rows);
+    if (!nextCursor) {
+      return { ok: true, items };
+    }
+    if (seen.has(nextCursor)) {
+      return { ok: false, reason: "repeated-cursor" };
+    }
+    seen.add(nextCursor);
+    cursor = nextCursor;
+  }
+  return { ok: false, reason: "page-cap" };
+}
+
+// src/api-client/retry.ts
+var IDEMPOTENT_METHODS = new Set([
+  "GET",
+  "HEAD",
+  "OPTIONS"
+]);
+var RETRYABLE_STATUSES = new Map([
+  [429, "any"],
+  [500, "idempotent"],
+  [502, "idempotent"],
+  [503, "idempotent"],
+  [504, "idempotent"]
+]);
+var DATE_RESOLUTION_MS = 1000;
+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) {
+    return false;
+  }
+  return replays === "any" || isIdempotentRequest(method, idempotent);
+}
+function parseRetryDelayMs(status, headers, now = Date.now()) {
+  const retryAfter = headers.get("retry-after")?.trim();
+  if (retryAfter) {
+    if (/^\d+$/.test(retryAfter)) {
+      return Number(retryAfter) * 1000;
+    }
+    const date = Date.parse(retryAfter);
+    return Number.isNaN(date) ? undefined : delayUntil(date, headers, now);
+  }
+  if (status !== 429 || !isWindowLimited(headers)) {
+    return;
+  }
+  const reset = Number(headers.get("x-sentry-rate-limit-reset"));
+  if (!Number.isFinite(reset) || reset <= 0) {
+    return;
+  }
+  return delayUntil(reset * 1000, headers, now);
+}
+function nextRetryDelayMs({
+  policy,
+  method,
+  idempotent,
+  status,
+  serverDelayMs,
+  attempt,
+  waitedMs,
+  random = Math.random
+}) {
+  if (attempt >= policy.maxRetries || !isRetryable(method, status, idempotent)) {
+    return;
+  }
+  let delayMs;
+  if (serverDelayMs !== undefined) {
+    if (serverDelayMs > policy.maxDelayMs) {
+      return;
+    }
+    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;
+}
+function sleep(ms, signal) {
+  return new Promise((resolve, reject) => {
+    if (signal?.aborted) {
+      reject(signal.reason);
+      return;
+    }
+    const onAbort = () => {
+      clearTimeout(timer);
+      reject(signal?.reason);
+    };
+    const timer = setTimeout(() => {
+      signal?.removeEventListener("abort", onAbort);
+      resolve();
+    }, ms);
+    signal?.addEventListener("abort", onAbort, { once: true });
+  });
+}
+function delayUntil(target, headers, now) {
+  let delay = target - now;
+  const date = Date.parse(headers.get("date") ?? "");
+  if (!Number.isNaN(date)) {
+    const latest = target - date;
+    delay = Math.min(Math.max(delay, latest - DATE_RESOLUTION_MS), latest);
+  }
+  return Math.max(0, delay);
+}
+function isWindowLimited(headers) {
+  return headers.get("x-sentry-rate-limit-remaining") === "0";
+}
+
+// src/api-client/response.ts
+function readDetail(json) {
+  if (json === null || typeof json !== "object" || !("detail" in json)) {
+    return;
+  }
+  return typeof json.detail === "string" ? json.detail : undefined;
+}
+function looksLikeHtml(text) {
+  return text.includes("<!DOCTYPE") || text.includes("<html");
+}
+async function readErrorResponse(response) {
+  const retryAfterMs = parseRetryDelayMs(response.status, response.headers);
+  let text;
+  try {
+    text = await response.text();
+  } catch {
+    return { text: undefined, isHtml: false, retryAfterMs };
+  }
+  try {
+    const json = JSON.parse(text);
+    return {
+      text,
+      json,
+      detail: readDetail(json),
+      isHtml: false,
+      retryAfterMs
+    };
+  } catch (error) {
+    return {
+      text,
+      parseError: error instanceof Error ? error.message : String(error),
+      isHtml: looksLikeHtml(text),
+      retryAfterMs
+    };
+  }
+}
+async function readJsonResponse(response) {
+  if (!response.headers?.get) {
+    return await response.json();
+  }
+  const contentType = response.headers.get("content-type");
+  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 ${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)}`);
+  }
+}
+
+// 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(".");
+}
+
+class ApiResponseValidationError extends Error {
+  issues;
+  constructor(issues) {
+    const listed = issues.slice(0, MAX_LISTED_ISSUES).map((issue) => {
+      const path = issuePath(issue);
+      return path ? `${path}: ${issue.message}` : issue.message;
+    });
+    const more = issues.length > MAX_LISTED_ISSUES ? ` (and ${issues.length - MAX_LISTED_ISSUES} more)` : "";
+    super(`Unexpected API response: ${listed.join("; ")}${more}`);
+    this.name = "ApiResponseValidationError";
+    this.issues = issues;
+  }
+}
+function validateResponse(schema, data) {
+  const result = schema["~standard"].validate(data);
+  if (result instanceof Promise) {
+    throw new TypeError("Response schemas must validate synchronously");
+  }
+  if (result.issues) {
+    throw new ApiResponseValidationError(result.issues);
+  }
+  return result.value;
+}
+
+// src/api-client/core.ts
+var MAX_LIST_PAGES = 50;
+function nextPageCursor(response) {
+  return parseSentryLinkHeader(response.headers.get("link")).nextCursor ?? null;
+}
+var NETWORK_ERROR_MESSAGES = {
+  EAI_AGAIN: "DNS temporarily unavailable. Check your internet connection.",
+  ENOTFOUND: "Hostname not found. Verify the URL is correct.",
+  ECONNREFUSED: "Connection refused. Ensure the service is accessible.",
+  ETIMEDOUT: "Connection timed out. Check network connectivity.",
+  ECONNRESET: "Connection reset. Try again in a moment."
+};
+var API_PREFIX = "/api/0";
+var CONFIGURATION_ERROR_CODES = new Set([
+  "ENOTFOUND",
+  "EAI_AGAIN",
+  "ECONNREFUSED",
+  "ETIMEDOUT"
+]);
+function networkError(url, error) {
+  let rootCause = error;
+  while (rootCause instanceof Error && rootCause.cause) {
+    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 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 });
+  }
+  return new Error(friendlyMessage, { cause: 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) {
+    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);
+    }
+    logger.warn("Failed to parse JSON error response", {
+      ...logExtra,
+      bodyPreview,
+      parseErrorMessage: body.parseError
+    });
+  } else if (body.json) {
+    if (body.detail !== undefined) {
+      return createApiError(body.detail, response.status, body.detail, body.json, retryAfterMs);
+    }
+    logger.warn("Failed to parse validated API error response", {
+      ...logExtra,
+      bodyPreview,
+      validationErrorMessage: "Error response has no string detail"
+    });
+  }
+  return createApiError(`API request failed: ${response.statusText}
+${errorText}`, response.status, errorText, undefined, retryAfterMs);
+}
+function createApiClientCore({
+  transport,
+  headers,
+  logger
+}) {
+  async function request(origin, path, init = {}, { allowStatuses } = {}) {
+    const url = buildSentryApiUrl(origin, path);
+    const requestHeaders = {
+      "Content-Type": "application/json",
+      ...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.");
+    }
+    let response;
+    try {
+      response = await transport.request(url, {
+        ...init,
+        headers: requestHeaders
+      });
+    } catch (error) {
+      if (init.signal?.aborted) {
+        throw error;
+      }
+      throw networkError(url, error);
+    }
+    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
+    });
+  }
+  return {
+    request,
+    async requestJson(origin, path, init) {
+      return await readJsonResponse(await request(origin, path, init));
+    },
+    sdkClient(origin, expectedPath) {
+      const base = new URL(origin).origin;
+      const sdkFetch = async (sdkRequest) => {
+        if (!(sdkRequest instanceof Request)) {
+          throw new ConfigurationError("Unexpected SDK request input");
+        }
+        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");
+        }
+        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);
+        }
+        return response;
+      };
+      return createSentryClient({ baseUrl: base, fetch: sdkFetch }).client;
+    }
+  };
+}
+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}`);
+  }
+  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 { data, response } = await fetchPage(perPage, cursor);
+    const rows = validateResponse(schema, data);
+    if (rows.length > perPage) {
+      throw new Error("API returned more items than requested");
+    }
+    items.push(...rows);
+    const nextCursor = nextPageCursor(response);
+    if (items.length >= limit || !nextCursor) {
+      return { items, nextCursor };
+    }
+    if (seenCursors.has(nextCursor) || nextCursor === cursor) {
+      throw new Error("API returned a repeated pagination cursor");
+    }
+    seenCursors.add(nextCursor);
+    cursor = nextCursor;
+  }
+  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));
+}
+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("/");
+  return { method: method.toUpperCase(), pattern: new RegExp(`^${source}$`) };
+}
+function createIdempotentOperationMatcher(operations) {
+  let matchers;
+  return (method, url) => {
+    if (!URL.canParse(url)) {
+      return false;
+    }
+    const pathname = new URL(url).pathname;
+    const apiIndex = pathname.indexOf("/api/");
+    if (apiIndex === -1) {
+      return false;
+    }
+    const apiPath2 = pathname.slice(apiIndex);
+    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));
+  };
+}
+// src/api-client/response-cache/invalidation.ts
+var API_V0_SEGMENT = "/api/0/";
+var TRAILING_SLASH_RE = /\/$/;
+var SKIP_INVALIDATION_PATTERNS = [
+  /\/chunk-upload\//,
+  /\/artifactbundle\/assemble\//
+];
+var CROSS_ENDPOINT_RULES = [
+  {
+    match: /^teams\/([^/]+)\/[^/]+\/projects\/?$/,
+    extra: ([, org]) => [`organizations/${org}/projects/`]
+  },
+  {
+    match: /^projects\/([^/]+)\/[^/]+\/?$/,
+    extra: ([, org]) => [`organizations/${org}/projects/`]
+  },
+  {
+    match: /^organizations\/[^/]+\/issues\/([^/]+)\/?$/,
+    extraAbsolute: ([, issueId], { apiBaseUrl }) => [
+      `${apiBaseUrl.replace(TRAILING_SLASH_RE, "")}/api/0/issues/${issueId}/`
+    ]
+  }
+];
+function computeInvalidationPrefixes(fullUrl, apiBaseUrl) {
+  let parsed;
+  try {
+    parsed = new URL(fullUrl);
+  } catch {
+    return [];
+  }
+  const apiIdx = parsed.pathname.indexOf(API_V0_SEGMENT);
+  if (apiIdx === -1) {
+    return [];
+  }
+  if (SKIP_INVALIDATION_PATTERNS.some((p) => p.test(parsed.pathname))) {
+    return [];
+  }
+  const base = `${parsed.origin}${parsed.pathname.slice(0, apiIdx + API_V0_SEGMENT.length)}`;
+  const relPath = parsed.pathname.slice(apiIdx + API_V0_SEGMENT.length);
+  if (relPath === "") {
+    return [];
+  }
+  const prefixes = new Set;
+  for (const segments of ancestorSegments(relPath)) {
+    prefixes.add(`${base}${segments}`);
+  }
+  for (const extra of applyCrossEndpointRules(relPath, base, apiBaseUrl)) {
+    prefixes.add(extra);
+  }
+  return [...prefixes];
+}
+function* applyCrossEndpointRules(relPath, base, apiBaseUrl) {
+  for (const rule of CROSS_ENDPOINT_RULES) {
+    const match = relPath.match(rule.match);
+    if (!match) {
+      continue;
+    }
+    for (const extra of rule.extra?.(match) ?? []) {
+      yield `${base}${extra}`;
+    }
+    for (const absolute of rule.extraAbsolute?.(match, { apiBaseUrl }) ?? []) {
+      yield absolute;
+    }
+  }
+}
+function* ancestorSegments(relPath) {
+  const trimmed = relPath.endsWith("/") ? relPath.slice(0, -1) : relPath;
+  if (trimmed === "") {
+    return;
+  }
+  const parts = trimmed.split("/");
+  const floor = parts.length > 2 ? 2 : 1;
+  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;
+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;
+  }));
+  parsed.search = sortedParams.toString() ? `?${sortedParams.toString()}` : "";
+  return `${method.toUpperCase()}|${parsed.toString()}`;
+}
+async function buildCacheKey(method, url, identity) {
+  if (!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("");
+}
+// 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) {
+    return fallback;
+  }
+  if (!(Number.isFinite(value) && value > 0)) {
+    throw new RangeError(`${name} must be a positive number, got ${value}`);
+  }
+  return value;
+}
+function ownBytes(bytes) {
+  return bytes.byteOffset === 0 && bytes.byteLength === bytes.buffer.byteLength ? bytes : new Uint8Array(bytes);
+}
+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;
+  let bytes = 0;
+  function remove(key) {
+    const slot = slots.get(key);
+    if (slot) {
+      slots.delete(key);
+      bytes -= slot.size;
+    }
+  }
+  return {
+    async get(key) {
+      const slot = slots.get(key);
+      if (!slot) {
+        return;
+      }
+      if (Date.now() >= slot.expiresAt) {
+        remove(key);
+        return;
+      }
+      slots.delete(key);
+      slots.set(key, slot);
+      return slot.entry;
+    },
+    async set(key, entry, ttlMs) {
+      remove(key);
+      const stored = entry.body.bytes.byteLength;
+      const size = stored + ENTRY_OVERHEAD_BYTES;
+      if (!(ttlMs > 0) || stored > maxEntryBytes || entry.body.rawSize > maxRawBytes || size > maxBytes) {
+        return;
+      }
+      const body = { ...entry.body, bytes: ownBytes(entry.body.bytes) };
+      slots.set(key, {
+        entry: { ...entry, body },
+        size,
+        expiresAt: Date.now() + ttlMs
+      });
+      bytes += size;
+      for (const oldest of slots.keys()) {
+        if (bytes <= maxBytes) {
+          break;
+        }
+        remove(oldest);
+      }
+    },
+    async deleteMatching(identity, urlPrefix) {
+      for (const [key, slot] of slots) {
+        if (slot.entry.identity === identity && slot.entry.url.startsWith(urlPrefix)) {
+          remove(key);
+        }
+      }
+    },
+    stats() {
+      return { entries: slots.size, bytes };
+    }
+  };
+}
+// 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,
+  "no-cache": 0
+};
+var URL_TIER_PATTERNS = [
+  ["no-cache", [/\/(?:autofix|root-cause)\//]],
+  [
+    "volatile",
+    [
+      /\/issues\//,
+      /[?&]dataset=(?:logs|spans)/,
+      /\/trace-logs\//,
+      /\/trace\/[0-9a-f]{32}\//,
+      /\/projects\/[^/]+\/[^/]+\/events\/[^/?]+\/?(?:\?|$)/
+    ]
+  ]
+];
+function classifyUrl(url) {
+  for (const [tier, patterns] of URL_TIER_PATTERNS) {
+    if (patterns.some((pattern) => pattern.test(url))) {
+      return tier;
+    }
+  }
+  return "stable";
+}
+
+// src/api-client/response-cache/policy.ts
+var REVALIDATION_WINDOW_MS = 24 * 60 * 60 * 1000;
+var POLICY_OPTIONS = {
+  shared: false,
+  cacheHeuristic: 0.1
+};
+var PRESERVED_HEADERS = ["link"];
+var encoder2 = new TextEncoder;
+function pickHeaders(headers) {
+  const result = {};
+  for (const name of PRESERVED_HEADERS) {
+    const value = headers.get(name);
+    if (value) {
+      result[name] = value;
+    }
+  }
+  return result;
+}
+async function policyRequestHeaders(headers) {
+  const result = {};
+  for (const [name, value] of Object.entries(headers)) {
+    result[name] = name.toLowerCase() === "authorization" && value ? await sha256Hex(value) : value;
+  }
+  return result;
+}
+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("");
+}
+function headersToObject(headers) {
+  return Object.fromEntries(headers.entries());
+}
+function hasServerCacheDirectives(policy) {
+  return Object.keys(policy.toObject().rescc).length > 0;
+}
+function isEntryFresh(policy, entry, request) {
+  if (policy.satisfiesWithoutRevalidation(request)) {
+    return true;
+  }
+  if (hasServerCacheDirectives(policy)) {
+    return false;
+  }
+  const fallbackTtl = FALLBACK_TTL_MS[classifyUrl(request.url)];
+  return Date.now() - entry.createdAt <= fallbackTtl;
+}
+function retentionMs(policy, tier) {
+  const freshMs = hasServerCacheDirectives(policy) ? policy.timeToLive() : FALLBACK_TTL_MS[tier];
+  return policy.responseHeaders().etag === undefined ? freshMs : freshMs + REVALIDATION_WINDOW_MS;
+}
+function buildResponseHeaders(policy, entry) {
+  const result = {};
+  for (const [name, value] of Object.entries(policy.responseHeaders())) {
+    if (value !== undefined) {
+      result[name] = Array.isArray(value) ? value.join(", ") : value;
+    }
+  }
+  for (const [name, value] of Object.entries(entry.headers)) {
+    if (!(name in result)) {
+      result[name] = value;
+    }
+  }
+  return result;
+}
+function responseBody(bytes) {
+  return bytes;
+}
+function staleLookup(options, entry, policy, request) {
+  const etag = policy.revalidationHeaders(request)["if-none-match"];
+  if (typeof etag !== "string") {
+    return;
+  }
+  const { store, codec, key, onRenewError } = options;
+  return {
+    kind: "stale",
+    conditionalHeaders: { "if-none-match": etag },
+    async revalidate(response) {
+      if (response.status !== 304) {
+        return;
+      }
+      const result = policy.revalidatedPolicy(request, {
+        status: response.status,
+        headers: headersToObject(response.headers)
+      });
+      if (result.modified || result.matches === false) {
+        return;
+      }
+      const body = await codec.decode(entry.body);
+      if (!body) {
+        return;
+      }
+      const renewed = {
+        ...entry,
+        policy: result.policy.toObject(),
+        createdAt: Date.now()
+      };
+      store.set(key, renewed, retentionMs(result.policy, entry.tier)).catch((error) => onRenewError?.(error));
+      return new Response(responseBody(body), {
+        status: entry.status,
+        headers: buildResponseHeaders(result.policy, entry)
+      });
+    }
+  };
+}
+async function lookupResponse(options) {
+  const { store, codec, key, url, requestHeaders } = options;
+  const entry = await store.get(key);
+  if (!entry) {
+    return;
+  }
+  const policy = CachePolicy.fromObject(entry.policy);
+  const request = {
+    url,
+    method: "GET",
+    headers: await policyRequestHeaders(requestHeaders)
+  };
+  if (!isEntryFresh(policy, entry, request)) {
+    return staleLookup(options, entry, policy, request);
+  }
+  const body = await codec.decode(entry.body);
+  if (!body) {
+    return;
+  }
+  return {
+    kind: "hit",
+    response: new Response(responseBody(body), {
+      status: entry.status,
+      headers: buildResponseHeaders(policy, entry)
+    }),
+    createdAt: entry.createdAt,
+    size: body.byteLength
+  };
+}
+async function storeResponse(options) {
+  const { store, codec, key, identity, url, requestHeaders, response } = options;
+  const tier = classifyUrl(url);
+  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);
+  if (!policy.storable()) {
+    return 0;
+  }
+  const text = await response.text();
+  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));
+  return body.bytes.byteLength;
+}
+// src/api-client/time-params.ts
+function normalizeStatsPeriod(statsPeriod) {
+  const normalized = statsPeriod?.trim();
+  return normalized || undefined;
+}
+function defaultStatsPeriod({
+  statsPeriod,
+  start,
+  end
+}) {
+  const normalized = normalizeStatsPeriod(statsPeriod);
+  return start || end ? normalized : normalized ?? "24h";
+}
+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`.");
+  }
+  return {
+    amount: Number(match[1]),
+    unit: match[2]
+  };
+}
+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.");
+  }
+  if (start && !end || !start && end) {
+    throw new ApiValidationError("Both start and end parameters must be provided together for absolute time ranges.");
+  }
+  if (statsPeriod) {
+    queryParams.set("statsPeriod", statsPeriod);
+  } else if (start && end) {
+    queryParams.set("start", start);
+    queryParams.set("end", 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.");
+  }
+  if (start && !end || !start && end) {
+    throw new ApiValidationError("Both start and end parameters must be provided together for absolute time ranges.");
+  }
+  let since;
+  let until;
+  if (start && end) {
+    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.");
+    }
+    since = Math.floor(startMs / 1000);
+    until = Math.floor(endMs / 1000);
+  } else {
+    const period = statsPeriod ?? "24h";
+    const { amount, unit } = parseStatsPeriod(period);
+    let unitSeconds;
+    switch (unit) {
+      case "s":
+        unitSeconds = 1;
+        break;
+      case "m":
+        unitSeconds = 60;
+        break;
+      case "h":
+        unitSeconds = 60 * 60;
+        break;
+      case "d":
+        unitSeconds = 60 * 60 * 24;
+        break;
+      case "w":
+        unitSeconds = 60 * 60 * 24 * 7;
+        break;
+      default:
+        throw new ApiValidationError("statsPeriod must use a supported relative time format, such as `24h`, `7d`, or `2w`.");
+    }
+    until = Math.floor(Date.now() / 1000);
+    since = until - amount * unitSeconds;
+  }
+  queryParams.set("since", String(since));
+  queryParams.set("until", String(until));
+  if (resolutionSeconds !== undefined) {
+    queryParams.set("resolution", `${resolutionSeconds}s`);
+  }
+}
+// src/api-client/transport.ts
+class ApiTimeoutError extends Error {
+  timeoutMs;
+  idempotent;
+  constructor(timeoutMs, idempotent) {
+    super(`Request timed out after ${Math.round(timeoutMs / 1000)}s`);
+    this.name = "ApiTimeoutError";
+    this.timeoutMs = timeoutMs;
+    this.idempotent = idempotent;
+  }
+}
+var MAX_REDIRECTS = 20;
+var ANONYMOUS = { token: "", identity: "" };
+var validatedSources = new WeakMap;
+function getValidatedResponseSource(response) {
+  return validatedSources.get(response);
+}
+function extractInputUrl(input) {
+  if (typeof input === "string") {
+    return input;
+  }
+  if (input instanceof URL) {
+    return input.href;
+  }
+  return input.url;
+}
+function extractUrlPath(input) {
+  const raw = extractInputUrl(input);
+  try {
+    return new URL(raw).pathname;
+  } catch {
+    return raw;
+  }
+}
+
+class Rejection {
+  error;
+  constructor(error) {
+    this.error = error;
+  }
+}
+function createApiTransport(config) {
+  const { credentials, retry, logger } = config;
+  const cache = credentials && config.cache;
+  const baseFetch = (input, init) => (config.fetch ?? globalThis.fetch)(input, init);
+  function authorization(credential) {
+    if (!credentials) {
+      return;
+    }
+    if (credentials.authorization) {
+      return credentials.authorization(credential);
+    }
+    const header = sentryBearerHeader(credential.token);
+    if (header === null) {
+      throw new Error("Malformed authentication token");
+    }
+    return header;
+  }
+  function lookupHeaders(credential) {
+    try {
+      const value = authorization(credential);
+      return value ? { authorization: value } : {};
+    } catch {
+      return {};
+    }
+  }
+  function timeoutFor(url) {
+    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));
+    config.prepareHeaders?.(headers, { input, credential });
+    setAuthorization(headers, authorization(credential));
+    if (config.userAgent && !headers.has("User-Agent")) {
+      headers.set("User-Agent", config.userAgent);
+    }
+    return headers;
+  }
+  function cancelBody(response) {
+    if (response.body && !response.bodyUsed) {
+      response.body.cancel().catch((error) => {
+        logger?.debug("Failed to cancel unused response body", error);
+      });
+    }
+  }
+  async function fetchOnce(input, init, signal, timeoutMs, mode) {
+    const controller = new AbortController;
+    let timedOut = false;
+    const timer = timeoutMs === undefined ? undefined : setTimeout(() => {
+      timedOut = true;
+      controller.abort();
+    }, timeoutMs);
+    const onAbort = () => controller.abort(signal?.reason);
+    if (signal?.aborted) {
+      onAbort();
+    } else {
+      signal?.addEventListener("abort", onAbort, { once: true });
+    }
+    try {
+      const response = await baseFetch(input, {
+        ...init,
+        signal: controller.signal
+      });
+      if (shouldBuffer(response, mode)) {
+        await drainBody(response.clone(), controller.signal);
+      }
+      return { response };
+    } catch (error) {
+      if (timedOut) {
+        return { failed: error, timedOutAfterMs: timeoutMs };
+      }
+      throw error;
+    } finally {
+      clearTimeout(timer);
+      signal?.removeEventListener("abort", onAbort);
+    }
+  }
+  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}`));
+  }
+  function trusts(url, credential, original) {
+    return config.origins ? config.origins.trusts(url, credential) : url.origin === original.origin;
+  }
+  async function nextRedirect(response, request2, credential, visited, original) {
+    const location = response.headers.get("location");
+    if (!location) {
+      return await rejectRedirect(response, "<unknown host>", credential);
+    }
+    if (visited.size > MAX_REDIRECTS) {
+      return await rejectRedirect(response, "<too many redirects>", credential);
+    }
+    let next;
+    try {
+      next = new URL(location, request2.url);
+    } catch (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)) {
+      return await rejectRedirect(response, next.origin, credential);
+    }
+    const key = redirectKey(next);
+    if (visited.has(key)) {
+      return await rejectRedirect(response, "<redirect loop>", credential);
+    }
+    visited.add(key);
+    return next;
+  }
+  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)]);
+    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);
+      if (!("response" in result) || !isRedirect(result.response.status)) {
+        const origin = httpOrigin(request2.url);
+        if ("response" in result && origin) {
+          validatedSources.set(result.response, {
+            origin,
+            identity: credential.identity
+          });
+        }
+        return result;
+      }
+      const { response } = result;
+      try {
+        const next = await nextRedirect(response, request2, credential, visited, originalUrl);
+        ({ request: request2, headers: requestHeaders } = await redirectRequest(request2, requestHeaders, next, response.status));
+      } finally {
+        cancelBody(response);
+      }
+    }
+  }
+  async function send(sendArgs) {
+    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 ?? {})) {
+      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;
+    let refreshed = false;
+    let waitedMs = 0;
+    const retryDelay = (attempt, status, serverDelayMs) => nextRetryDelayMs({
+      policy: retry,
+      method,
+      idempotent,
+      status,
+      serverDelayMs,
+      attempt,
+      waitedMs
+    });
+    async function onResponse(response, attempt) {
+      if (response.status === 401) {
+        const next = refreshed || !credentials?.refresh ? undefined : await credentials.refresh(credential);
+        if (!next) {
+          return { action: "done", response };
+        }
+        refreshed = true;
+        credential = next;
+        setAuthorization(headers, authorization(next));
+        if (config.refreshedRequestHeader) {
+          headers.set(config.refreshedRequestHeader, "1");
+        }
+        cancelBody(response);
+        return { action: "replay" };
+      }
+      const serverDelayMs = parseRetryDelayMs(response.status, response.headers);
+      const delayMs = retryDelay(attempt, response.status, serverDelayMs);
+      if (delayMs !== undefined) {
+        cancelBody(response);
+        return { action: "retry", delayMs };
+      }
+      if (response.status === 429 && config.errors?.rateLimited) {
+        const error = await config.errors.rateLimited(response, {
+          path,
+          retryAfterMs: serverDelayMs
+        });
+        if (error) {
+          return { action: "throw", error };
+        }
+      }
+      return { action: "done", response };
+    }
+    function onFailure({ failed, timedOutAfterMs }, attempt) {
+      if (failed instanceof Rejection) {
+        return { action: "throw", error: failed.error };
+      }
+      if (isAbort(failed, signal)) {
+        return { action: "throw", error: failed };
+      }
+      const fatal = config.errors?.fatal?.(failed);
+      if (fatal) {
+        return { action: "throw", error: fatal };
+      }
+      const delayMs = retryDelay(attempt, undefined, undefined);
+      if (delayMs !== undefined) {
+        return { action: "retry", delayMs };
+      }
+      if (timedOutAfterMs === undefined) {
+        return { action: "throw", error: failed };
+      }
+      const replayable = isIdempotentRequest(method, idempotent);
+      return {
+        action: "throw",
+        error: config.errors?.timeout?.({
+          timeoutMs: timedOutAfterMs,
+          idempotent: replayable
+        }) ?? new ApiTimeoutError(timedOutAfterMs, replayable)
+      };
+    }
+    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);
+      } 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);
+        return result.response;
+      }
+      if (result.action === "throw") {
+        throw result.error;
+      }
+      if (result.action === "replay") {
+        logger?.debug(`${method} ${path} → replay with a refreshed credential`);
+        continue;
+      }
+      logger?.debug(`${method} ${path} → retry ${attempt + 1}/${retry.maxRetries} after ${Math.round(result.delayMs)}ms`);
+      await sleep(result.delayMs, signal);
+      waitedMs += result.delayMs;
+      attempt++;
+    }
+  }
+  function storeInCache(method, url, identity, headers, response) {
+    if (!cache || method !== "GET" || !response.ok) {
+      return;
+    }
+    cache.store({
+      url,
+      requestHeaders: { authorization: headers.get("Authorization") ?? "" },
+      identity
+    }, response.clone()).catch((error) => {
+      logger?.debug("Response cache write failed", error);
+    });
+  }
+  async function invalidateAfterWrite(method, url, identity, response) {
+    if (!cache || method === "GET" || !response.ok) {
+      return;
+    }
+    try {
+      await cache.invalidate(url, identity);
+    } catch (error) {
+      logger?.debug("Post-mutation cache invalidation failed", error);
+    }
+  }
+  async function request(input, init, options = {}) {
+    const method = init?.method ?? (input instanceof Request ? input.method : "GET");
+    const url = extractInputUrl(input);
+    const path = extractUrlPath(input);
+    const run = async () => {
+      const startTime = performance.now();
+      const elapsed = () => (performance.now() - startTime).toFixed(0);
+      const credential = credentials ? await credentials.current() : ANONYMOUS;
+      const lookup = cache && method === "GET" && !options.validateRedirects && !config.fresh?.() ? await cache.lookup({
+        url,
+        requestHeaders: lookupHeaders(credential),
+        identity: credential.identity
+      }) : undefined;
+      if (lookup?.kind === "hit") {
+        logger?.debug(`${method} ${path} → ${lookup.response.status} (cache hit, ${elapsed()}ms)`);
+        return lookup.response;
+      }
+      const sendArgs = { input, init, method, url, path, credential, options };
+      let response = await send({
+        ...sendArgs,
+        conditionalHeaders: lookup?.conditionalHeaders
+      });
+      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)`);
+          return revalidated;
+        }
+        response = await send(sendArgs);
+      }
+      logger?.debug(`${method} ${path} → ${response.status} (${elapsed()}ms)`);
+      return response;
+    };
+    return config.span ? await config.span({ method, path }, run) : await run();
+  }
+  return { request };
+}
+async function drainBody(response, signal) {
+  const drained = response.body?.pipeTo(new WritableStream);
+  if (!drained) {
+    return;
+  }
+  let onAbort;
+  const aborted = new Promise((_, reject) => {
+    onAbort = () => reject(signal.reason);
+    if (signal.aborted) {
+      onAbort();
+    } else {
+      signal.addEventListener("abort", onAbort, { once: true });
+    }
+  });
+  try {
+    await Promise.race([drained, aborted]);
+  } finally {
+    if (onAbort) {
+      signal.removeEventListener("abort", onAbort);
+    }
+    drained.catch(() => {});
+  }
+}
+function isAbort(error, signal) {
+  return Boolean(signal?.aborted) && (error === signal?.reason || error instanceof DOMException && error.name === "AbortError");
+}
+function shouldBuffer(response, mode) {
+  const contentType = response.headers.get("Content-Type");
+  if (contentType?.split(";")[0]?.trim().toLowerCase() === "text/event-stream") {
+    return false;
+  }
+  return response.ok && (mode === "buffer" || mode === "auto" && !!contentType);
+}
+async function replayableInput(input, init) {
+  if (input instanceof Request) {
+    return () => ({ input: input.clone(), init });
+  }
+  const body = init?.body;
+  if (body instanceof ReadableStream) {
+    const snapshot = await new Response(body).arrayBuffer();
+    return () => ({ input, init: { ...init, body: snapshot } });
+  }
+  return () => ({ input, init });
+}
+function setAuthorization(headers, value) {
+  if (value !== undefined) {
+    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;
+}
+function isRedirect(status) {
+  return [301, 302, 303, 307, 308].includes(status);
+}
+function redirectKey(url) {
+  const key = new URL(url);
+  key.hash = "";
+  return key.href;
+}
+async function redirectRequest(request, requestHeaders, next, status) {
+  const current = request.method.toUpperCase();
+  const method = status === 303 && current !== "HEAD" || (status === 301 || status === 302) && current === "POST" ? "GET" : current;
+  const headers = new Headers(requestHeaders);
+  if (method !== current) {
+    headers.delete("content-length");
+    headers.delete("content-type");
+    headers.delete("transfer-encoding");
+  }
+  const body = method === current && request.body ? await request.clone().arrayBuffer() : undefined;
+  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,
+  ApiAuthenticationError,
+  API_MAX_PER_PAGE
+};