rezo 1.0.41 → 1.0.43

package/dist/cache/navigation-history.js

@@ -0,0 +1,296 @@
+import fs from "node:fs";
+import path from "node:path";
+import { createHash } from "node:crypto";
+function detectRuntime() {
+  if (typeof globalThis.Bun !== "undefined")
+    return "bun";
+  if (typeof globalThis.Deno !== "undefined")
+    return "deno";
+  return "node";
+}
+async function createDatabase(dbPath) {
+  const runtime = detectRuntime();
+  if (runtime === "bun") {
+    const { Database } = await import("bun:sqlite");
+    const db = new Database(dbPath);
+    return {
+      run: (sql, ...params) => db.run(sql, ...params),
+      get: (sql, ...params) => db.query(sql).get(...params),
+      all: (sql, ...params) => db.query(sql).all(...params),
+      close: () => db.close()
+    };
+  }
+  if (runtime === "deno") {
+    try {
+      const { Database } = await import("node:sqlite");
+      const db = new Database(dbPath);
+      return {
+        run: (sql, ...params) => db.exec(sql, params),
+        get: (sql, ...params) => {
+          const stmt = db.prepare(sql);
+          return stmt.get(...params);
+        },
+        all: (sql, ...params) => {
+          const stmt = db.prepare(sql);
+          return stmt.all(...params);
+        },
+        close: () => db.close()
+      };
+    } catch {
+      throw new Error("Deno SQLite support requires Node.js compatibility mode");
+    }
+  }
+  const { DatabaseSync } = await import("node:sqlite");
+  const db = new DatabaseSync(dbPath);
+  return {
+    run: (sql, ...params) => {
+      const stmt = db.prepare(sql);
+      stmt.run(...params);
+    },
+    get: (sql, ...params) => {
+      const stmt = db.prepare(sql);
+      return stmt.get(...params);
+    },
+    all: (sql, ...params) => {
+      const stmt = db.prepare(sql);
+      return stmt.all(...params);
+    },
+    close: () => db.close()
+  };
+}
+
+export class NavigationHistory {
+  db = null;
+  options;
+  storeDir;
+  dbPath;
+  closed = false;
+  initPromise = null;
+  constructor(options = {}) {
+    this.options = {
+      storeDir: options.storeDir || "./navigation-history",
+      dbFileName: options.dbFileName || "navigation.db",
+      hashUrls: options.hashUrls ?? false
+    };
+    this.storeDir = path.resolve(this.options.storeDir);
+    this.dbPath = path.join(this.storeDir, this.options.dbFileName);
+    if (!fs.existsSync(this.storeDir)) {
+      fs.mkdirSync(this.storeDir, { recursive: true });
+    }
+  }
+  static async create(options = {}) {
+    const store = new NavigationHistory(options);
+    await store.initialize();
+    return store;
+  }
+  async initialize() {
+    if (this.initPromise)
+      return this.initPromise;
+    this.initPromise = (async () => {
+      this.db = await createDatabase(this.dbPath);
+      this.db.run(`
+        CREATE TABLE IF NOT EXISTS sessions (
+          sessionId TEXT PRIMARY KEY,
+          baseUrl TEXT NOT NULL,
+          startedAt INTEGER NOT NULL,
+          lastActivityAt INTEGER NOT NULL,
+          status TEXT DEFAULT 'running',
+          urlsVisited INTEGER DEFAULT 0,
+          urlsQueued INTEGER DEFAULT 0,
+          urlsFailed INTEGER DEFAULT 0,
+          metadata TEXT
+        )
+      `);
+      this.db.run(`
+        CREATE TABLE IF NOT EXISTS queue (
+          id INTEGER PRIMARY KEY AUTOINCREMENT,
+          sessionId TEXT NOT NULL,
+          urlKey TEXT NOT NULL,
+          originalUrl TEXT NOT NULL,
+          method TEXT DEFAULT 'GET',
+          priority INTEGER DEFAULT 0,
+          body TEXT,
+          headers TEXT,
+          metadata TEXT,
+          addedAt INTEGER NOT NULL,
+          UNIQUE(sessionId, urlKey)
+        )
+      `);
+      this.db.run(`
+        CREATE TABLE IF NOT EXISTS visited (
+          id INTEGER PRIMARY KEY AUTOINCREMENT,
+          sessionId TEXT NOT NULL,
+          urlKey TEXT NOT NULL,
+          originalUrl TEXT NOT NULL,
+          status INTEGER,
+          visitedAt INTEGER NOT NULL,
+          finalUrl TEXT,
+          contentType TEXT,
+          errorMessage TEXT,
+          UNIQUE(sessionId, urlKey)
+        )
+      `);
+      this.db.run("CREATE INDEX IF NOT EXISTS idx_queue_session ON queue(sessionId)");
+      this.db.run("CREATE INDEX IF NOT EXISTS idx_queue_priority ON queue(sessionId, priority DESC)");
+      this.db.run("CREATE INDEX IF NOT EXISTS idx_visited_session ON visited(sessionId)");
+      this.db.run("CREATE INDEX IF NOT EXISTS idx_sessions_status ON sessions(status)");
+    })();
+    return this.initPromise;
+  }
+  getUrlKey(url) {
+    if (this.options.hashUrls) {
+      return createHash("sha256").update(url).digest("hex");
+    }
+    return url;
+  }
+  async createSession(sessionId, baseUrl, metadata) {
+    if (this.closed || !this.db)
+      throw new Error("NavigationHistory is closed");
+    const now = Date.now();
+    const session = {
+      sessionId,
+      baseUrl,
+      startedAt: now,
+      lastActivityAt: now,
+      status: "running",
+      urlsVisited: 0,
+      urlsQueued: 0,
+      urlsFailed: 0,
+      metadata: metadata ? JSON.stringify(metadata) : undefined
+    };
+    this.db.run(`INSERT OR REPLACE INTO sessions (sessionId, baseUrl, startedAt, lastActivityAt, status, urlsVisited, urlsQueued, urlsFailed, metadata)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`, sessionId, baseUrl, now, now, "running", 0, 0, 0, session.metadata ?? null);
+    return session;
+  }
+  async getSession(sessionId) {
+    if (this.closed || !this.db)
+      throw new Error("NavigationHistory is closed");
+    return this.db.get("SELECT * FROM sessions WHERE sessionId = ?", sessionId);
+  }
+  async updateSessionStatus(sessionId, status) {
+    if (this.closed || !this.db)
+      throw new Error("NavigationHistory is closed");
+    this.db.run("UPDATE sessions SET status = ?, lastActivityAt = ? WHERE sessionId = ?", status, Date.now(), sessionId);
+  }
+  async updateSessionStats(sessionId, stats) {
+    if (this.closed || !this.db)
+      throw new Error("NavigationHistory is closed");
+    const updates = ["lastActivityAt = ?"];
+    const params = [Date.now()];
+    if (stats.urlsVisited !== undefined) {
+      updates.push("urlsVisited = ?");
+      params.push(stats.urlsVisited);
+    }
+    if (stats.urlsQueued !== undefined) {
+      updates.push("urlsQueued = ?");
+      params.push(stats.urlsQueued);
+    }
+    if (stats.urlsFailed !== undefined) {
+      updates.push("urlsFailed = ?");
+      params.push(stats.urlsFailed);
+    }
+    params.push(sessionId);
+    this.db.run(`UPDATE sessions SET ${updates.join(", ")} WHERE sessionId = ?`, ...params);
+  }
+  async addToQueue(sessionId, url, options = {}) {
+    if (this.closed || !this.db)
+      throw new Error("NavigationHistory is closed");
+    const urlKey = this.getUrlKey(url);
+    const existing = this.db.get("SELECT id FROM queue WHERE sessionId = ? AND urlKey = ?", sessionId, urlKey);
+    if (existing)
+      return false;
+    const isVisited = this.db.get("SELECT id FROM visited WHERE sessionId = ? AND urlKey = ?", sessionId, urlKey);
+    if (isVisited)
+      return false;
+    this.db.run(`INSERT INTO queue (sessionId, urlKey, originalUrl, method, priority, body, headers, metadata, addedAt)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`, sessionId, urlKey, url, options.method || "GET", options.priority || 0, options.body ? JSON.stringify(options.body) : null, options.headers ? JSON.stringify(options.headers) : null, options.metadata ? JSON.stringify(options.metadata) : null, Date.now());
+    return true;
+  }
+  async getNextFromQueue(sessionId) {
+    if (this.closed || !this.db)
+      throw new Error("NavigationHistory is closed");
+    const item = this.db.get("SELECT originalUrl as url, method, priority, body, headers, metadata, addedAt FROM queue WHERE sessionId = ? ORDER BY priority DESC, addedAt ASC LIMIT 1", sessionId);
+    return item;
+  }
+  async removeFromQueue(sessionId, url) {
+    if (this.closed || !this.db)
+      throw new Error("NavigationHistory is closed");
+    const urlKey = this.getUrlKey(url);
+    this.db.run("DELETE FROM queue WHERE sessionId = ? AND urlKey = ?", sessionId, urlKey);
+    return true;
+  }
+  async getQueueSize(sessionId) {
+    if (this.closed || !this.db)
+      throw new Error("NavigationHistory is closed");
+    const result = this.db.get("SELECT COUNT(*) as count FROM queue WHERE sessionId = ?", sessionId);
+    return result?.count || 0;
+  }
+  async markVisited(sessionId, url, result = {}) {
+    if (this.closed || !this.db)
+      throw new Error("NavigationHistory is closed");
+    const urlKey = this.getUrlKey(url);
+    this.db.run("DELETE FROM queue WHERE sessionId = ? AND urlKey = ?", sessionId, urlKey);
+    this.db.run(`INSERT OR REPLACE INTO visited (sessionId, urlKey, originalUrl, status, visitedAt, finalUrl, contentType, errorMessage)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?)`, sessionId, urlKey, url, result.status || 0, Date.now(), result.finalUrl ?? null, result.contentType ?? null, result.errorMessage ?? null);
+  }
+  async isVisited(sessionId, url) {
+    if (this.closed || !this.db)
+      throw new Error("NavigationHistory is closed");
+    const urlKey = this.getUrlKey(url);
+    const result = this.db.get("SELECT id FROM visited WHERE sessionId = ? AND urlKey = ?", sessionId, urlKey);
+    return !!result;
+  }
+  async getVisitedCount(sessionId) {
+    if (this.closed || !this.db)
+      throw new Error("NavigationHistory is closed");
+    const result = this.db.get("SELECT COUNT(*) as count FROM visited WHERE sessionId = ?", sessionId);
+    return result?.count || 0;
+  }
+  async getFailedUrls(sessionId) {
+    if (this.closed || !this.db)
+      throw new Error("NavigationHistory is closed");
+    return this.db.all("SELECT url, status, visitedAt, finalUrl, contentType, errorMessage FROM visited WHERE sessionId = ? AND (status >= 400 OR errorMessage IS NOT NULL)", sessionId);
+  }
+  async getAllQueuedUrls(sessionId) {
+    if (this.closed || !this.db)
+      throw new Error("NavigationHistory is closed");
+    return this.db.all("SELECT originalUrl as url, method, priority, body, headers, metadata, addedAt FROM queue WHERE sessionId = ? ORDER BY priority DESC, addedAt ASC", sessionId);
+  }
+  async clearQueue(sessionId) {
+    if (this.closed || !this.db)
+      throw new Error("NavigationHistory is closed");
+    this.db.run("DELETE FROM queue WHERE sessionId = ?", sessionId);
+  }
+  async clearVisited(sessionId) {
+    if (this.closed || !this.db)
+      throw new Error("NavigationHistory is closed");
+    this.db.run("DELETE FROM visited WHERE sessionId = ?", sessionId);
+  }
+  async deleteSession(sessionId) {
+    if (this.closed || !this.db)
+      throw new Error("NavigationHistory is closed");
+    this.db.run("DELETE FROM queue WHERE sessionId = ?", sessionId);
+    this.db.run("DELETE FROM visited WHERE sessionId = ?", sessionId);
+    this.db.run("DELETE FROM sessions WHERE sessionId = ?", sessionId);
+  }
+  async getResumableSessions() {
+    if (this.closed || !this.db)
+      throw new Error("NavigationHistory is closed");
+    return this.db.all("SELECT * FROM sessions WHERE status IN ('running', 'paused') ORDER BY lastActivityAt DESC");
+  }
+  async close() {
+    if (this.closed)
+      return;
+    this.closed = true;
+    if (this.db) {
+      this.db.close();
+      this.db = null;
+    }
+  }
+  get isClosed() {
+    return this.closed;
+  }
+  get databasePath() {
+    return this.dbPath;
+  }
+}

