@xano/sdk 1.0.0

package/dist/chunk-YLDALTWZ.js

@@ -0,0 +1,653 @@
+import {
+  profileSourceLabel
+} from "./chunk-QXTKSOFI.js";
+import {
+  readEnvVar
+} from "./chunk-X2NL4KUO.js";
+import {
+  UsageError
+} from "./chunk-PTHVMXZI.js";
+
+// src/util/last-credential.ts
+import { AsyncLocalStorage } from "async_hooks";
+var runScope = new AsyncLocalStorage();
+function inCredentialScope(fn) {
+  return runScope.run({}, fn);
+}
+function noteResolvedAuth(auth, args) {
+  const state = runScope.getStore();
+  if (state !== void 0) state.last = { auth, args };
+}
+function lastResolvedAuth() {
+  return runScope.getStore()?.last;
+}
+async function noteMetaAnswer(url, res) {
+  if (res.status !== 404 && res.status !== 500) return;
+  const state = runScope.getStore();
+  const auth = state?.last?.auth;
+  if (state === void 0 || auth === void 0 || state.workspaceMiss === true) return;
+  try {
+    const at = new URL(url);
+    if (at.origin !== new URL(auth.instance).origin) return;
+    const id = /^\/api:meta\/workspace\/(\d+)(?:\/|$)/.exec(at.pathname)?.[1];
+    if (id === void 0 || Number(id) !== auth.workspaceId) return;
+    const text = await res.clone().text();
+    let said = text.trim();
+    try {
+      const message = JSON.parse(said).message;
+      said = typeof message === "string" ? message.trim() : "";
+    } catch {
+    }
+    if (said === "" || /^invalid workspace\.?$/i.test(said)) state.workspaceMiss = true;
+  } catch {
+  }
+}
+function pinnedWorkspaceMissed() {
+  return runScope.getStore()?.workspaceMiss === true;
+}
+
+// src/util/http.ts
+import { isIP } from "net";
+var MAX_DETAIL_CHARS = 500;
+function debugEnabled() {
+  const v = readEnvVar("XANOSDK_DEBUG")?.trim();
+  return v !== void 0 && v !== "0" && v.toLowerCase() !== "false";
+}
+function serverMessage(text) {
+  let parsed;
+  let isJson = false;
+  try {
+    parsed = JSON.parse(text);
+    isJson = true;
+  } catch {
+  }
+  if (isJson) {
+    const message = parsed !== null && typeof parsed === "object" && !Array.isArray(parsed) ? parsed.message : void 0;
+    if (typeof message !== "string") return void 0;
+    const flat2 = message.replace(/\s+/g, " ").trim();
+    if (flat2 === "") return void 0;
+    return flat2.length > MAX_DETAIL_CHARS ? `${flat2.slice(0, MAX_DETAIL_CHARS)}\u2026` : flat2;
+  }
+  const page = markupSummary(text);
+  if (page !== void 0) return page;
+  const first = text.split(/\r?\n/).map((l) => l.trim()).find((l) => l !== "");
+  if (first === void 0) return void 0;
+  const flat = first.replace(/\s+/g, " ");
+  return flat.length > MAX_LINE_CHARS ? `${flat.slice(0, MAX_LINE_CHARS)}\u2026` : flat;
+}
+var MAX_LINE_CHARS = 200;
+function markupSummary(text) {
+  const head = text.trimStart().slice(0, 512).toLowerCase();
+  const isMarkup = head.startsWith("<!doctype html") || head.startsWith("<html") || /<(html|head|body|title)[\s>]/.test(head);
+  if (!isMarkup) return void 0;
+  const title = /<title[^>]*>([\s\S]*?)<\/title>/i.exec(text)?.[1]?.replace(/\s+/g, " ").trim();
+  const bare = text.replace(/<(script|style)[\s\S]*?<\/\1>/gi, " ").replace(/<[^>]*>/g, " ").replace(/\s+/g, " ").trim();
+  const shown = title !== void 0 && title !== "" ? title.slice(0, 120) : bare !== "" && bare.length <= 120 ? bare : void 0;
+  return shown !== void 0 ? `an HTML page ("${shown}"), not an API response` : "an HTML page, not an API response";
+}
+function notJsonError(action, text, url, opts = {}) {
+  const where = url === void 0 || url === "" ? "the instance" : transportTarget(url);
+  const isPage = markupSummary(text) !== void 0;
+  const titled = isPage && opts.safe !== true && /<title[^>]*>\s*\S[\s\S]*?<\/title>/i.test(text);
+  const what = isPage ? `${titled ? markupSummary(text) : "an HTML page, not an API response"} \u2014 a proxy or captive portal between you and the instance?` : text.trim() === "" ? "an empty body, not an API response." : "something that is not JSON, not an API response.";
+  const head = `${action}: ${where} answered with ${what}${opts.aftermath !== void 0 ? `
+${opts.aftermath}` : ""}`;
+  return new Error(opts.safe !== true && debugEnabled() && text.trim() !== "" ? `${head}
+${text}` : head);
+}
+function unexpectedAnswerError(action, text, url, opts = {}) {
+  const where = url === void 0 || url === "" ? "the instance" : transportTarget(url);
+  const head = `${action}: ${where} answered with something that is not the answer this request expects.${opts.aftermath !== void 0 ? `
+${opts.aftermath}` : ""}`;
+  return new Error(opts.safe !== true && debugEnabled() && text.trim() !== "" ? `${head}
+${text}` : head);
+}
+function parseJsonAnswer(text, action, url, opts = {}) {
+  try {
+    return JSON.parse(text);
+  } catch {
+    throw notJsonError(action, text, url, opts);
+  }
+}
+var TransportError = class extends Error {
+  constructor(message, timeout, options) {
+    super(message, options);
+    this.timeout = timeout;
+  }
+  timeout;
+  name = "TransportError";
+};
+function isBodyTransportFailure(err) {
+  if (isTimeoutError(err)) return true;
+  const name = err?.name;
+  if (name === "AbortError") return true;
+  if (typeof err?.cause?.code === "string") return true;
+  return err instanceof TypeError && /terminated|fetch failed|socket|network|ECONN/i.test(err.message);
+}
+function explainBodyFailure(err, opts) {
+  const where = opts.display ?? transportTarget(opts.url);
+  const redirected = redirectFailure(err, opts.url);
+  if (redirected !== void 0) {
+    const head2 = `${opts.what}: ${where} ${redirected}`;
+    return new TransportError(opts.aftermath === void 0 ? head2 : `${head2}
+${opts.aftermath}`, false, { cause: err });
+  }
+  const timeout = isTimeoutError(err);
+  const head = timeout ? `${opts.what}: ${where} did not finish answering` + (opts.timeoutMs !== void 0 ? ` within ${seconds(opts.timeoutMs)}` : "") + ` \u2014 the read timed out.` : `${opts.what}: the connection to ${where} dropped before the answer was fully read (${describeTransportFailure(err)}).`;
+  return new TransportError(`${head}
+${opts.aftermath ?? READ_AFTERMATH}`, timeout, { cause: err });
+}
+async function readBodyText(res, what, opts = {}) {
+  try {
+    return await res.text();
+  } catch (err) {
+    if (err instanceof TransportError || !isBodyTransportFailure(err)) throw err;
+    throw explainBodyFailure(err, { url: opts.url ?? res.url, what, timeoutMs: opts.timeoutMs, aftermath: opts.aftermath });
+  }
+}
+async function readBodyBytes(res, what, opts = {}) {
+  try {
+    return new Uint8Array(await res.arrayBuffer());
+  } catch (err) {
+    if (err instanceof TransportError || !isBodyTransportFailure(err)) throw err;
+    throw explainBodyFailure(err, { url: opts.url ?? res.url, what, timeoutMs: opts.timeoutMs, aftermath: opts.aftermath });
+  }
+}
+function explainingBody(res, opts) {
+  for (const method of ["text", "arrayBuffer", "json", "blob", "bytes", "formData"]) {
+    const original = res[method];
+    if (typeof original !== "function") continue;
+    Object.defineProperty(res, method, {
+      configurable: true,
+      value: async (...a) => {
+        try {
+          return await original.apply(res, a);
+        } catch (err) {
+          if (err instanceof TransportError || !isBodyTransportFailure(err)) throw err;
+          throw explainBodyFailure(err, opts);
+        }
+      }
+    });
+  }
+  return res;
+}
+var SENT_AFTERMATH = "The request was sent, so it may or may not have taken effect \u2014 check before retrying.";
+function writeRefusedBy(status, opts = {}) {
+  if (opts.atomic === true) return !GATEWAY_STATUSES.has(status);
+  return status >= 400 && status < 500 || status === 501;
+}
+var GATEWAY_STATUSES = /* @__PURE__ */ new Set([502, 503, 504]);
+function writeStatusAftermath(status, aftermath = SENT_AFTERMATH, opts = {}) {
+  return writeRefusedBy(status, opts) ? void 0 : aftermath;
+}
+var OPENED_THEN_LOST = /* @__PURE__ */ new Set(["UND_ERR_SOCKET"]);
+function answerWasLost(err) {
+  let next = err;
+  for (let depth = 0; depth < 8 && next !== null && typeof next === "object"; depth++) {
+    const code = next.code;
+    if (typeof code === "string" && OPENED_THEN_LOST.has(code)) return true;
+    next = next.cause;
+  }
+  return false;
+}
+function lostAnswerHead(head, err) {
+  if (!answerWasLost(err)) return head;
+  const m = /^(.*?) could not reach (.+?): (.*)$/s.exec(head);
+  return m === null ? head : `${m[1]}: the answer from ${m[2]} was lost \u2014 ${m[3]}`;
+}
+function withWriteStatusAftermath(head, status, aftermath, opts = {}) {
+  const line = writeStatusAftermath(status, aftermath, opts);
+  return line === void 0 ? head : `${head}
+${line}`;
+}
+function isReadMethod(init) {
+  const method = (init.method ?? "GET").toUpperCase();
+  return method === "GET" || method === "HEAD";
+}
+function labelledMessage(text) {
+  let parsed;
+  try {
+    parsed = JSON.parse(text);
+  } catch {
+    return void 0;
+  }
+  if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) return void 0;
+  const message = parsed.message;
+  if (typeof message !== "string" || message === "") return void 0;
+  const flat = message.replace(/\s+/g, " ").trim();
+  if (flat === "") return void 0;
+  return flat.length > MAX_DETAIL_CHARS ? `${flat.slice(0, MAX_DETAIL_CHARS)}\u2026` : flat;
+}
+function statusLabel(res) {
+  return res.statusText === "" ? String(res.status) : `${res.status} ${res.statusText}`;
+}
+function safeHttpFailure(action, res, body, binding) {
+  const detail = labelledMessage(body);
+  const head = `${action} failed (${statusLabel(res)})${detail !== void 0 ? `: ${detail}` : "."}`;
+  if (res.status !== 403 || binding === void 0) return head;
+  const why = explainBindingRefusal(binding);
+  return why === void 0 ? head : `${head}
+${why}`;
+}
+function bindingFor(auth, workspaceId, tenantHost) {
+  return {
+    boundWorkspaceId: auth.workspaceId,
+    instance: auth.instance,
+    profile: auth.profile,
+    addressedWorkspaceId: workspaceId,
+    credentialType: auth.credentialType,
+    tenantHost
+  };
+}
+function explainBindingRefusal(ctx, flag = ctx.profile?.flag ?? "--profile") {
+  if (ctx.tenantHost) return void 0;
+  if (ctx.credentialType === "token") return void 0;
+  if (ctx.boundWorkspaceId !== void 0 && ctx.boundWorkspaceId === ctx.addressedWorkspaceId) {
+    return void 0;
+  }
+  const arm = ctx.credentialType === "oauth-refresh" ? `This credential came from \`XANO_REFRESH_TOKEN\`, which resolves its workspace at run time \u2014 check that the refresh token was minted for workspace ${ctx.addressedWorkspaceId}.` : profileRemedy(ctx.profile, flag);
+  const whose = ctx.profile === void 0 ? "This credential" : `Profile "${ctx.profile.name}"`;
+  return `${whose} is bound to ${ctx.boundWorkspaceId === void 0 ? "a different workspace" : `workspace ${ctx.boundWorkspaceId}`} on ${ctx.instance ?? "this instance"}, and this call addressed workspace ${ctx.addressedWorkspaceId}. A token can only act on the workspace it was issued for.
+` + arm;
+}
+function profileRemedy(profile, flag) {
+  if (profile !== void 0 && profile.source === "flag" && flag !== "--profile") {
+    return `Run \`xanosdk profile list\` to see which profile addresses the workspace you meant, then name it with \`${flag} <name>\`.`;
+  }
+  if (profile === void 0 || profile.source === "flag" || profile.source === "env") {
+    return `Run \`xanosdk profile list\` to see which profile addresses the workspace you meant, or \`xanosdk whoami\` for this one's binding.`;
+  }
+  return `Nothing on the command line selected this profile \u2014 it came from ${profileSourceLabel(profile.source, profile.defaultIn)}. Run \`xanosdk profile list\` to see the others, then \`--profile <name>\` for one run or \`xanosdk profile use <name>\` to pin this project to it.`;
+}
+function httpFailure(action, res, body) {
+  const detail = serverMessage(body);
+  const head = `${action} failed (${statusLabel(res)})${detail !== void 0 ? `: ${detail}` : "."}`;
+  return debugEnabled() && body.trim() !== "" ? `${head}
+${body}` : head;
+}
+function closeSentence(text) {
+  const t = text.trimEnd();
+  return t === "" || /[.!?…]["')\]]*$/.test(t) ? t : `${t}.`;
+}
+function appendSentence(message, sentence) {
+  const [first = "", ...rest] = message.split("\n");
+  return [`${closeSentence(first)} ${sentence}`.trimStart(), ...rest].join("\n");
+}
+function httpFailureError(action, res, body) {
+  return new Error(httpFailure(action, res, body));
+}
+function describeTransportFailure(err) {
+  const cause = err?.cause;
+  if (isInvalidRequestHeader(err)) return INVALID_HEADER;
+  const certificate = certificateFailureCode(err);
+  if (certificate !== void 0) return describeCertificateFailure(certificate);
+  if (isBlockedPort(err)) {
+    return `its port is one fetch refuses to connect to (a blocked port, e.g. 1 or 25) \u2014 nothing was sent. Check the port in the URL.`;
+  }
+  const code = cause?.code;
+  const outer = err instanceof Error ? err.message : String(err);
+  if (typeof code === "string") return `${outer} (${code})`;
+  if (cause instanceof Error && cause.message !== "") return `${outer} (${cause.message})`;
+  if (cause !== void 0 && cause !== null) return `${outer} (${String(cause)})`;
+  return outer;
+}
+var INVALID_HEADER = "a request header holds a character no request can carry (a line break, a control or a non-ASCII character), so nothing was sent. Check the credential's token for stray characters.";
+function isInvalidRequestHeader(err) {
+  const message = err instanceof Error ? err.message : "";
+  if (/is an invalid header value|Cannot convert argument to a ByteString/.test(message)) return true;
+  const cause = err?.cause;
+  return cause?.code === "UND_ERR_INVALID_ARG" && /header/i.test(String(cause.message ?? ""));
+}
+var TLS_CERTIFICATE_CODES = /* @__PURE__ */ new Set([
+  "DEPTH_ZERO_SELF_SIGNED_CERT",
+  "SELF_SIGNED_CERT_IN_CHAIN",
+  "UNABLE_TO_VERIFY_LEAF_SIGNATURE",
+  "UNABLE_TO_GET_ISSUER_CERT",
+  "UNABLE_TO_GET_ISSUER_CERT_LOCALLY",
+  "UNABLE_TO_DECRYPT_CERT_SIGNATURE",
+  "UNABLE_TO_DECODE_ISSUER_PUBLIC_KEY",
+  "CERT_SIGNATURE_FAILURE",
+  "CERT_NOT_YET_VALID",
+  "CERT_HAS_EXPIRED",
+  "CERT_REVOKED",
+  "CERT_UNTRUSTED",
+  "CERT_REJECTED",
+  "CERT_CHAIN_TOO_LONG",
+  "INVALID_CA",
+  "INVALID_PURPOSE",
+  "HOSTNAME_MISMATCH",
+  "ERR_TLS_CERT_ALTNAME_INVALID",
+  "ERR_TLS_CERT_ALTNAME_FORMAT"
+]);
+var PROXY_CERTIFICATE_CODES = /* @__PURE__ */ new Set(["SELF_SIGNED_CERT_IN_CHAIN", "UNABLE_TO_GET_ISSUER_CERT_LOCALLY"]);
+function certificateFailureCode(err) {
+  for (let e = err, depth = 0; e !== void 0 && e !== null && depth < 8; depth++) {
+    const code = e.code;
+    if (typeof code === "string" && TLS_CERTIFICATE_CODES.has(code)) return code;
+    e = e.cause;
+  }
+  return void 0;
+}
+function certificateFailureHost(err) {
+  for (let e = err, depth = 0; e !== void 0 && e !== null && depth < 8; depth++) {
+    const m = e instanceof Error ? /could not reach (https?:\/\/[^\s/]+?)(?=: |\/| |$)/.exec(e.message) : null;
+    if (m !== null) {
+      try {
+        return new URL(m[1]).host;
+      } catch {
+        break;
+      }
+    }
+    e = e.cause;
+  }
+  return "the server";
+}
+var UNTRUSTED_CERTIFICATE = "the server's TLS certificate is not trusted";
+function describeCertificateFailure(code) {
+  const proxy = PROXY_CERTIFICATE_CODES.has(code) ? " If a corporate proxy re-signs HTTPS traffic, point NODE_EXTRA_CA_CERTS at its CA certificate file." : "";
+  return `${UNTRUSTED_CERTIFICATE} (${code}), so nothing was sent \u2014 a certificate or proxy configuration problem, not a network blip, and retrying will not help until it is fixed.${proxy}`;
+}
+function isBlockedPort(err) {
+  const cause = err?.cause;
+  return cause instanceof Error && cause.message === "bad port";
+}
+function isTimeoutError(err) {
+  return typeof err?.name === "string" && err.name === "TimeoutError";
+}
+function seconds(ms) {
+  return `${Number((ms / 1e3).toFixed(1))}s`;
+}
+function transportTarget(url) {
+  let parsed;
+  try {
+    parsed = new URL(url);
+  } catch {
+    return "the instance";
+  }
+  const cut = parsed.pathname.search(/\/api:/);
+  const path = (cut === -1 ? parsed.pathname : parsed.pathname.slice(0, cut)).replace(/\/$/, "");
+  return `${parsed.origin}${path}`;
+}
+function explainFetchFailure(err, opts) {
+  const where = opts.display ?? transportTarget(opts.url);
+  const redirected = redirectFailure(err, opts.url);
+  if (redirected !== void 0) {
+    const head = `${opts.what}: ${where} ${redirected}`;
+    return new TransportError(opts.aftermath === void 0 ? head : `${head}
+${opts.aftermath}`, false, { cause: err });
+  }
+  const timeout = isTimeoutError(err);
+  const within = opts.timeoutMs !== void 0 ? ` within ${seconds(opts.timeoutMs)}` : "";
+  if (opts.aftermath !== void 0 && !isBlockedPort(err) && certificateFailureCode(err) === void 0) {
+    const head = timeout ? `${opts.what}: ${where} did not answer${within}. The instance may still be starting up or under load.` : closeSentence(`${opts.what} could not reach ${where}: ${describeTransportFailure(err)}`);
+    return new TransportError(`${head}
+${opts.aftermath}`, timeout, { cause: err });
+  }
+  const message = timeout ? `${opts.what}: ${where} did not answer${within}. The instance may still be starting up or under load \u2014 retry, or raise the wait.` : `${opts.what} could not reach ${where}: ${describeTransportFailure(err)}`;
+  return new TransportError(message, timeout, { cause: err });
+}
+function redirectedUnresolvedHost(err, url) {
+  let own;
+  try {
+    own = new URL(url).hostname;
+  } catch {
+    return void 0;
+  }
+  for (let e = err, depth = 0; e !== void 0 && e !== null && depth < 5; depth++) {
+    const { code, hostname } = e;
+    if (code === "ENOTFOUND" && typeof hostname === "string" && hostname !== "") {
+      return hostname.replace(/^\[|\]$/g, "") === own.replace(/^\[|\]$/g, "") ? void 0 : hostname;
+    }
+    e = e.cause;
+  }
+  return void 0;
+}
+var BLOCKED_PORTS = /* @__PURE__ */ new Set([
+  1,
+  7,
+  9,
+  11,
+  13,
+  15,
+  17,
+  19,
+  20,
+  21,
+  22,
+  23,
+  25,
+  37,
+  42,
+  43,
+  53,
+  69,
+  77,
+  79,
+  87,
+  95,
+  101,
+  102,
+  103,
+  104,
+  109,
+  110,
+  111,
+  113,
+  115,
+  117,
+  119,
+  123,
+  135,
+  137,
+  139,
+  143,
+  161,
+  179,
+  389,
+  427,
+  465,
+  512,
+  513,
+  514,
+  515,
+  526,
+  530,
+  531,
+  532,
+  540,
+  548,
+  554,
+  556,
+  563,
+  587,
+  601,
+  636,
+  989,
+  990,
+  993,
+  995,
+  1719,
+  1720,
+  1723,
+  2049,
+  3659,
+  4045,
+  4190,
+  5060,
+  5061,
+  6e3,
+  6566,
+  6665,
+  6666,
+  6667,
+  6668,
+  6669,
+  6679,
+  6697,
+  10080
+]);
+function redirectFailure(err, url) {
+  let own;
+  try {
+    own = new URL(url);
+  } catch {
+    return void 0;
+  }
+  const unresolved = redirectedUnresolvedHost(err, url);
+  if (unresolved !== void 0) return `redirected to ${unresolved}, which does not resolve (ENOTFOUND). Check where that host points.`;
+  const ownHost = own.hostname.replace(/^\[|\]$/g, "");
+  const ownPort = own.port === "" ? own.protocol === "https:" ? "443" : "80" : own.port;
+  if (isBlockedPort(err)) {
+    return BLOCKED_PORTS.has(Number(ownPort)) ? void 0 : `redirected to a port fetch refuses to connect to (a blocked port, e.g. 1 or 25), so nothing was sent there. Check where that redirect points.`;
+  }
+  for (let e = err, depth = 0; e !== void 0 && e !== null && depth < 5; depth++) {
+    const { code, address, port } = e;
+    if (typeof code === "string" && typeof address === "string" && (typeof port === "number" || typeof port === "string")) {
+      const otherPort = String(port) !== ownPort;
+      const otherAddress = isIP(ownHost) !== 0 && address !== ownHost;
+      if (!otherPort && !otherAddress) return void 0;
+      const target = `${address.includes(":") ? `[${address}]` : address}:${port}`;
+      const what = code === "ECONNREFUSED" ? "which refused the connection" : "which could not be reached";
+      return `redirected to ${target}, ${what} (${code}). Check where that redirect points.`;
+    }
+    e = e.cause;
+  }
+  return void 0;
+}
+var READ_AFTERMATH = "Nothing was changed \u2014 retry.";
+function withoutReadAftermath(message) {
+  return message.split("\n").filter((line) => line !== READ_AFTERMATH).join("\n");
+}
+async function fetchOrExplain(url, init, what, timeoutMs, display) {
+  let res;
+  try {
+    res = await fetchPastRateLimit(url, init, isReadMethod(init));
+    await noteMetaAnswer(url, res);
+  } catch (err) {
+    if (isInvalidRequestHeader(err)) throw new UsageError(`${what}: ${INVALID_HEADER}`);
+    throw explainFetchFailure(err, {
+      url,
+      what,
+      timeoutMs,
+      display,
+      ...isReadMethod(init) ? { aftermath: READ_AFTERMATH } : {}
+    });
+  }
+  return explainingBody(res, {
+    url,
+    what,
+    ...timeoutMs !== void 0 ? { timeoutMs } : {},
+    ...display !== void 0 ? { display } : {},
+    ...isReadMethod(init) ? {} : { aftermath: SENT_AFTERMATH }
+  });
+}
+var READ_ATTEMPTS = 3;
+var READ_BACKOFF_MS = 400;
+var RATE_LIMIT_MAX_WAIT_S = 5;
+var RATE_LIMIT_RETRIES = 2;
+var lastRetryAfterS;
+function retryAfterSeconds(header, now = Date.now()) {
+  if (header === null || header.trim() === "") return void 0;
+  const t = header.trim();
+  if (/^\d+$/.test(t)) return Number(t);
+  const at = Date.parse(t);
+  return Number.isNaN(at) ? void 0 : Math.max(0, Math.ceil((at - now) / 1e3));
+}
+function noteRateLimit(res) {
+  if (res.status === 429) lastRetryAfterS = retryAfterSeconds(res.headers?.get?.("retry-after") ?? null);
+}
+function lastRateLimitRetryAfter() {
+  return lastRetryAfterS;
+}
+async function fetchPastRateLimit(url, init, read) {
+  for (let attempt = 0; ; attempt++) {
+    const res = await fetch(url, init);
+    if (res.status !== 429) return res;
+    noteRateLimit(res);
+    const after = lastRetryAfterS;
+    if (!read || attempt >= RATE_LIMIT_RETRIES) return res;
+    const wait = after ?? 2 ** attempt;
+    if (wait > RATE_LIMIT_MAX_WAIT_S) return res;
+    await res.body?.cancel().catch(() => void 0);
+    await new Promise((r) => setTimeout(r, wait * 1e3));
+  }
+}
+function isRetryableTransportFailure(err) {
+  if (isTimeoutError(err)) return false;
+  const code = err?.cause?.code;
+  return typeof code === "string" && ["ECONNREFUSED", "ECONNRESET", "ENOTFOUND", "EAI_AGAIN", "EPIPE", "ETIMEDOUT", "ENETUNREACH"].includes(code);
+}
+async function fetchReadOrExplain(url, init, what, timeoutMs) {
+  let res;
+  try {
+    res = await retryingFetch(url, init);
+  } catch (err) {
+    throw explainFetchFailure(err, { url, what, timeoutMs, aftermath: READ_AFTERMATH });
+  }
+  return explainingBody(res, { url, what, ...timeoutMs !== void 0 ? { timeoutMs } : {} });
+}
+async function retryingFetch(url, init) {
+  let last;
+  for (let attempt = 0; attempt < READ_ATTEMPTS; attempt++) {
+    try {
+      const res = await fetchPastRateLimit(url, init, true);
+      await noteMetaAnswer(url, res);
+      return res;
+    } catch (err) {
+      last = err;
+      if (!isRetryableTransportFailure(err) || attempt === READ_ATTEMPTS - 1) break;
+      await new Promise((r) => setTimeout(r, READ_BACKOFF_MS * 2 ** attempt));
+    }
+  }
+  throw last;
+}
+
+export {
+  inCredentialScope,
+  noteResolvedAuth,
+  lastResolvedAuth,
+  noteMetaAnswer,
+  pinnedWorkspaceMissed,
+  debugEnabled,
+  serverMessage,
+  markupSummary,
+  notJsonError,
+  unexpectedAnswerError,
+  parseJsonAnswer,
+  TransportError,
+  explainBodyFailure,
+  readBodyText,
+  readBodyBytes,
+  SENT_AFTERMATH,
+  writeRefusedBy,
+  writeStatusAftermath,
+  lostAnswerHead,
+  withWriteStatusAftermath,
+  statusLabel,
+  safeHttpFailure,
+  bindingFor,
+  explainBindingRefusal,
+  httpFailure,
+  closeSentence,
+  appendSentence,
+  httpFailureError,
+  describeTransportFailure,
+  TLS_CERTIFICATE_CODES,
+  certificateFailureCode,
+  certificateFailureHost,
+  UNTRUSTED_CERTIFICATE,
+  isTimeoutError,
+  transportTarget,
+  explainFetchFailure,
+  redirectedUnresolvedHost,
+  READ_AFTERMATH,
+  withoutReadAftermath,
+  fetchOrExplain,
+  RATE_LIMIT_MAX_WAIT_S,
+  retryAfterSeconds,
+  noteRateLimit,
+  lastRateLimitRetryAfter,
+  fetchReadOrExplain,
+  retryingFetch
+};
+//# sourceMappingURL=chunk-YLDALTWZ.js.map