@caido-utils/backend 1.7.0 → 1.8.1

package/dist/http/client/index.d.ts

@@ -0,0 +1,6 @@
+export { applyCloseConnection, applyContentLength } from "./normalize";
+export { RawHttpClient, type BatchCallbacks, type RawHttpSettings, type RawRequest, } from "./raw";
+export { checkSignal, waitForUnpause } from "./signal";
+export { HttpClient } from "./spec";
+export { resolveRedirectUrl, sendRawRequest } from "./transport";
+export type { HttpClientOptions, HttpClientRequest, HttpClientResponse, HttpMethod, RawHttpConfig, RawSendResult, RedirectPolicy, Result, Signal, } from "./types";

package/dist/http/client/index.js

@@ -0,0 +1,7 @@
+export { applyCloseConnection, applyContentLength } from "./normalize.js";
+export {
+  RawHttpClient
+} from "./raw.js";
+export { checkSignal, waitForUnpause } from "./signal.js";
+export { HttpClient } from "./spec.js";
+export { resolveRedirectUrl, sendRawRequest } from "./transport.js";

package/dist/http/client/normalize.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Ensure Connection: close header is present in the raw request.
+ */
+export declare function applyCloseConnection(raw: string): string;
+/**
+ * Recalculate and set the Content-Length header based on the body.
+ * Uses string length as a byte proxy — raw HTTP bodies from Caido are
+ * single-byte encoded, so string length matches byte length.
+ */
+export declare function applyContentLength(raw: string): string;

package/dist/http/client/normalize.js

@@ -0,0 +1,27 @@
+export function applyCloseConnection(raw) {
+  const headerEnd = raw.indexOf("\r\n\r\n");
+  if (headerEnd === -1) return raw;
+  const headerSection = raw.slice(0, headerEnd);
+  if (/^Connection\s*:/im.test(headerSection)) {
+    return raw.replace(/^Connection\s*:.*$/im, "Connection: close");
+  }
+  return raw.slice(0, headerEnd) + "\r\nConnection: close" + raw.slice(headerEnd);
+}
+export function applyContentLength(raw) {
+  const headerEnd = raw.indexOf("\r\n\r\n");
+  if (headerEnd === -1) return raw;
+  const body = raw.slice(headerEnd + 4);
+  const bodyLength = body.length;
+  const headerSection = raw.slice(0, headerEnd);
+  if (/^Content-Length\s*:/im.test(headerSection)) {
+    return headerSection.replace(
+      /^Content-Length\s*:.*$/im,
+      `Content-Length: ${bodyLength}`
+    ) + raw.slice(headerEnd);
+  }
+  if (bodyLength > 0) {
+    return headerSection + `\r
+Content-Length: ${bodyLength}` + raw.slice(headerEnd);
+  }
+  return raw;
+}

package/dist/http/client/raw.d.ts

@@ -0,0 +1,49 @@
+import type { SDK } from "caido:plugin";
+import type { RawSendResult, RedirectPolicy } from "./types";
+export type RawHttpSettings = {
+    threads: number;
+    delay: number;
+    redirection: {
+        max: number;
+        strategy: RedirectPolicy;
+    };
+    retry: {
+        max: number;
+        delay: number;
+    };
+    normalization: {
+        closeConnection: boolean;
+        updateContentLength: boolean;
+    };
+};
+export type RawRequest = {
+    url: string;
+    raw: string;
+};
+export type BatchCallbacks = {
+    onResult?: (result: RawSendResult, index: number) => void;
+    onError?: (error: string, index: number) => void;
+    onDone?: (total: number) => void;
+};
+export declare class RawHttpClient {
+    settings: RawHttpSettings;
+    private sdk;
+    private signal;
+    private queue;
+    constructor(sdk: SDK, settings?: Partial<RawHttpSettings>);
+    /**
+     * Send a single request. Returns the result.
+     */
+    send(request: RawRequest): Promise<RawSendResult>;
+    /**
+     * Send multiple requests through a concurrent queue.
+     * Results are delivered via callbacks.
+     */
+    send(requests: RawRequest[], callbacks?: BatchCallbacks): Promise<void>;
+    pause(): void;
+    resume(): void;
+    stop(): void;
+    private toConfig;
+    private sendSingle;
+    private sendBatch;
+}

package/dist/http/client/raw.js

