rezo 1.0.42 → 1.0.43

package/dist/adapters/http2.js

@@ -1,4 +1,5 @@
 import * as http2 from "node:http2";
+import * as tls from "node:tls";
 import * as zlib from "node:zlib";
 import { URL } from "node:url";
 import { Readable } from "node:stream";
@@ -14,6 +15,8 @@ import { DownloadResponse } from '../responses/download.js';
 import { UploadResponse } from '../responses/upload.js';
 import { CompressionUtil } from '../utils/compression.js';
 import { isSameDomain, RezoPerformance } from '../utils/tools.js';
+import { SocksClient } from '../internal/agents/socks-client.js';
+import * as net from "node:net";
 import { ResponseCache } from '../cache/response-cache.js';
 let zstdDecompressSync = null;
 let zstdChecked = false;
@@ -194,8 +197,9 @@ class Http2SessionPool {
       this.cleanupInterval.unref();
     }
   }
-  getSessionKey(url, options) {
-    return `${url.protocol}//${url.host}`;
+  getSessionKey(url, options, proxy) {
+    const proxyKey = proxy ? typeof proxy === "string" ? proxy : `${proxy.protocol}://${proxy.host}:${proxy.port}` : "";
+    return `${url.protocol}//${url.host}${proxyKey ? `@${proxyKey}` : ""}`;
   }
   isSessionHealthy(session, entry) {
     if (session.closed || session.destroyed)
@@ -207,8 +211,8 @@ class Http2SessionPool {
       return false;
     return true;
   }
-  async getSession(url, options, timeout, forceNew = false) {
-    const key = this.getSessionKey(url, options);
+  async getSession(url, options, timeout, forceNew = false, proxy) {
+    const key = this.getSessionKey(url, options, proxy);
     const existing = this.sessions.get(key);
     if (!forceNew && existing && this.isSessionHealthy(existing.session, existing)) {
       existing.lastUsed = Date.now();
@@ -221,12 +225,13 @@ class Http2SessionPool {
       } catch {}
       this.sessions.delete(key);
     }
-    const session = await this.createSession(url, options, timeout);
+    const session = await this.createSession(url, options, timeout, proxy);
     const entry = {
       session,
       lastUsed: Date.now(),
       refCount: 1,
-      goawayReceived: false
+      goawayReceived: false,
+      proxy
     };
     this.sessions.set(key, entry);
     session.on("close", () => {
@@ -240,15 +245,19 @@ class Http2SessionPool {
     });
     return session;
   }
-  createSession(url, options, timeout) {
+  async createSession(url, options, timeout, proxy) {
+    const authority = `${url.protocol}//${url.host}`;
+    const sessionOptions = {
+      ...options,
+      rejectUnauthorized: options?.rejectUnauthorized !== false,
+      ALPNProtocols: ["h2", "http/1.1"],
+      timeout
+    };
+    if (proxy) {
+      const tunnelSocket = await this.createProxyTunnel(url, proxy, timeout, options?.rejectUnauthorized);
+      sessionOptions.createConnection = () => tunnelSocket;
+    }
     return new Promise((resolve, reject) => {
-      const authority = `${url.protocol}//${url.host}`;
-      const sessionOptions = {
-        ...options,
-        rejectUnauthorized: options?.rejectUnauthorized !== false,
-        ALPNProtocols: ["h2", "http/1.1"],
-        timeout
-      };
       const session = http2.connect(authority, sessionOptions);
       let settled = false;
       const timeoutId = timeout ? setTimeout(() => {
@@ -279,8 +288,186 @@ class Http2SessionPool {
       });
     });
   }
-  releaseSession(url) {
-    const key = this.getSessionKey(url);
+  async createProxyTunnel(url, proxy, timeout, rejectUnauthorized) {
+    return new Promise((resolve, reject) => {
+      let proxyUrl;
+      let proxyAuth;
+      if (typeof proxy === "string") {
+        proxyUrl = new URL(proxy);
+        if (proxyUrl.username || proxyUrl.password) {
+          proxyAuth = Buffer.from(`${decodeURIComponent(proxyUrl.username)}:${decodeURIComponent(proxyUrl.password)}`).toString("base64");
+        }
+      } else {
+        const protocol = proxy.protocol || "http";
+        let proxyUrlStr = `${protocol}://${proxy.host}:${proxy.port}`;
+        if (proxy.auth) {
+          const encodedUser = encodeURIComponent(proxy.auth.username);
+          const encodedPass = encodeURIComponent(proxy.auth.password);
+          proxyUrlStr = `${protocol}://${encodedUser}:${encodedPass}@${proxy.host}:${proxy.port}`;
+          proxyAuth = Buffer.from(`${proxy.auth.username}:${proxy.auth.password}`).toString("base64");
+        }
+        proxyUrl = new URL(proxyUrlStr);
+      }
+      const targetHost = url.hostname;
+      const targetPort = url.port || (url.protocol === "https:" ? "443" : "80");
+      if (proxyUrl.protocol.startsWith("socks")) {
+        const socksType = proxyUrl.protocol === "socks5:" || proxyUrl.protocol === "socks5h:" ? 5 : 4;
+        const socksOpts = {
+          proxy: {
+            host: proxyUrl.hostname,
+            port: parseInt(proxyUrl.port || "1080", 10),
+            type: socksType,
+            userId: proxyUrl.username ? decodeURIComponent(proxyUrl.username) : undefined,
+            password: proxyUrl.password ? decodeURIComponent(proxyUrl.password) : undefined
+          },
+          destination: {
+            host: targetHost,
+            port: parseInt(targetPort, 10)
+          },
+          command: "connect",
+          timeout
+        };
+        SocksClient.createConnection(socksOpts).then(({ socket }) => {
+          if (url.protocol === "https:") {
+            const tlsSocket = tls.connect({
+              socket,
+              host: targetHost,
+              servername: targetHost,
+              rejectUnauthorized: rejectUnauthorized !== false,
+              ALPNProtocols: ["h2", "http/1.1"]
+            });
+            const tlsTimeoutId = timeout ? setTimeout(() => {
+              tlsSocket.destroy();
+              reject(new Error(`TLS handshake timeout after ${timeout}ms`));
+            }, timeout) : null;
+            tlsSocket.on("secureConnect", () => {
+              if (tlsTimeoutId)
+                clearTimeout(tlsTimeoutId);
+              const alpn = tlsSocket.alpnProtocol;
+              if (alpn && alpn !== "h2") {
+                tlsSocket.destroy();
+                reject(new Error(`Server does not support HTTP/2 (negotiated: ${alpn})`));
+                return;
+              }
+              resolve(tlsSocket);
+            });
+            tlsSocket.on("error", (err) => {
+              if (tlsTimeoutId)
+                clearTimeout(tlsTimeoutId);
+              reject(new Error(`TLS handshake failed: ${err.message}`));
+            });
+          } else {
+            resolve(socket);
+          }
+        }).catch((err) => {
+          reject(new Error(`SOCKS proxy connection failed: ${err.message}`));
+        });
+        return;
+      }
+      const proxyHost = proxyUrl.hostname;
+      const proxyPort = parseInt(proxyUrl.port || (proxyUrl.protocol === "https:" ? "443" : "80"), 10);
+      let proxySocket;
+      const connectToProxy = () => {
+        if (proxyUrl.protocol === "https:") {
+          proxySocket = tls.connect({
+            host: proxyHost,
+            port: proxyPort,
+            rejectUnauthorized: rejectUnauthorized !== false
+          });
+        } else {
+          proxySocket = net.connect({
+            host: proxyHost,
+            port: proxyPort
+          });
+        }
+        let settled = false;
+        const timeoutId = timeout ? setTimeout(() => {
+          if (!settled) {
+            settled = true;
+            proxySocket.destroy();
+            reject(new Error(`Proxy connection timeout after ${timeout}ms`));
+          }
+        }, timeout) : null;
+        proxySocket.on("error", (err) => {
+          if (!settled) {
+            settled = true;
+            if (timeoutId)
+              clearTimeout(timeoutId);
+            reject(new Error(`Proxy connection error: ${err.message}`));
+          }
+        });
+        proxySocket.on("connect", () => {
+          const connectRequest = [
+            `CONNECT ${targetHost}:${targetPort} HTTP/1.1`,
+            `Host: ${targetHost}:${targetPort}`,
+            proxyAuth ? `Proxy-Authorization: Basic ${proxyAuth}` : "",
+            "",
+            ""
+          ].filter(Boolean).join(`\r
+`);
+          proxySocket.write(connectRequest);
+        });
+        let responseBuffer = "";
+        proxySocket.on("data", function onData(data) {
+          if (settled)
+            return;
+          responseBuffer += data.toString();
+          const headerEnd = responseBuffer.indexOf(`\r
+\r
+`);
+          if (headerEnd !== -1) {
+            settled = true;
+            if (timeoutId)
+              clearTimeout(timeoutId);
+            proxySocket.removeListener("data", onData);
+            const statusLine = responseBuffer.split(`\r
+`)[0];
+            const statusMatch = statusLine.match(/HTTP\/\d\.\d (\d{3})/);
+            const statusCode = statusMatch ? parseInt(statusMatch[1], 10) : 0;
+            if (statusCode === 200) {
+              if (url.protocol === "https:") {
+                const tlsSocket = tls.connect({
+                  socket: proxySocket,
+                  host: targetHost,
+                  servername: targetHost,
+                  rejectUnauthorized: rejectUnauthorized !== false,
+                  ALPNProtocols: ["h2", "http/1.1"]
+                });
+                const tlsTimeoutId = timeout ? setTimeout(() => {
+                  tlsSocket.destroy();
+                  reject(new Error(`TLS handshake timeout after ${timeout}ms`));
+                }, timeout) : null;
+                tlsSocket.on("secureConnect", () => {
+                  if (tlsTimeoutId)
+                    clearTimeout(tlsTimeoutId);
+                  const alpn = tlsSocket.alpnProtocol;
+                  if (alpn && alpn !== "h2") {
+                    tlsSocket.destroy();
+                    reject(new Error(`Server does not support HTTP/2 (negotiated: ${alpn})`));
+                    return;
+                  }
+                  resolve(tlsSocket);
+                });
+                tlsSocket.on("error", (err) => {
+                  if (tlsTimeoutId)
+                    clearTimeout(tlsTimeoutId);
+                  reject(new Error(`TLS handshake failed: ${err.message}`));
+                });
+              } else {
+                resolve(proxySocket);
+              }
+            } else {
+              proxySocket.destroy();
+              reject(new Error(`Proxy CONNECT failed with status ${statusCode}: ${statusLine}`));
+            }
+          }
+        });
+      };
+      connectToProxy();
+    });
+  }
+  releaseSession(url, proxy) {
+    const key = this.getSessionKey(url, undefined, proxy);
     const entry = this.sessions.get(key);
     if (entry) {
       entry.refCount = Math.max(0, entry.refCount - 1);
@@ -293,8 +480,8 @@ class Http2SessionPool {
       }
     }
   }
-  closeSession(url) {
-    const key = this.getSessionKey(url);
+  closeSession(url, proxy) {
+    const key = this.getSessionKey(url, undefined, proxy);
     const entry = this.sessions.get(key);
     if (entry) {
       entry.session.close();
@@ -1008,10 +1195,10 @@ async function executeHttp2Stream(config, fetchOptions, requestCount, timing, _s
       const forceNewSession = requestCount > 0;
       let session;
       if (config.debug) {
-        console.log(`[Rezo Debug] HTTP/2: Acquiring session for ${url.host}${forceNewSession ? " (forcing new for redirect)" : ""}...`);
+        console.log(`[Rezo Debug] HTTP/2: Acquiring session for ${url.host}${forceNewSession ? " (forcing new for redirect)" : ""}${fetchOptions.proxy ? " (via proxy)" : ""}...`);
       }
       try {
-        session = await (sessionPool || Http2SessionPool.getInstance()).getSession(url, sessionOptions, config.timeout !== null ? config.timeout : undefined, forceNewSession);
+        session = await (sessionPool || Http2SessionPool.getInstance()).getSession(url, sessionOptions, config.timeout !== null ? config.timeout : undefined, forceNewSession, fetchOptions.proxy);
         if (config.debug) {
           console.log(`[Rezo Debug] HTTP/2: Session acquired successfully`);
         }
@@ -1240,7 +1427,7 @@ async function executeHttp2Stream(config, fetchOptions, requestCount, timing, _s
               config.transfer.requestSize = Buffer.byteLength(JSON.stringify(body), "utf8");
             }
           }
-          (sessionPool || Http2SessionPool.getInstance()).releaseSession(url);
+          (sessionPool || Http2SessionPool.getInstance()).releaseSession(url, fetchOptions.proxy);
           if (isRedirect) {
             _stats.statusOnNext = "redirect";
             const partialResponse = {
@@ -1417,7 +1604,7 @@ async function executeHttp2Stream(config, fetchOptions, requestCount, timing, _s
           if (config.debug) {
             console.log(`[Rezo Debug] HTTP/2: Error in 'end' handler:`, endError.message);
           }
-          (sessionPool || Http2SessionPool.getInstance()).releaseSession(url);
+          (sessionPool || Http2SessionPool.getInstance()).releaseSession(url, fetchOptions.proxy);
           const error = buildSmartError(config, fetchOptions, endError);
           _stats.statusOnNext = "error";
           resolve(error);

package/dist/adapters/index.cjs

@@ -1,6 +1,6 @@
-const _mod_8y5us8 = require('./picker.cjs');
-exports.detectRuntime = _mod_8y5us8.detectRuntime;
-exports.getAdapterCapabilities = _mod_8y5us8.getAdapterCapabilities;
-exports.buildAdapterContext = _mod_8y5us8.buildAdapterContext;
-exports.getAvailableAdapters = _mod_8y5us8.getAvailableAdapters;
-exports.selectAdapter = _mod_8y5us8.selectAdapter;;
+const _mod_63iyz4 = require('./picker.cjs');
+exports.detectRuntime = _mod_63iyz4.detectRuntime;
+exports.getAdapterCapabilities = _mod_63iyz4.getAdapterCapabilities;
+exports.buildAdapterContext = _mod_63iyz4.buildAdapterContext;
+exports.getAvailableAdapters = _mod_63iyz4.getAvailableAdapters;
+exports.selectAdapter = _mod_63iyz4.selectAdapter;;

package/dist/cache/file-cacher.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/file-cacher.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/cache/index.cjs

@@ -1,13 +1,15 @@
-const _mod_q88avp = require('./lru-cache.cjs');
-exports.LRUCache = _mod_q88avp.LRUCache;;
-const _mod_ycn5kr = require('./dns-cache.cjs');
-exports.DNSCache = _mod_ycn5kr.DNSCache;
-exports.getGlobalDNSCache = _mod_ycn5kr.getGlobalDNSCache;
-exports.resetGlobalDNSCache = _mod_ycn5kr.resetGlobalDNSCache;;
-const _mod_ca0ngi = require('./response-cache.cjs');
-exports.ResponseCache = _mod_ca0ngi.ResponseCache;
-exports.normalizeResponseCacheConfig = _mod_ca0ngi.normalizeResponseCacheConfig;;
-const _mod_pmo9e4 = require('./file-cacher.cjs');
-exports.FileCacher = _mod_pmo9e4.FileCacher;;
-const _mod_h6jprd = require('./url-store.cjs');
-exports.UrlStore = _mod_h6jprd.UrlStore;;
+const _mod_6dj0p0 = require('./lru-cache.cjs');
+exports.LRUCache = _mod_6dj0p0.LRUCache;;
+const _mod_9z4pm1 = require('./dns-cache.cjs');
+exports.DNSCache = _mod_9z4pm1.DNSCache;
+exports.getGlobalDNSCache = _mod_9z4pm1.getGlobalDNSCache;
+exports.resetGlobalDNSCache = _mod_9z4pm1.resetGlobalDNSCache;;
+const _mod_5ylf2b = require('./response-cache.cjs');
+exports.ResponseCache = _mod_5ylf2b.ResponseCache;
+exports.normalizeResponseCacheConfig = _mod_5ylf2b.normalizeResponseCacheConfig;;
+const _mod_fk65c2 = require('./file-cacher.cjs');
+exports.FileCacher = _mod_fk65c2.FileCacher;;
+const _mod_7tzsb5 = require('./url-store.cjs');
+exports.UrlStore = _mod_7tzsb5.UrlStore;;
+const _mod_04c8wb = require('./navigation-history.cjs');
+exports.NavigationHistory = _mod_04c8wb.NavigationHistory;;

package/dist/cache/index.js

@@ -3,3 +3,4 @@ export { DNSCache, getGlobalDNSCache, resetGlobalDNSCache } from './dns-cache.js
 export { ResponseCache, normalizeResponseCacheConfig } from './response-cache.js';
 export { FileCacher } from './file-cacher.js';
 export { UrlStore } from './url-store.js';
+export { NavigationHistory } from './navigation-history.js';

package/dist/cache/navigation-history.cjs

@@ -0,0 +1,298 @@
+const fs = require("node:fs");
+const path = require("node:path");
+const { createHash } = require("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()
+  };
+}
+
+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;
+  }
+}
+
+exports.NavigationHistory = NavigationHistory;