rezo 1.0.41 → 1.0.43

package/dist/adapters/index.cjs

@@ -1,6 +1,6 @@
-const _mod_ds8hb1 = require('./picker.cjs');
-exports.detectRuntime = _mod_ds8hb1.detectRuntime;
-exports.getAdapterCapabilities = _mod_ds8hb1.getAdapterCapabilities;
-exports.buildAdapterContext = _mod_ds8hb1.buildAdapterContext;
-exports.getAvailableAdapters = _mod_ds8hb1.getAvailableAdapters;
-exports.selectAdapter = _mod_ds8hb1.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/adapters/xhr.cjs

@@ -16,6 +16,85 @@ const Environment = {
   hasFormData: typeof FormData !== "undefined",
   hasBlob: typeof Blob !== "undefined"
 };
+const debugLog = {
+  requestStart: (config, url, method) => {
+    if (config.debug) {
+      console.log(`
+[Rezo Debug] ─────────────────────────────────────`);
+      console.log(`[Rezo Debug] ${method} ${url}`);
+      console.log(`[Rezo Debug] Request ID: ${config.requestId}`);
+      console.log(`[Rezo Debug] Adapter: xhr`);
+      if (config.originalRequest?.headers) {
+        const headers = config.originalRequest.headers instanceof RezoHeaders ? config.originalRequest.headers.toObject() : config.originalRequest.headers;
+        console.log(`[Rezo Debug] Request Headers:`, JSON.stringify(headers, null, 2));
+      }
+    }
+    if (config.trackUrl) {
+      console.log(`[Rezo Track] → ${method} ${url}`);
+    }
+  },
+  retry: (config, attempt, maxRetries, statusCode, delay) => {
+    if (config.debug) {
+      console.log(`[Rezo Debug] Retry ${attempt}/${maxRetries} after status ${statusCode}${delay > 0 ? ` (waiting ${delay}ms)` : ""}`);
+    }
+    if (config.trackUrl) {
+      console.log(`[Rezo Track]   ⟳ Retry ${attempt}/${maxRetries} (status ${statusCode})`);
+    }
+  },
+  maxRetries: (config, maxRetries) => {
+    if (config.debug) {
+      console.log(`[Rezo Debug] Max retries (${maxRetries}) reached, throwing error`);
+    }
+    if (config.trackUrl) {
+      console.log(`[Rezo Track]   ✗ Max retries reached`);
+    }
+  },
+  response: (config, status, statusText, duration) => {
+    if (config.debug) {
+      console.log(`[Rezo Debug] Response: ${status} ${statusText} (${duration.toFixed(2)}ms)`);
+    }
+    if (config.trackUrl) {
+      console.log(`[Rezo Track] ✓ ${status} ${statusText}`);
+    }
+  },
+  responseHeaders: (config, headers) => {
+    if (config.debug) {
+      console.log(`[Rezo Debug] Response Headers:`, JSON.stringify(headers, null, 2));
+    }
+  },
+  cookies: (config, cookieCount) => {
+    if (config.debug && cookieCount > 0) {
+      console.log(`[Rezo Debug] Cookies received: ${cookieCount}`);
+    }
+  },
+  timing: (config, timing) => {
+    if (config.debug) {
+      const parts = [];
+      if (timing.ttfb)
+        parts.push(`TTFB: ${timing.ttfb.toFixed(2)}ms`);
+      if (timing.total)
+        parts.push(`Total: ${timing.total.toFixed(2)}ms`);
+      if (parts.length > 0) {
+        console.log(`[Rezo Debug] Timing: ${parts.join(" | ")}`);
+      }
+    }
+  },
+  complete: (config, url) => {
+    if (config.debug) {
+      console.log(`[Rezo Debug] Request complete: ${url}`);
+      console.log(`[Rezo Debug] ─────────────────────────────────────
+`);
+    }
+  },
+  error: (config, error) => {
+    if (config.debug) {
+      console.log(`[Rezo Debug] Error: ${error instanceof Error ? error.message : error}`);
+    }
+    if (config.trackUrl) {
+      console.log(`[Rezo Track]   ✗ Error: ${error instanceof Error ? error.message : error}`);
+    }
+  }
+};
 function updateTiming(config, timing, bodySize) {
   const now = performance.now();
   config.timing.domainLookupStart = config.timing.startTime;
@@ -330,11 +409,14 @@ async function executeXHRRequest(fetchOptions, config, options, perform, streamR
             throw response;
           }
           if (maxRetries <= retries) {
+            debugLog.maxRetries(config, maxRetries);
             throw response;
           }
           retries++;
-          if (retryDelay > 0) {
-            await new Promise((resolve) => setTimeout(resolve, incrementDelay ? retryDelay * retries : retryDelay));
+          const currentDelay = incrementDelay ? retryDelay * retries : retryDelay;
+          debugLog.retry(config, retries, maxRetries, response.status || 0, currentDelay);
+          if (currentDelay > 0) {
+            await new Promise((resolve) => setTimeout(resolve, currentDelay));
           }
         }
         config.retryAttempts++;
@@ -359,6 +441,7 @@ function executeSingleXHRRequest(config, fetchOptions, timing, streamResult, dow
       config.isSecure = isSecure;
       config.finalUrl = url;
       config.network.protocol = isSecure ? "https" : "http";
+      debugLog.requestStart(config, url, fetchOptions.method?.toUpperCase() || "GET");
       const xhr = new XMLHttpRequest;
       xhr.open(fetchOptions.method.toUpperCase(), url, true);
       const headers = toXHRHeaders(fetchOptions.headers);
@@ -513,6 +596,15 @@ function executeSingleXHRRequest(config, fetchOptions, timing, streamResult, dow
           resolve(error);
           return;
         }
+        const duration = performance.now() - timing.startTime;
+        debugLog.response(config, status, statusText, duration);
+        debugLog.responseHeaders(config, responseHeaders.toObject());
+        debugLog.cookies(config, cookies.array.length);
+        debugLog.timing(config, {
+          ttfb: config.timing.responseStart - config.timing.startTime,
+          total: duration
+        });
+        debugLog.complete(config, xhr.responseURL || url);
         const finalResponse = {
           data: responseData,
           status,

package/dist/adapters/xhr.js

@@ -16,6 +16,85 @@ const Environment = {
   hasFormData: typeof FormData !== "undefined",
   hasBlob: typeof Blob !== "undefined"
 };
+const debugLog = {
+  requestStart: (config, url, method) => {
+    if (config.debug) {
+      console.log(`
+[Rezo Debug] ─────────────────────────────────────`);
+      console.log(`[Rezo Debug] ${method} ${url}`);
+      console.log(`[Rezo Debug] Request ID: ${config.requestId}`);
+      console.log(`[Rezo Debug] Adapter: xhr`);
+      if (config.originalRequest?.headers) {
+        const headers = config.originalRequest.headers instanceof RezoHeaders ? config.originalRequest.headers.toObject() : config.originalRequest.headers;
+        console.log(`[Rezo Debug] Request Headers:`, JSON.stringify(headers, null, 2));
+      }
+    }
+    if (config.trackUrl) {
+      console.log(`[Rezo Track] → ${method} ${url}`);
+    }
+  },
+  retry: (config, attempt, maxRetries, statusCode, delay) => {
+    if (config.debug) {
+      console.log(`[Rezo Debug] Retry ${attempt}/${maxRetries} after status ${statusCode}${delay > 0 ? ` (waiting ${delay}ms)` : ""}`);
+    }
+    if (config.trackUrl) {
+      console.log(`[Rezo Track]   ⟳ Retry ${attempt}/${maxRetries} (status ${statusCode})`);
+    }
+  },
+  maxRetries: (config, maxRetries) => {
+    if (config.debug) {
+      console.log(`[Rezo Debug] Max retries (${maxRetries}) reached, throwing error`);
+    }
+    if (config.trackUrl) {
+      console.log(`[Rezo Track]   ✗ Max retries reached`);
+    }
+  },
+  response: (config, status, statusText, duration) => {
+    if (config.debug) {
+      console.log(`[Rezo Debug] Response: ${status} ${statusText} (${duration.toFixed(2)}ms)`);
+    }
+    if (config.trackUrl) {
+      console.log(`[Rezo Track] ✓ ${status} ${statusText}`);
+    }
+  },
+  responseHeaders: (config, headers) => {
+    if (config.debug) {
+      console.log(`[Rezo Debug] Response Headers:`, JSON.stringify(headers, null, 2));
+    }
+  },
+  cookies: (config, cookieCount) => {
+    if (config.debug && cookieCount > 0) {
+      console.log(`[Rezo Debug] Cookies received: ${cookieCount}`);
+    }
+  },
+  timing: (config, timing) => {
+    if (config.debug) {
+      const parts = [];
+      if (timing.ttfb)
+        parts.push(`TTFB: ${timing.ttfb.toFixed(2)}ms`);
+      if (timing.total)
+        parts.push(`Total: ${timing.total.toFixed(2)}ms`);
+      if (parts.length > 0) {
+        console.log(`[Rezo Debug] Timing: ${parts.join(" | ")}`);
+      }
+    }
+  },
+  complete: (config, url) => {
+    if (config.debug) {
+      console.log(`[Rezo Debug] Request complete: ${url}`);
+      console.log(`[Rezo Debug] ─────────────────────────────────────
+`);
+    }
+  },
+  error: (config, error) => {
+    if (config.debug) {
+      console.log(`[Rezo Debug] Error: ${error instanceof Error ? error.message : error}`);
+    }
+    if (config.trackUrl) {
+      console.log(`[Rezo Track]   ✗ Error: ${error instanceof Error ? error.message : error}`);
+    }
+  }
+};
 function updateTiming(config, timing, bodySize) {
   const now = performance.now();
   config.timing.domainLookupStart = config.timing.startTime;
@@ -330,11 +409,14 @@ async function executeXHRRequest(fetchOptions, config, options, perform, streamR
             throw response;
           }
           if (maxRetries <= retries) {
+            debugLog.maxRetries(config, maxRetries);
             throw response;
           }
           retries++;
-          if (retryDelay > 0) {
-            await new Promise((resolve) => setTimeout(resolve, incrementDelay ? retryDelay * retries : retryDelay));
+          const currentDelay = incrementDelay ? retryDelay * retries : retryDelay;
+          debugLog.retry(config, retries, maxRetries, response.status || 0, currentDelay);
+          if (currentDelay > 0) {
+            await new Promise((resolve) => setTimeout(resolve, currentDelay));
           }
         }
         config.retryAttempts++;
@@ -359,6 +441,7 @@ function executeSingleXHRRequest(config, fetchOptions, timing, streamResult, dow
       config.isSecure = isSecure;
       config.finalUrl = url;
       config.network.protocol = isSecure ? "https" : "http";
+      debugLog.requestStart(config, url, fetchOptions.method?.toUpperCase() || "GET");
       const xhr = new XMLHttpRequest;
       xhr.open(fetchOptions.method.toUpperCase(), url, true);
       const headers = toXHRHeaders(fetchOptions.headers);
@@ -513,6 +596,15 @@ function executeSingleXHRRequest(config, fetchOptions, timing, streamResult, dow
           resolve(error);
           return;
         }
+        const duration = performance.now() - timing.startTime;
+        debugLog.response(config, status, statusText, duration);
+        debugLog.responseHeaders(config, responseHeaders.toObject());
+        debugLog.cookies(config, cookies.array.length);
+        debugLog.timing(config, {
+          ttfb: config.timing.responseStart - config.timing.startTime,
+          total: duration
+        });
+        debugLog.complete(config, xhr.responseURL || url);
         const finalResponse = {
           data: responseData,
           status,

package/dist/cache/dns-cache.cjs

@@ -1,5 +1,5 @@
 const { LRUCache } = require('./lru-cache.cjs');
-const dns = require("dns");
+const dns = require("node:dns");
 const DEFAULT_DNS_TTL = 60000;
 const DEFAULT_DNS_MAX_ENTRIES = 1000;
 
@@ -24,10 +24,12 @@ class DNSCache {
     const cached = this.cache.get(key);
     if (cached && cached.addresses.length > 0) {
       const address = cached.addresses[Math.floor(Math.random() * cached.addresses.length)];
-      return { address, family: cached.family };
+      if (address && typeof address === "string") {
+        return { address, family: cached.family };
+      }
     }
     const result = await this.resolveDNS(hostname, family);
-    if (result) {
+    if (result && result.address && typeof result.address === "string") {
       this.cache.set(key, {
         addresses: [result.address],
         family: result.family,

package/dist/cache/dns-cache.js

@@ -1,5 +1,5 @@
 import { LRUCache } from './lru-cache.js';
-import dns from "dns";
+import dns from "node:dns";
 const DEFAULT_DNS_TTL = 60000;
 const DEFAULT_DNS_MAX_ENTRIES = 1000;
 
@@ -24,10 +24,12 @@ export class DNSCache {
     const cached = this.cache.get(key);
     if (cached && cached.addresses.length > 0) {
       const address = cached.addresses[Math.floor(Math.random() * cached.addresses.length)];
-      return { address, family: cached.family };
+      if (address && typeof address === "string") {
+        return { address, family: cached.family };
+      }
     }
     const result = await this.resolveDNS(hostname, family);
-    if (result) {
+    if (result && result.address && typeof result.address === "string") {
       this.cache.set(key, {
         addresses: [result.address],
         family: result.family,

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_pf5i2i = require('./lru-cache.cjs');
-exports.LRUCache = _mod_pf5i2i.LRUCache;;
-const _mod_iftoun = require('./dns-cache.cjs');
-exports.DNSCache = _mod_iftoun.DNSCache;
-exports.getGlobalDNSCache = _mod_iftoun.getGlobalDNSCache;
-exports.resetGlobalDNSCache = _mod_iftoun.resetGlobalDNSCache;;
-const _mod_lg2ryg = require('./response-cache.cjs');
-exports.ResponseCache = _mod_lg2ryg.ResponseCache;
-exports.normalizeResponseCacheConfig = _mod_lg2ryg.normalizeResponseCacheConfig;;
-const _mod_btk7am = require('./file-cacher.cjs');
-exports.FileCacher = _mod_btk7am.FileCacher;;
-const _mod_56wgw7 = require('./url-store.cjs');
-exports.UrlStore = _mod_56wgw7.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;