@@ -0,0 +1,97 @@
+import { Queue } from "../../pool/pool.js";
+import { sendRawRequest } from "./transport.js";
+import { checkSignal, waitForUnpause } from "./signal.js";
+const DEFAULT_SETTINGS = {
+  threads: 1,
+  delay: 0,
+  redirection: { max: 5, strategy: "never" },
+  retry: { max: 0, delay: 1e3 },
+  normalization: { closeConnection: false, updateContentLength: true }
+};
+export class RawHttpClient {
+  settings;
+  sdk;
+  signal;
+  queue;
+  constructor(sdk, settings) {
+    this.sdk = sdk;
+    this.signal = { stopped: false, paused: false };
+    this.settings = { ...DEFAULT_SETTINGS, ...settings };
+  }
+  async send(input, callbacks) {
+    if (!Array.isArray(input)) {
+      return this.sendSingle(input);
+    }
+    return this.sendBatch(input, callbacks);
+  }
+  pause() {
+    this.signal.paused = true;
+    this.queue?.pause();
+  }
+  resume() {
+    this.signal.paused = false;
+    this.queue?.resume();
+  }
+  stop() {
+    this.signal.stopped = true;
+    this.queue?.stop();
+    this.queue = void 0;
+  }
+  toConfig() {
+    return {
+      redirectPolicy: this.settings.redirection.strategy,
+      maxRedirects: this.settings.redirection.max,
+      maxRetries: this.settings.retry.max,
+      retryDelayMs: this.settings.retry.delay,
+      closeConnection: this.settings.normalization.closeConnection,
+      updateContentLength: this.settings.normalization.updateContentLength
+    };
+  }
+  sendSingle(request) {
+    return sendRawRequest(
+      this.sdk,
+      request.url,
+      request.raw,
+      this.toConfig()
+    );
+  }
+  sendBatch(requests, callbacks) {
+    this.signal = { stopped: false, paused: false };
+    return new Promise((resolve) => {
+      const signal = this.signal;
+      const config = this.toConfig();
+      const queue = new Queue(
+        { concurrency: this.settings.threads, delayMs: this.settings.delay },
+        async (item) => {
+          if (checkSignal(signal) === "stopped") return;
+          await waitForUnpause(signal);
+          if (checkSignal(signal) === "stopped") return;
+          const result = await sendRawRequest(
+            this.sdk,
+            item.request.url,
+            item.request.raw,
+            config,
+            signal
+          );
+          callbacks?.onResult?.(result, item.index);
+        },
+        {
+          onError: (item, error) => {
+            callbacks?.onError?.(error, item.index);
+          }
+        }
+      );
+      this.queue = queue;
+      const items = requests.map((request, index) => ({ request, index }));
+      queue.enqueue(items);
+      const checkDone = setInterval(() => {
+        if (!queue.isRunning() && queue.pending === 0) {
+          clearInterval(checkDone);
+          callbacks?.onDone?.(queue.completed);
+          this.queue = void 0;
+          resolve();
+        }
+      }, 200);
+    });
+  }
+}

package/dist/http/client/transport.d.ts

@@ -0,0 +1,7 @@
+import type { SDK } from "caido:plugin";
+import type { RawHttpConfig, RawSendResult, Signal } from "./types";
+export declare function resolveRedirectUrl(currentUrl: string, location: string): string;
+/**
+ * Send a raw HTTP request with optional normalization, retry, and redirect support.
+ */
+export declare function sendRawRequest(sdk: SDK, url: string, raw: string, config?: RawHttpConfig, signal?: Signal): Promise<RawSendResult>;

package/dist/http/client/transport.js

