@getstrata/core 2.2.38 → 2.2.40

package/dist/entries/auth/oauth/providers.js

@@ -85,245 +85,8 @@ function sdkClientClassName() {
   return fromName ? `${fromName}Client` : "AppClient";
 }
 
-// ../../src/core/security/safeUrl.ts
-import { lookup as dnsLookupImpl } from "dns/promises";
-import { BadRequestError } from "@getstrata/core/errors/http";
-var dnsLookup = dnsLookupImpl;
-var BLOCKED_HOSTNAMES = new Set([
-  "localhost",
-  "127.0.0.1",
-  "0.0.0.0",
-  "::1",
-  "metadata.google.internal"
-]);
-function parseCanonicalDottedDecimal(hostname) {
-  const parts = hostname.split(".");
-  if (parts.length !== 4) {
-    return null;
-  }
-  const octets = [];
-  for (const part of parts) {
-    if (!/^(0|[1-9]\d{0,2})$/u.test(part)) {
-      return null;
-    }
-    const value = Number.parseInt(part, 10);
-    if (!Number.isInteger(value) || value < 0 || value > 255) {
-      return null;
-    }
-    octets.push(value);
-  }
-  return octets;
-}
-function parseDottedIpv4(hostname) {
-  return parseCanonicalDottedDecimal(hostname);
-}
-function isBlockedIpv4Octets(octets) {
-  const [a = 0, b = 0] = octets;
-  if (a === 10 || a === 127 || a === 0) {
-    return true;
-  }
-  if (a === 169 && b === 254) {
-    return true;
-  }
-  if (a === 172 && b >= 16 && b <= 31) {
-    return true;
-  }
-  if (a === 192 && b === 168) {
-    return true;
-  }
-  if (a === 100 && b >= 64 && b <= 127) {
-    return true;
-  }
-  if (a === 198 && (b === 18 || b === 19)) {
-    return true;
-  }
-  return false;
-}
-function expandIpv6(hostname) {
-  const trimmed = hostname.trim().toLowerCase();
-  const unbracketed = trimmed.startsWith("[") && trimmed.endsWith("]") ? trimmed.slice(1, -1) : trimmed;
-  if (unbracketed.includes("%")) {
-    return null;
-  }
-  const mapped = unbracketed.match(/^::ffff:([0-9a-fx.]+)$/iu);
-  if (mapped?.[1]) {
-    const octets = parseDottedIpv4(mapped[1]);
-    if (!octets) {
-      return null;
-    }
-    return [
-      0,
-      0,
-      0,
-      0,
-      0,
-      65535,
-      octets[0] << 8 | octets[1],
-      octets[2] << 8 | octets[3]
-    ];
-  }
-  const halves = unbracketed.split("::");
-  if (halves.length > 2) {
-    return null;
-  }
-  const parseGroup = (part) => {
-    if (!/^[0-9a-f]{1,4}$/u.test(part)) {
-      return null;
-    }
-    return Number.parseInt(part, 16);
-  };
-  if (halves.length === 1) {
-    const groups = unbracketed.split(":");
-    if (groups.length !== 8) {
-      return null;
-    }
-    const values = groups.map(parseGroup);
-    return values.every((value) => value !== null) ? values : null;
-  }
-  const head = halves[0] ? halves[0].split(":").filter(Boolean) : [];
-  const tail = halves[1] ? halves[1].split(":").filter(Boolean) : [];
-  if (head.length + tail.length > 8) {
-    return null;
-  }
-  const values = [];
-  for (const part of head) {
-    const value = parseGroup(part);
-    if (value === null) {
-      return null;
-    }
-    values.push(value);
-  }
-  while (values.length < 8 - tail.length) {
-    values.push(0);
-  }
-  for (const part of tail) {
-    const value = parseGroup(part);
-    if (value === null) {
-      return null;
-    }
-    values.push(value);
-  }
-  return values.length === 8 ? values : null;
-}
-function isBlockedIpv6(hostname) {
-  const groups = expandIpv6(hostname);
-  if (!groups) {
-    return hostname.includes(":");
-  }
-  const first = groups[0] ?? 0;
-  const second = groups[1] ?? 0;
-  if (groups.every((group) => group === 0)) {
-    return true;
-  }
-  if (groups.slice(0, 7).every((group) => group === 0) && groups[7] === 1) {
-    return true;
-  }
-  if ((first & 65472) === 65152) {
-    return true;
-  }
-  if ((first & 65024) === 64512) {
-    return true;
-  }
-  if ((first & 65280) === 65280) {
-    return true;
-  }
-  if (first === 0 && second === 0 && groups[2] === 0 && groups[3] === 0 && groups[4] === 0 && groups[5] === 65535) {
-    const a = (groups[6] ?? 0) >> 8;
-    const b = (groups[6] ?? 0) & 255;
-    const c = (groups[7] ?? 0) >> 8;
-    const d = (groups[7] ?? 0) & 255;
-    return isBlockedIpv4Octets([a, b, c, d]);
-  }
-  return false;
-}
-function isBlockedHostname(hostname) {
-  const normalized = hostname.trim().toLowerCase();
-  if (normalized.length === 0) {
-    return true;
-  }
-  if (BLOCKED_HOSTNAMES.has(normalized)) {
-    return true;
-  }
-  if (normalized.endsWith(".local") || normalized.endsWith(".internal")) {
-    return true;
-  }
-  if (normalized.includes(":")) {
-    return isBlockedIpv6(normalized);
-  }
-  if (/^\d+$/u.test(normalized)) {
-    return true;
-  }
-  if (normalized.includes(".")) {
-    const canonical = parseCanonicalDottedDecimal(normalized);
-    if (canonical) {
-      return isBlockedIpv4Octets(canonical);
-    }
-    if (/^[0-9a-fx.]+$/iu.test(normalized)) {
-      return true;
-    }
-  }
-  return false;
-}
-function productionSafeOutboundOptions(options) {
-  if (!isProductionEnv()) {
-    return options;
-  }
-  return { ...options, allowPrivate: false, resolveDns: true };
-}
-function assertSafeOutboundUrl(rawUrl, options = {}) {
-  const resolved = productionSafeOutboundOptions(options);
-  let parsed;
-  try {
-    parsed = new URL(rawUrl);
-  } catch {
-    throw new BadRequestError("Webhook URL is invalid.");
-  }
-  if (parsed.protocol !== "https:" && !(resolved.allowHttp && parsed.protocol === "http:")) {
-    throw new BadRequestError("Webhook URL must use HTTPS.");
-  }
-  if (parsed.username || parsed.password) {
-    throw new BadRequestError("Webhook URL must not include credentials.");
-  }
-  if (!resolved.allowPrivate && isBlockedHostname(parsed.hostname)) {
-    throw new BadRequestError("Webhook URL targets a blocked host.");
-  }
-  return parsed;
-}
-function isBlockedIpAddress(address) {
-  return isBlockedHostname(address.trim().toLowerCase());
-}
-function isLiteralIpHostname(hostname) {
-  return parseCanonicalDottedDecimal(hostname) !== null || expandIpv6(hostname) !== null;
-}
-function pinUrlToAddress(url, address) {
-  const pinned = new URL(url.toString());
-  const ipv6 = expandIpv6(address.replace(/^\[|\]$/gu, ""));
-  pinned.hostname = ipv6 ? `[${address.replace(/^\[|\]$/gu, "")}]` : address;
-  return pinned;
-}
-async function resolveSafeOutboundTarget(rawUrl, options = {}) {
-  const resolvedOptions = productionSafeOutboundOptions(options);
-  const parsed = assertSafeOutboundUrl(rawUrl, resolvedOptions);
-  if (resolvedOptions.resolveDns === false || resolvedOptions.allowPrivate) {
-    return { url: parsed, addresses: [] };
-  }
-  const hostname = parsed.hostname.trim().toLowerCase();
-  if (isLiteralIpHostname(hostname)) {
-    return { url: parsed, addresses: [hostname] };
-  }
-  let results;
-  try {
-    results = await dnsLookup(hostname, { all: true, verbatim: true });
-  } catch {
-    throw new BadRequestError("Webhook URL targets a blocked host.");
-  }
-  if (results.length === 0 || results.some((result) => isBlockedIpAddress(result.address))) {
-    throw new BadRequestError("Webhook URL targets a blocked host.");
-  }
-  return { url: parsed, addresses: results.map((result) => result.address) };
-}
-
 // ../../src/core/security/safeFetch.ts