package/dist/cache/url-store.cjs

@@ -45,7 +45,13 @@ async function createDatabase(dbPath) {
   const { DatabaseSync } = await import("node:sqlite");
   const db = new DatabaseSync(dbPath);
   return {
-    run: (sql, ...params) => db.exec(sql),
+    run: (sql, ...params) => {
+      if (params.length === 0) {
+        db.exec(sql);
+      } else {
+        db.prepare(sql).run(...params);
+      }
+    },
     get: (sql, ...params) => {
       const stmt = db.prepare(sql);
       return stmt.get(...params);

package/dist/cache/url-store.js

@@ -45,7 +45,13 @@ async function createDatabase(dbPath) {
   const { DatabaseSync } = await import("node:sqlite");
   const db = new DatabaseSync(dbPath);
   return {
-    run: (sql, ...params) => db.exec(sql),
+    run: (sql, ...params) => {
+      if (params.length === 0) {
+        db.exec(sql);
+      } else {
+        db.prepare(sql).run(...params);
+      }
+    },
     get: (sql, ...params) => {
       const stmt = db.prepare(sql);
       return stmt.get(...params);

package/dist/core/rezo.cjs

@@ -7,6 +7,7 @@ const packageJson = require("../../package.json");
 const { createDefaultHooks, mergeHooks, runVoidHooksSync, runTransformHooks } = require('./hooks.cjs');
 const { ResponseCache, DNSCache } = require('../cache/index.cjs');
 const { ProxyManager } = require('../proxy/manager.cjs');
+const { toCurl: toCurlUtil, fromCurl: fromCurlUtil } = require('../utils/curl.cjs');
 let globalAdapter = null;
 function setGlobalAdapter(adapter) {
   globalAdapter = adapter;
@@ -479,6 +480,12 @@ class Rezo {
   clearCookies() {
     this.jar?.removeAllCookiesSync();
   }
+  static toCurl(config) {
+    return toCurlUtil(config);
+  }
+  static fromCurl(curlCommand) {
+    return fromCurlUtil(curlCommand);
+  }
 }
 const defaultTransforms = exports.defaultTransforms = {
   request: [

package/dist/core/rezo.js

@@ -7,6 +7,7 @@ import packageJson from "../../package.json" with { type: 'json' };
 import { createDefaultHooks, mergeHooks, runVoidHooksSync, runTransformHooks } from './hooks.js';
 import { ResponseCache, DNSCache } from '../cache/index.js';
 import { ProxyManager } from '../proxy/manager.js';
+import { toCurl as toCurlUtil, fromCurl as fromCurlUtil } from '../utils/curl.js';
 let globalAdapter = null;
 export function setGlobalAdapter(adapter) {
   globalAdapter = adapter;
@@ -479,6 +480,12 @@ export class Rezo {
   clearCookies() {
     this.jar?.removeAllCookiesSync();
   }
+  static toCurl(config) {
+    return toCurlUtil(config);
+  }
+  static fromCurl(curlCommand) {
+    return fromCurlUtil(curlCommand);
+  }
 }
 export const defaultTransforms = {
   request: [

package/dist/crawler.d.ts

@@ -228,6 +228,17 @@ declare class FileCacher {
 	 */
 	get directory(): string;
 }
+export interface CrawlSession {
+	sessionId: string;
+	baseUrl: string;
+	startedAt: number;
+	lastActivityAt: number;
+	status: "running" | "paused" | "completed" | "failed";
+	urlsVisited: number;
+	urlsQueued: number;
+	urlsFailed: number;
+	metadata?: string;
+}
 export interface RezoHttpHeaders {
 	accept?: string | undefined;
 	"accept-encoding"?: string | undefined;
@@ -4464,6 +4475,71 @@ declare class Rezo {
 	 * @see {@link cookieJar} - Access the underlying RezoCookieJar for more control
 	 */
 	clearCookies(): void;
+	/**
+	 * Convert a Rezo request configuration to a cURL command string.
+	 *
+	 * Generates a valid cURL command that can be executed in a terminal to
+	 * reproduce the same HTTP request. Useful for:
+	 * - Debugging and sharing requests
+	 * - Documentation and examples
+	 * - Testing requests outside of Node.js
+	 * - Exporting requests to other tools
+	 *
+	 * @param config - Request configuration object
+	 * @returns A cURL command string
+	 *
+	 * @example
+	 * ```typescript
+	 * const curl = Rezo.toCurl({
+	 *   url: 'https://api.example.com/users',
+	 *   method: 'POST',
+	 *   headers: { 'Content-Type': 'application/json' },
+	 *   body: { name: 'John', email: 'john@example.com' }
+	 * });
+	 * // Output: curl -X POST -H 'content-type: application/json' --data-raw '{"name":"John","email":"john@example.com"}' -L --compressed 'https://api.example.com/users'
+	 * ```
+	 */
+	static toCurl(config: RezoRequestConfig | RezoRequestOptions): string;
+	/**
+	 * Parse a cURL command string into a Rezo request configuration.
+	 *
+	 * Converts a cURL command into a configuration object that can be
+	 * passed directly to Rezo request methods. Useful for:
+	 * - Importing requests from browser DevTools
+	 * - Converting curl examples from API documentation
+	 * - Migrating scripts from curl to Rezo
+	 *
+	 * Supports common cURL options:
+	 * - `-X, --request` - HTTP method
+	 * - `-H, --header` - Request headers
+	 * - `-d, --data, --data-raw, --data-binary` - Request body
+	 * - `-u, --user` - Basic authentication
+	 * - `-x, --proxy` - Proxy configuration
+	 * - `--socks5, --socks4` - SOCKS proxy
+	 * - `-L, --location` - Follow redirects
+	 * - `--max-redirs` - Maximum redirects
+	 * - `--max-time` - Request timeout
+	 * - `-k, --insecure` - Skip TLS verification
+	 * - `-A, --user-agent` - User agent header
+	 *
+	 * @param curlCommand - A cURL command string
+	 * @returns A request configuration object
+	 *
+	 * @example
+	 * ```typescript
+	 * // From browser DevTools "Copy as cURL"
+	 * const config = Rezo.fromCurl(`
+	 *   curl 'https://api.example.com/data' \\
+	 *     -H 'Authorization: Bearer token123' \\
+	 *     -H 'Content-Type: application/json'
+	 * `);
+	 *
+	 * // Use with Rezo
+	 * const rezo = new Rezo();
+	 * const response = await rezo.request(config);
+	 * ```
+	 */
+	static fromCurl(curlCommand: string): RezoRequestOptions;
 }
 /**
  * Rezo HTTP Client - Core Types
@@ -6284,6 +6360,15 @@ declare class Decodo {
  * const regexDomain: Domain = '^(sub|api)\.example\.com$';
  */
 export type Domain = string[] | string | RegExp;
+/**
+ * Supported HTTP adapter types for crawler requests
+ * @description
+ * - 'http': Standard Node.js HTTP/HTTPS adapter (default)
+ * - 'http2': HTTP/2 adapter with session pooling
+ * - 'curl': cURL adapter for maximum compatibility
+ * - 'fetch': Browser-compatible Fetch API adapter
+ */
+export type CrawlerAdapterType = "http" | "http2" | "curl" | "fetch";
 /**
  * Configuration interface for the CrawlerOptions class
  * @description Defines all available options for configuring web crawler behavior,
@@ -6292,6 +6377,12 @@ export type Domain = string[] | string | RegExp;
 export interface ICrawlerOptions {
 	/** Base URL for the crawler - the starting point for crawling operations */
 	baseUrl: string;
+	/** HTTP adapter to use for requests (default: 'http') */
+	adapter?: CrawlerAdapterType;
+	/** Enable navigation history for resumable crawling (default: false) */
+	enableNavigationHistory?: boolean;
+	/** Session ID for navigation history - allows resuming specific crawl sessions */
+	sessionId?: string;
 	/** Whether to reject unauthorized SSL certificates (default: true) */
 	rejectUnauthorized?: boolean;
 	/** Custom user agent string for HTTP requests */
@@ -6415,6 +6506,12 @@ export interface ICrawlerOptions {
 export declare class CrawlerOptions {
 	/** Base URL for the crawler - the starting point for crawling operations */
 	baseUrl: string;
+	/** HTTP adapter to use for requests */
+	adapter: CrawlerAdapterType;
+	/** Enable navigation history for resumable crawling */
+	enableNavigationHistory: boolean;
+	/** Session ID for navigation history - allows resuming specific crawl sessions */
+	sessionId: string;
 	/** Whether to reject unauthorized SSL certificates */
 	rejectUnauthorized?: boolean;
 	/** Custom user agent string for HTTP requests */
@@ -6886,29 +6983,107 @@ export declare class Crawler {
 	private isStorageReady;
 	private isCacheReady;
 	private leadsFinder;
+	/** Navigation history for resumable crawling */
+	private navigationHistory;
+	private isNavigationHistoryReady;
+	private isSessionReady;
+	private currentSession;
+	private navigationHistoryInitPromise;
+	/** Adapter-specific request executor */
+	private adapterExecutor;
+	private adapterType;
 	/**
 	 * Creates a new Crawler instance with the specified configuration.
 	 *
-	 * @param option - Primary crawler configuration options
-	 * @param backup - Optional backup HTTP client configuration for failover scenarios
+	 * @param crawlerOptions - Crawler configuration options
+	 * @param http - Optional Rezo HTTP client instance (creates default if not provided)
 	 *
 	 * @example
 	 * ```typescript
+	 * // Basic usage (creates default Rezo instance)
 	 * const crawler = new Crawler({
-	 *   http: primaryHttpClient,
-	 *   baseUrl: 'https://api.example.com',
-	 *   timeout: 30000,
+	 *   baseUrl: 'https://example.com',
 	 *   enableCache: true,
 	 *   cacheDir: './cache',
-	 *   socksProxies: [{ host: '127.0.0.1', port: 9050 }]
-	 * }, {
-	 *   http: backupHttpClient,
-	 *   useProxy: false,
-	 *   concurrency: 5
 	 * });
+	 *
+	 * // With resumable crawling
+	 * const crawler = new Crawler({
+	 *   baseUrl: 'https://example.com',
+	 *   enableNavigationHistory: true,
+	 *   sessionId: 'my-session',
+	 *   cacheDir: './cache',
+	 * });
+	 *
+	 * // With custom Rezo instance
+	 * const crawler = new Crawler({
+	 *   baseUrl: 'https://example.com',
+	 *   adapter: 'curl',
+	 * }, myRezoInstance);
 	 * ```
 	 */
-	constructor(crawlerOptions: ICrawlerOptions, http: Rezo);
+	constructor(crawlerOptions: ICrawlerOptions, http?: Rezo);
+	/**
+	 * Initialize the HTTP adapter based on configuration
+	 */
+	private initializeAdapter;
+	/**
+	 * Initialize navigation history and session
+	 */
+	private initializeNavigationHistory;
+	/**
+	 * Wait for navigation history and session to be ready
+	 */
+	private waitForNavigationHistory;
+	/**
+	 * Ensure navigation history is ready and return it (or null if not enabled)
+	 * This is used by visit() and other methods that need to write to navigation history
+	 */
+	private ensureNavigationHistoryReady;
+	/**
+	 * Add URL to navigation history queue
+	 */
+	private addToNavigationQueue;
+	/**
+	 * Mark URL as visited in navigation history
+	 */
+	private markUrlVisited;
+	/**
+	 * Get the current crawl session
+	 */
+	getSession(): CrawlSession | null;
+	/**
+	 * Get the session ID
+	 */
+	getSessionId(): string;
+	/**
+	 * Resume a previous crawl session
+	 * @param sessionId - Optional session ID to resume (uses current session if not provided)
+	 * @returns Promise resolving to the Crawler instance for chaining
+	 */
+	resume(sessionId?: string): Promise<Crawler>;
+	/**
+	 * Get list of resumable sessions
+	 * @returns Promise resolving to array of sessions that can be resumed
+	 */
+	getResumableSessions(): Promise<CrawlSession[]>;
+	/**
+	 * Pause the current crawl session
+	 */
+	pause(): Promise<void>;
+	/**
+	 * Mark the current session as completed
+	 */
+	complete(): Promise<void>;
+	/**
+	 * Get the current adapter type being used
+	 */
+	getAdapterType(): CrawlerAdapterType;
+	/**
+	 * Switch to a different adapter at runtime
+	 * @param adapter - The adapter type to switch to
+	 */
+	setAdapter(adapter: CrawlerAdapterType): Promise<void>;
 	private rawResponseHandler;
 	private waitForCache;
 	private waitForStorage;
@@ -7303,6 +7478,16 @@ export declare class Crawler {
 	 * ```
 	 */
 	waitForAll(): Promise<void>;
+	/**
+	 * Alias for waitForAll() - waits for all crawling operations to complete.
+	 * @returns Promise that resolves when done
+	 * @example
+	 * ```typescript
+	 * crawler.visit('https://example.com');
+	 * await crawler.done();
+	 * ```
+	 */
+	done(): Promise<void>;
 	close(): Promise<void>;
 }
 

package/dist/entries/crawler.cjs

@@ -1,5 +1,5 @@
-const _mod_7nublp = require('../plugin/crawler.cjs');
-exports.Crawler = _mod_7nublp.Crawler;;
-const _mod_dsncou = require('../plugin/crawler-options.cjs');
-exports.CrawlerOptions = _mod_dsncou.CrawlerOptions;
-exports.Domain = _mod_dsncou.Domain;;
+const _mod_l31jyt = require('../plugin/crawler.cjs');
+exports.Crawler = _mod_l31jyt.Crawler;;
+const _mod_2ht78p = require('../plugin/crawler-options.cjs');
+exports.CrawlerOptions = _mod_2ht78p.CrawlerOptions;
+exports.Domain = _mod_2ht78p.Domain;;