@@ -0,0 +1,131 @@
+import { RequestSpec, RequestSpecRaw } from "caido:utils";
+import { applyCloseConnection, applyContentLength } from "./normalize.js";
+import { checkSignal, waitForUnpause } from "./signal.js";
+const REDIRECT_CODES = [301, 302, 303, 307, 308];
+function delay(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+export function resolveRedirectUrl(currentUrl, location) {
+  if (location.startsWith("http://") || location.startsWith("https://")) {
+    return location;
+  }
+  const url = new URL(currentUrl);
+  if (location.startsWith("/")) {
+    return `${url.protocol}//${url.host}${location}`;
+  }
+  const basePath = url.pathname.substring(
+    0,
+    url.pathname.lastIndexOf("/") + 1
+  );
+  return `${url.protocol}//${url.host}${basePath}${location}`;
+}
+async function sendWithRetry(sdk, url, raw, useRawSpec, maxRetries, retryDelayMs, signal) {
+  let lastError;
+  for (let attempt = 0; attempt <= maxRetries; attempt++) {
+    if (signal && checkSignal(signal) === "stopped") {
+      return {
+        statusCode: 0,
+        roundtripTime: 0,
+        responseSize: 0,
+        rawRequest: raw,
+        rawResponse: "",
+        error: "Stopped"
+      };
+    }
+    if (attempt > 0) {
+      await delay(retryDelayMs * attempt);
+      if (signal) {
+        await waitForUnpause(signal);
+        if (checkSignal(signal) === "stopped") {
+          return {
+            statusCode: 0,
+            roundtripTime: 0,
+            responseSize: 0,
+            rawRequest: raw,
+            rawResponse: "",
+            error: "Stopped"
+          };
+        }
+      }
+    }
+    try {
+      let response;
+      if (useRawSpec) {
+        const spec = new RequestSpecRaw(url);
+        spec.setRaw(raw);
+        response = await sdk.requests.send(spec);
+      } else {
+        const spec = new RequestSpec(url);
+        response = await sdk.requests.send(spec);
+      }
+      const statusCode = response.response.getCode();
+      if (attempt < maxRetries && (statusCode === 429 || statusCode >= 500)) {
+        lastError = `HTTP ${statusCode}`;
+        continue;
+      }
+      return {
+        statusCode,
+        roundtripTime: response.response.getRoundtripTime(),
+        responseSize: response.response.getRaw().toBytes().length,
+        rawRequest: response.request.getRaw().toText(),
+        rawResponse: response.response.getRaw().toText()
+      };
+    } catch (err) {
+      lastError = err instanceof Error ? err.message : "Unknown error";
+      if (attempt < maxRetries) continue;
+    }
+  }
+  return {
+    statusCode: 0,
+    roundtripTime: 0,
+    responseSize: 0,
+    rawRequest: raw,
+    rawResponse: "",
+    error: lastError
+  };
+}
+export async function sendRawRequest(sdk, url, raw, config, signal) {
+  const maxRetries = config?.maxRetries ?? 0;
+  const retryDelayMs = config?.retryDelayMs ?? 1e3;
+  const redirectPolicy = config?.redirectPolicy ?? "never";
+  const maxRedirects = config?.maxRedirects ?? 5;
+  let processedRaw = raw;
+  if (config?.closeConnection) {
+    processedRaw = applyCloseConnection(processedRaw);
+  }
+  if (config?.updateContentLength) {
+    processedRaw = applyContentLength(processedRaw);
+  }
+  let currentUrl = url;
+  let currentRaw = processedRaw;
+  let useRawSpec = true;
+  let redirectCount = 0;
+  for (; ; ) {
+    const result = await sendWithRetry(
+      sdk,
+      currentUrl,
+      currentRaw,
+      useRawSpec,
+      maxRetries,
+      retryDelayMs,
+      signal
+    );
+    if (redirectPolicy !== "never" && REDIRECT_CODES.includes(result.statusCode) && redirectCount < maxRedirects) {
+      const locationMatch = result.rawResponse.match(
+        /^Location\s*:\s*(.+)$/im
+      );
+      if (locationMatch?.[1]) {
+        const location = locationMatch[1].trim();
+        currentUrl = resolveRedirectUrl(currentUrl, location);
+        currentRaw = `GET ${new URL(currentUrl).pathname}${new URL(currentUrl).search} HTTP/1.1\r
+Host: ${new URL(currentUrl).host}\r
+\r
+`;
+        useRawSpec = true;
+        redirectCount++;
+        continue;
+      }
+    }
+    return result;
+  }
+}

package/dist/http/{types.d.ts → client/types.d.ts}

@@ -34,3 +34,20 @@ export type HttpClientResponse = {
     url: string;
     caidoId: string | undefined;
 };
+export type RedirectPolicy = "always" | "in-scope" | "same-site" | "never";
+export type RawHttpConfig = {
+    redirectPolicy?: RedirectPolicy;
+    maxRedirects?: number;
+    maxRetries?: number;
+    retryDelayMs?: number;
+    closeConnection?: boolean;
+    updateContentLength?: boolean;
+};
+export type RawSendResult = {
+    statusCode: number;
+    roundtripTime: number;
+    responseSize: number;
+    rawRequest: string;
+    rawResponse: string;
+    error?: string;
+};

package/dist/http/helpers/index.d.ts

@@ -0,0 +1,5 @@
+export { filterAuthHeaders } from "./headers";
+export { queryRequests, type QueryRequestsOptions } from "./query";
+export { HttpRequest, type HttpRequestOptions } from "./request";
+export { getStatusText } from "./status";
+export { parseUrl } from "./url";

package/dist/http/helpers/index.js

@@ -0,0 +1,5 @@
+export { filterAuthHeaders } from "./headers.js";
+export { queryRequests } from "./query.js";
+export { HttpRequest } from "./request.js";
+export { getStatusText } from "./status.js";
+export { parseUrl } from "./url.js";

package/dist/http/index.d.ts

@@ -1,6 +1,2 @@
-export { HttpClient } from "./client";
-export { HttpRequest, type HttpRequestOptions } from "./request";
-export { checkSignal, waitForUnpause } from "./signal";
-export { getStatusText } from "./status";
-export type { HttpClientOptions, HttpClientRequest, HttpClientResponse, HttpMethod, Result, Signal, } from "./types";
-export { parseUrl } from "./url";
+export { applyCloseConnection, applyContentLength, checkSignal, HttpClient, RawHttpClient, resolveRedirectUrl, sendRawRequest, waitForUnpause, type BatchCallbacks, type HttpClientOptions, type HttpClientRequest, type HttpClientResponse, type HttpMethod, type RawHttpConfig, type RawHttpSettings, type RawRequest, type RawSendResult, type RedirectPolicy, type Result, type Signal, } from "./client";
+export { filterAuthHeaders, getStatusText, HttpRequest, parseUrl, queryRequests, type HttpRequestOptions, type QueryRequestsOptions, } from "./helpers";

package/dist/http/index.js

@@ -1,5 +1,17 @@
-export { HttpClient } from "./client.js";
-export { HttpRequest } from "./request.js";
-export { checkSignal, waitForUnpause } from "./signal.js";
-export { getStatusText } from "./status.js";
-export { parseUrl } from "./url.js";
+export {
+  applyCloseConnection,
+  applyContentLength,
+  checkSignal,
+  HttpClient,
+  RawHttpClient,
+  resolveRedirectUrl,
+  sendRawRequest,
+  waitForUnpause
+} from "./client/index.js";
+export {
+  filterAuthHeaders,
+  getStatusText,
+  HttpRequest,
+  parseUrl,
+  queryRequests
+} from "./helpers/index.js";

package/dist/index.d.ts

@@ -1,9 +1,10 @@
 export { spawnCommand } from "./process";
 export { sha256 } from "./crypto";
 export { resolveFilterQuery } from "./filter";
-export { HttpClient, HttpRequest, checkSignal, getStatusText, parseUrl, waitForUnpause, type HttpClientOptions, type HttpClientRequest, type HttpClientResponse, type HttpMethod, type HttpRequestOptions, type Result, type Signal, } from "./http";
+export { HttpClient, HttpRequest, RawHttpClient, applyCloseConnection, applyContentLength, checkSignal, filterAuthHeaders, getStatusText, parseUrl, queryRequests, resolveRedirectUrl, sendRawRequest, waitForUnpause, type BatchCallbacks, type HttpClientOptions, type HttpClientRequest, type HttpClientResponse, type HttpMethod, type HttpRequestOptions, type QueryRequestsOptions, type RawHttpConfig, type RawHttpSettings, type RawRequest, type RawSendResult, type RedirectPolicy, type Result, type Signal, } from "./http";
+export { JobManager, WorkerPool } from "./jobs";
+export type { Job, JobSignal, JobStatus } from "./jobs";
 export { Queue } from "./pool";
 export type { PoolCallbacks, PoolConfig } from "./pool";
 export { getProjectId } from "./project";
-export { Fetch, filterAuthHeaders, queryRequests, type FetchOptions, type QueryRequestsOptions, } from "./requests";
 export { deleteFile, fileExists, readFile, storeFile } from "./storage";

package/dist/index.js

@@ -4,16 +4,19 @@ export { resolveFilterQuery } from "./filter/index.js";
 export {
   HttpClient,
   HttpRequest,
+  RawHttpClient,
+  applyCloseConnection,
+  applyContentLength,
   checkSignal,
+  filterAuthHeaders,
   getStatusText,
   parseUrl,
+  queryRequests,
+  resolveRedirectUrl,
+  sendRawRequest,
   waitForUnpause
 } from "./http/index.js";
+export { JobManager, WorkerPool } from "./jobs/index.js";
 export { Queue } from "./pool/index.js";
 export { getProjectId } from "./project/index.js";
-export {
-  Fetch,
-  filterAuthHeaders,
-  queryRequests
-} from "./requests/index.js";
 export { deleteFile, fileExists, readFile, storeFile } from "./storage/index.js";

package/dist/jobs/index.d.ts

@@ -0,0 +1,3 @@
+export { JobManager } from "./manager";
+export { WorkerPool } from "./worker-pool";
+export type { Job, JobSignal, JobStatus } from "./types";

package/dist/jobs/index.js

@@ -0,0 +1,2 @@
+export { JobManager } from "./manager.js";
+export { WorkerPool } from "./worker-pool.js";

package/dist/jobs/manager.d.ts

@@ -0,0 +1,18 @@
+import type { Job } from "./types";
+export declare class JobManager<TType extends string = string> {
+    private jobs;
+    private completionListeners;
+    createJob(type: TType): Job<TType>;
+    getJob(id: string): Job<TType> | undefined;
+    getAllJobs(): Job<TType>[];
+    getJobsByType(type: TType): Job<TType>[];
+    completeJob(id: string): void;
+    failJob(id: string): void;
+    stopJob(id: string): void;
+    pauseJob(id: string): void;
+    resumeJob(id: string): void;
+    removeJob(id: string): void;
+    onJobDone(id: string, callback: () => void): void;
+    clearCompleted(): void;
+    private notifyDone;
+}

package/dist/jobs/manager.js

@@ -0,0 +1,98 @@
+let nextId = 1;
+function generateId() {
+  return String(nextId++);
+}
+export class JobManager {
+  jobs = /* @__PURE__ */ new Map();
+  completionListeners = /* @__PURE__ */ new Map();
+  createJob(type) {
+    const id = generateId();
+    const job = {
+      id,
+      type,
+      status: "running",
+      signal: { stopped: false, paused: false },
+      createdAt: Date.now()
+    };
+    this.jobs.set(id, job);
+    return job;
+  }
+  getJob(id) {
+    return this.jobs.get(id);
+  }
+  getAllJobs() {
+    return [...this.jobs.values()];
+  }
+  getJobsByType(type) {
+    return [...this.jobs.values()].filter((j) => j.type === type);
+  }
+  completeJob(id) {
+    const job = this.jobs.get(id);
+    if (job !== void 0 && job.status === "running") {
+      job.status = "completed";
+      this.notifyDone(id);
+    }
+  }
+  failJob(id) {
+    const job = this.jobs.get(id);
+    if (job !== void 0) {
+      job.status = "error";
+      this.notifyDone(id);
+    }
+  }
+  stopJob(id) {
+    const job = this.jobs.get(id);
+    if (job === void 0) return;
+    if (job.status !== "running" && job.status !== "paused") return;
+    job.signal.stopped = true;
+    job.status = "stopped";
+    this.notifyDone(id);
+  }
+  pauseJob(id) {
+    const job = this.jobs.get(id);
+    if (job === void 0) return;
+    if (job.status !== "running") return;
+    job.signal.paused = true;
+    job.status = "paused";
+  }
+  resumeJob(id) {
+    const job = this.jobs.get(id);
+    if (job === void 0) return;
+    if (job.status !== "paused") return;
+    job.signal.paused = false;
+    job.status = "running";
+  }
+  removeJob(id) {
+    const job = this.jobs.get(id);
+    if (job === void 0) return;
+    if (job.status === "running" || job.status === "paused") {
+      job.signal.stopped = true;
+      job.status = "stopped";
+    }
+    this.jobs.delete(id);
+  }
+  onJobDone(id, callback) {
+    const existing = this.completionListeners.get(id);
+    if (existing !== void 0) {
+      existing.push(callback);
+    } else {
+      this.completionListeners.set(id, [callback]);
+    }
+  }
+  clearCompleted() {
+    for (const [id, job] of this.jobs) {
+      if (job.status === "completed" || job.status === "error" || job.status === "stopped") {
+        this.jobs.delete(id);
+      }
+    }
+  }
+  notifyDone(id) {
+    const listeners = this.completionListeners.get(id);
+    if (listeners !== void 0) {
+      for (const cb of listeners) {
+        cb();
+      }
+      this.completionListeners.delete(id);
+    }
+  }
+}

package/dist/jobs/types.d.ts

@@ -0,0 +1,10 @@
+import type { Signal } from "../http/client/types";
+export type JobStatus = "running" | "paused" | "completed" | "error" | "stopped";
+export type { Signal as JobSignal };
+export type Job<TType extends string = string> = {
+    id: string;
+    type: TType;
+    status: JobStatus;
+    signal: Signal;
+    createdAt: number;
+};

package/dist/jobs/worker-pool.d.ts

@@ -0,0 +1,14 @@
+import type { JobManager } from "./manager";
+export declare class WorkerPool<TRequest> {
+    private readonly maxConcurrency;
+    private active;
+    private queue;
+    private dispatcher;
+    private jobManager;
+    constructor(maxConcurrency: number, dispatcher: (request: TRequest) => string, jobManager: JobManager);
+    submit(request: TRequest): void;
+    get pending(): number;
+    get running(): number;
+    private dispatch;
+    private drain;
+}

package/dist/jobs/worker-pool.js

@@ -0,0 +1,41 @@
+export class WorkerPool {
+  maxConcurrency;
+  active = 0;
+  queue = [];
+  dispatcher;
+  jobManager;
+  constructor(maxConcurrency, dispatcher, jobManager) {
+    this.maxConcurrency = maxConcurrency;
+    this.dispatcher = dispatcher;
+    this.jobManager = jobManager;
+  }
+  submit(request) {
+    if (this.active < this.maxConcurrency) {
+      this.dispatch({ request });
+    } else {
+      this.queue.push({ request });
+    }
+  }
+  get pending() {
+    return this.queue.length;
+  }
+  get running() {
+    return this.active;
+  }
+  dispatch(task) {
+    this.active++;
+    const jobId = this.dispatcher(task.request);
+    this.jobManager.onJobDone(jobId, () => {
+      this.active--;
+      this.drain();
+    });
+  }
+  drain() {
+    while (this.active < this.maxConcurrency && this.queue.length > 0) {
+      const next = this.queue.shift();
+      if (next !== void 0) {
+        this.dispatch(next);
+      }
+    }
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@caido-utils/backend",
-  "version": "1.7.0",
+  "version": "1.8.1",
   "type": "module",
   "files": [
     "dist"

package/dist/requests/fetcher.d.ts

@@ -1,17 +0,0 @@
-import type { SDK } from "caido:plugin";
-import type { RequestResponse, RequestSpec, RequestSpecRaw } from "caido:utils";
-export type FetchOptions = {
-    threads?: number;
-    delay?: number;
-};
-export declare class Fetch {
-    private sdk;
-    private threads;
-    private delay;
-    private active;
-    private queue;
-    constructor(sdk: SDK, options?: FetchOptions);
-    send(request: RequestSpec | RequestSpecRaw): Promise<RequestResponse>;
-    private drain;
-    private execute;
-}

package/dist/requests/fetcher.js

@@ -1,43 +0,0 @@
-function sleep(ms) {
-  if (ms <= 0) return Promise.resolve();
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-export class Fetch {
-  sdk;
-  threads;
-  delay;
-  active = 0;
-  queue = [];
-  constructor(sdk, options = {}) {
-    this.sdk = sdk;
-    this.threads = options.threads ?? 10;
-    this.delay = options.delay ?? 0;
-  }
-  send(request) {
-    return new Promise((resolve, reject) => {
-      this.queue.push({ request, resolve, reject });
-      this.drain();
-    });
-  }
-  drain() {
-    while (this.active < this.threads && this.queue.length > 0) {
-      const item = this.queue.shift();
-      this.active++;
-      this.execute(item);
-    }
-  }
-  async execute(item) {
-    try {
-      const result = await this.sdk.requests.send(item.request);
-      item.resolve(result);
-    } catch (err) {
-      item.reject(err);
-    } finally {
-      if (this.delay > 0) {
-        await sleep(this.delay);
-      }
-      this.active--;
-      this.drain();
-    }
-  }
-}

package/dist/requests/index.d.ts

@@ -1,3 +0,0 @@
-export { Fetch, type FetchOptions } from "./fetcher";
-export { filterAuthHeaders } from "./headers";
-export { queryRequests, type QueryRequestsOptions } from "./query";

package/dist/requests/index.js

@@ -1,3 +0,0 @@
-export { Fetch } from "./fetcher.js";
-export { filterAuthHeaders } from "./headers.js";
-export { queryRequests } from "./query.js";