+import { pinUrlToAddress, resolveSafeOutboundTarget } from "@getstrata/core/security/safeUrl";
 var DEFAULT_FETCH_TIMEOUT_MS = 1e4;
 function untilAborted(work, signal) {
   signal.throwIfAborted();

package/dist/entries/http/metricsMiddleware.js

@@ -26,130 +26,8 @@ function createAsyncContextStore(key) {
 }
 var init_asyncContextStore = () => {};
 
-// ../../src/core/metrics/prometheus.ts
-var HTTP_DURATION_BUCKETS_MS = [5, 10, 25, 50, 100, 250, 500, 1000, 2500, 5000, 1e4];
-function emptyHistogram() {
-  return {
-    cumulative: HTTP_DURATION_BUCKETS_MS.map(() => 0),
-    sum: 0,
-    count: 0
-  };
-}
-
-class PrometheusRegistry {
-  maxSeries;
-  seriesLabels = new Map;
-  constructor(maxSeries = 4096) {
-    this.maxSeries = maxSeries;
-    if (!Number.isSafeInteger(maxSeries) || maxSeries < 1) {
-      throw new Error("Metrics maxSeries must be a positive safe integer.");
-    }
-  }
-  httpRequestsTotal = new Map;
-  httpRequestDurationMs = new Map;
-  incrementHttpRequest(labels) {
-    const key = this.metricKey(labels);
-    this.httpRequestsTotal.set(key, (this.httpRequestsTotal.get(key) ?? 0) + 1);
-  }
-  observeHttpDuration(labels, durationMs) {
-    if (!Number.isFinite(durationMs) || durationMs < 0)
-      return;
-    const key = this.metricKey(labels);
-    const histogram = this.httpRequestDurationMs.get(key) ?? emptyHistogram();
-    histogram.count += 1;
-    histogram.sum += durationMs;
-    for (let index = 0;index < HTTP_DURATION_BUCKETS_MS.length; index += 1) {
-      const bound = HTTP_DURATION_BUCKETS_MS[index];
-      if (bound !== undefined && durationMs <= bound) {
-        const count = histogram.cumulative[index] ?? 0;
-        histogram.cumulative[index] = count + 1;
-      }
-    }
-    this.httpRequestDurationMs.set(key, histogram);
-  }
-  renderMetrics() {
-    const lines = [
-      "# HELP http_requests_total Total HTTP requests processed.",
-      "# TYPE http_requests_total counter"
-    ];
-    for (const [key, value] of this.httpRequestsTotal) {
-      lines.push(`http_requests_total{${key}} ${value}`);
-    }
-    lines.push("# HELP http_request_duration_ms HTTP request duration in milliseconds.", "# TYPE http_request_duration_ms histogram");
-    for (const [key, histogram] of this.httpRequestDurationMs) {
-      for (let index = 0;index < HTTP_DURATION_BUCKETS_MS.length; index += 1) {
-        const bound = HTTP_DURATION_BUCKETS_MS[index];
-        lines.push(`http_request_duration_ms_bucket{${key},le="${bound}"} ${histogram.cumulative[index] ?? 0}`);
-      }
-      lines.push(`http_request_duration_ms_bucket{${key},le="+Inf"} ${histogram.count}`);
-      lines.push(`http_request_duration_ms_sum{${key}} ${histogram.sum}`);
-      lines.push(`http_request_duration_ms_count{${key}} ${histogram.count}`);
-    }
-    return `${lines.join(`
-`)}
-`;
-  }
-  resetForTests() {
-    this.seriesLabels.clear();
-    this.httpRequestsTotal.clear();
-    this.httpRequestDurationMs.clear();
-  }
-  getHttpRequestSummary() {
-    const byStatus = {};
-    const pathCounts = new Map;
-    let totalRequests = 0;
-    for (const [key, count] of this.httpRequestsTotal) {
-      totalRequests += count;
-      const labels = this.seriesLabels.get(key);
-      if (!labels)
-        continue;
-      const { method, path, status } = labels;
-      byStatus[status] = (byStatus[status] ?? 0) + count;
-      const pathKey = `${method} ${path}`;
-      const existing = pathCounts.get(pathKey);
-      if (existing) {
-        existing.count += count;
-      } else {
-        pathCounts.set(pathKey, { method, path, count });
-      }
-    }
-    const topPaths = Array.from(pathCounts.values()).sort((left, right) => right.count - left.count).slice(0, 10);
-    return {
-      totalRequests,
-      byStatus,
-      topPaths
-    };
-  }
-  getStorageStats() {
-    return {
-      series: this.seriesLabels.size,
-      histograms: this.httpRequestDurationMs.size,
-      bucketCounters: this.httpRequestDurationMs.size * HTTP_DURATION_BUCKETS_MS.length
-    };
-  }
-  metricKey(labels) {
-    const normalized = {
-      method: /^(GET|HEAD|POST|PUT|PATCH|DELETE|CONNECT|OPTIONS|TRACE)$/.test(labels.method) ? labels.method : "OTHER",
-      path: labels.path.length <= 512 ? labels.path : "__overflow__",
-      status: /^[1-5][0-9]{2}$/.test(labels.status) ? labels.status : "000"
-    };
-    const escapeLabel = (value) => value.replaceAll("\\", "\\\\").replaceAll(`
-`, "\\n").replaceAll('"', "\\\"");
-    const encode = (value) => `method="${value.method}",path="${escapeLabel(value.path)}",status="${value.status}"`;
-    let key = encode(normalized);
-    if (!this.seriesLabels.has(key)) {
-      if (this.seriesLabels.size >= this.maxSeries) {
-        const overflow = { method: "OTHER", path: "__overflow__", status: "000" };
-        key = encode(overflow);
-        this.seriesLabels.set(key, overflow);
-      } else {
-        this.seriesLabels.set(key, normalized);
-      }
-    }
-    return key;
-  }
-}
-var prometheusRegistry = new PrometheusRegistry;
+// ../../src/core/http/metricsMiddleware.ts
+import { prometheusRegistry } from "@getstrata/core/metrics/prometheus";
 
 // ../../src/core/http/requestMetaContext.ts
 init_asyncContextStore();

package/dist/entries/jobs/exportAuditLogsJob.js

@@ -995,10 +995,141 @@ function sdkClientClassName() {
   return fromName ? `${fromName}Client` : "AppClient";
 }
 
+// ../../src/core/security/safeFetch.ts
+import { pinUrlToAddress, resolveSafeOutboundTarget } from "@getstrata/core/security/safeUrl";
+var DEFAULT_FETCH_TIMEOUT_MS = 1e4;
+function untilAborted(work, signal) {
+  signal.throwIfAborted();
+  return new Promise((resolve, reject) => {
+    const onAbort = () => reject(signal.reason);
+    signal.addEventListener("abort", onAbort, { once: true });
+    work.then(resolve, reject).finally(() => signal.removeEventListener("abort", onAbort));
+  });
+}
+function preserveResponseMetadata(response, original) {
+  Object.defineProperties(response, {
+    url: { value: original.url },
+    redirected: { value: original.redirected },
+    type: { value: original.type }
+  });
+  const clone = response.clone.bind(response);
+  response.clone = () => preserveResponseMetadata(clone(), original);
+  return response;
+}
+function withBodyDeadline(response, signal, release) {
+  if (!response.body) {
+    release();
+    return response;
+  }
+  const reader = response.body.getReader();
+  let stopped = false;
+  let bodyController;
+  const stop = (reason, errorBody) => {
+    if (stopped)
+      return;
+    stopped = true;
+    release();
+    signal.removeEventListener("abort", onAbort);
+    if (errorBody)
+      bodyController.error(reason);
+    reader.cancel(reason).catch(() => {}).finally(() => reader.releaseLock());
+  };
+  const onAbort = () => stop(signal.reason, true);
+  const body = new ReadableStream({
+    start(controller) {
+      bodyController = controller;
+      signal.addEventListener("abort", onAbort, { once: true });
+      if (signal.aborted)
+        onAbort();
+    },
+    async pull(controller) {
+      try {
+        const result = await untilAborted(reader.read(), signal);
+        if (stopped)
+          return;
+        if (result.done) {
+          stopped = true;
+          release();
+          signal.removeEventListener("abort", onAbort);
+          reader.releaseLock();
+          controller.close();
+        } else {
+          controller.enqueue(result.value);
+        }
+      } catch (error) {
+        stop(error, true);
+      }
+    },
+    cancel(reason) {
+      stop(reason, false);
+    }
+  }, { highWaterMark: 0 });
+  return preserveResponseMetadata(new Response(body, {
+    status: response.status,
+    statusText: response.statusText,
+    headers: response.headers
+  }), response);
+}
+async function safeFetch(input, init = {}, options = {}) {
+  init.signal?.throwIfAborted();
+  const timeoutMs = options.timeoutMs ?? DEFAULT_FETCH_TIMEOUT_MS;
+  if (!Number.isFinite(timeoutMs) || timeoutMs <= 0) {
+    throw new RangeError("safeFetch timeoutMs must be a positive finite number.");
+  }
+  const maxRedirects = options.maxRedirects ?? 0;
+  const urlOptions = {
+    allowHttp: options.allowHttp,
+    resolveDns: options.resolveDns ?? true,
+    allowPrivate: options.allowPrivate
+  };
+  const controller = new AbortController;
+  const forwardAbort = () => controller.abort(init.signal?.reason);
+  init.signal?.addEventListener("abort", forwardAbort, { once: true });
+  const timeout = setTimeout(() => controller.abort(new DOMException("The operation timed out.", "TimeoutError")), timeoutMs);
+  const release = () => {
+    clearTimeout(timeout);
+    init.signal?.removeEventListener("abort", forwardAbort);
+  };
+  try {
+    let current = await untilAborted(resolveSafeOutboundTarget(input, urlOptions), controller.signal);
+    let redirectCount = 0;
+    while (true) {
+      controller.signal.throwIfAborted();
+      const address = current.addresses[0];
+      const fetchUrl = address ? pinUrlToAddress(current.url, address).toString() : current.url.toString();
+      const headers = new Headers(init.headers);
+      if (address && !headers.has("host"))
+        headers.set("Host", current.url.host);
+      const fetchInit = {
+        ...init,
+        headers,
+        signal: controller.signal,
+        redirect: "manual"
+      };
+      if (address)
+        fetchInit.tls = { serverName: current.url.hostname };
+      const response = await untilAborted(fetch(fetchUrl, fetchInit), controller.signal);
+      if (response.status >= 300 && response.status < 400) {
+        const location = response.headers.get("location");
+        if (location && redirectCount < maxRedirects) {
+          if (response.body)
+            await untilAborted(response.body.cancel(), controller.signal);
+          current = await untilAborted(resolveSafeOutboundTarget(new URL(location, current.url).toString(), urlOptions), controller.signal);
+          redirectCount++;
+          continue;
+        }
+      }
+      return withBodyDeadline(response, controller.signal, release);
+    }
+  } catch (error) {
+    controller.abort(error);
+    release();
+    throw error;
+  }
+}
+
 // ../../src/core/security/safeUrl.ts
-import { lookup as dnsLookupImpl } from "dns/promises";
 import { BadRequestError } from "@getstrata/core/errors/http";
-var dnsLookup = dnsLookupImpl;
 var BLOCKED_HOSTNAMES = new Set([
   "localhost",
   "127.0.0.1",
@@ -1199,171 +1330,6 @@ function assertSafeOutboundUrl(rawUrl, options = {}) {
   }
   return parsed;
 }
-function isBlockedIpAddress(address) {
-  return isBlockedHostname(address.trim().toLowerCase());
-}
-function isLiteralIpHostname(hostname) {
-  return parseCanonicalDottedDecimal(hostname) !== null || expandIpv6(hostname) !== null;
-}
-function pinUrlToAddress(url, address) {
-  const pinned = new URL(url.toString());
-  const ipv6 = expandIpv6(address.replace(/^\[|\]$/gu, ""));
-  pinned.hostname = ipv6 ? `[${address.replace(/^\[|\]$/gu, "")}]` : address;
-  return pinned;
-}
-async function resolveSafeOutboundTarget(rawUrl, options = {}) {
-  const resolvedOptions = productionSafeOutboundOptions(options);
-  const parsed = assertSafeOutboundUrl(rawUrl, resolvedOptions);
-  if (resolvedOptions.resolveDns === false || resolvedOptions.allowPrivate) {
-    return { url: parsed, addresses: [] };
-  }
-  const hostname = parsed.hostname.trim().toLowerCase();
-  if (isLiteralIpHostname(hostname)) {
-    return { url: parsed, addresses: [hostname] };
-  }
-  let results;
-  try {
-    results = await dnsLookup(hostname, { all: true, verbatim: true });
-  } catch {
-    throw new BadRequestError("Webhook URL targets a blocked host.");
-  }
-  if (results.length === 0 || results.some((result) => isBlockedIpAddress(result.address))) {
-    throw new BadRequestError("Webhook URL targets a blocked host.");
-  }
-  return { url: parsed, addresses: results.map((result) => result.address) };
-}
-
-// ../../src/core/security/safeFetch.ts
-var DEFAULT_FETCH_TIMEOUT_MS = 1e4;
-function untilAborted(work, signal) {
-  signal.throwIfAborted();
-  return new Promise((resolve, reject) => {
-    const onAbort = () => reject(signal.reason);
-    signal.addEventListener("abort", onAbort, { once: true });
-    work.then(resolve, reject).finally(() => signal.removeEventListener("abort", onAbort));
-  });
-}
-function preserveResponseMetadata(response, original) {
-  Object.defineProperties(response, {
-    url: { value: original.url },
-    redirected: { value: original.redirected },
-    type: { value: original.type }
-  });
-  const clone = response.clone.bind(response);
-  response.clone = () => preserveResponseMetadata(clone(), original);
-  return response;
-}
-function withBodyDeadline(response, signal, release) {
-  if (!response.body) {
-    release();
-    return response;
-  }
-  const reader = response.body.getReader();
-  let stopped = false;
-  let bodyController;
-  const stop = (reason, errorBody) => {
-    if (stopped)
-      return;
-    stopped = true;
-    release();
-    signal.removeEventListener("abort", onAbort);
-    if (errorBody)
-      bodyController.error(reason);
-    reader.cancel(reason).catch(() => {}).finally(() => reader.releaseLock());
-  };
-  const onAbort = () => stop(signal.reason, true);
-  const body = new ReadableStream({
-    start(controller) {
-      bodyController = controller;
-      signal.addEventListener("abort", onAbort, { once: true });
-      if (signal.aborted)
-        onAbort();
-    },
-    async pull(controller) {
-      try {
-        const result = await untilAborted(reader.read(), signal);
-        if (stopped)
-          return;
-        if (result.done) {
-          stopped = true;
-          release();
-          signal.removeEventListener("abort", onAbort);
-          reader.releaseLock();
-          controller.close();
-        } else {
-          controller.enqueue(result.value);
-        }
-      } catch (error) {
-        stop(error, true);
-      }
-    },
-    cancel(reason) {
-      stop(reason, false);
-    }
-  }, { highWaterMark: 0 });
-  return preserveResponseMetadata(new Response(body, {
-    status: response.status,
-    statusText: response.statusText,
-    headers: response.headers
-  }), response);
-}
-async function safeFetch(input, init = {}, options = {}) {
-  init.signal?.throwIfAborted();
-  const timeoutMs = options.timeoutMs ?? DEFAULT_FETCH_TIMEOUT_MS;
-  if (!Number.isFinite(timeoutMs) || timeoutMs <= 0) {
-    throw new RangeError("safeFetch timeoutMs must be a positive finite number.");
-  }
-  const maxRedirects = options.maxRedirects ?? 0;
-  const urlOptions = {
-    allowHttp: options.allowHttp,
-    resolveDns: options.resolveDns ?? true,
-    allowPrivate: options.allowPrivate
-  };
-  const controller = new AbortController;
-  const forwardAbort = () => controller.abort(init.signal?.reason);
-  init.signal?.addEventListener("abort", forwardAbort, { once: true });
-  const timeout = setTimeout(() => controller.abort(new DOMException("The operation timed out.", "TimeoutError")), timeoutMs);
-  const release = () => {
-    clearTimeout(timeout);
-    init.signal?.removeEventListener("abort", forwardAbort);
-  };
-  try {
-    let current = await untilAborted(resolveSafeOutboundTarget(input, urlOptions), controller.signal);
-    let redirectCount = 0;
-    while (true) {
-      controller.signal.throwIfAborted();
-      const address = current.addresses[0];
-      const fetchUrl = address ? pinUrlToAddress(current.url, address).toString() : current.url.toString();
-      const headers = new Headers(init.headers);
-      if (address && !headers.has("host"))
-        headers.set("Host", current.url.host);
-      const fetchInit = {
-        ...init,
-        headers,
-        signal: controller.signal,
-        redirect: "manual"
-      };
-      if (address)
-        fetchInit.tls = { serverName: current.url.hostname };
-      const response = await untilAborted(fetch(fetchUrl, fetchInit), controller.signal);
-      if (response.status >= 300 && response.status < 400) {
-        const location = response.headers.get("location");
-        if (location && redirectCount < maxRedirects) {
-          if (response.body)
-            await untilAborted(response.body.cancel(), controller.signal);
-          current = await untilAborted(resolveSafeOutboundTarget(new URL(location, current.url).toString(), urlOptions), controller.signal);
-          redirectCount++;
-          continue;
-        }
-      }
-      return withBodyDeadline(response, controller.signal, release);
-    }
-  } catch (error) {
-    controller.abort(error);
-    release();
-    throw error;
-  }
-}
 
 // ../../src/core/audit/exportAuditLogs.ts
 init_databaseTenantContext();