rezo 1.0.71 → 1.0.73

package/dist/crawler.d.ts

@@ -11,8 +11,9 @@ import { Cookie as TouchCookie, CookieJar as TouchCookieJar, CreateCookieOptions
  * Optimized specifically for crawler workloads with:
  * - WAL mode for high-throughput concurrent reads/writes
  * - Batch operations for efficient bulk storage
- * - Domain-based namespacing for organized cache management
+ * - Domain-based namespacing via column (single database)
  * - Optional zstd compression for storage efficiency
+ * - LRU eviction to prevent unbounded growth
  *
  * @module cache/file-cacher
  * @author Rezo HTTP Client Library
@@ -22,10 +23,15 @@ import { Cookie as TouchCookie, CookieJar as TouchCookieJar, CreateCookieOptions
  */
 export interface FileCacherOptions {
 	/**
-	 * Directory path for storing cache databases
+	 * Directory path for storing the cache database
 	 * @default '/tmp/rezo-crawler/cache'
 	 */
 	cacheDir?: string;
+	/**
+	 * Database filename
+	 * @default 'cache.db'
+	 */
+	dbFileName?: string;
 	/**
 	 * Default time-to-live in milliseconds
 	 * @default 604800000 (7 days)
@@ -38,30 +44,33 @@ export interface FileCacherOptions {
 	 */
 	compression?: boolean;
 	/**
-	 * Hash namespace names for privacy
-	 * @default false
-	 */
-	encryptNamespace?: boolean;
-	/**
-	 * Maximum entries per namespace (0 = unlimited)
-	 * @default 0
+	 * Maximum total entries (0 = unlimited, recommended: 100000)
+	 * Uses LRU eviction when limit is reached
+	 * @default 100000
 	 */
 	maxEntries?: number;
 }
 declare class FileCacher {
-	private databases;
+	private db;
 	private readonly options;
 	private readonly cacheDir;
+	private readonly dbPath;
 	private closed;
+	private initPromise;
+	private evictionInProgress;
 	private constructor();
 	/**
 	 * Create a new FileCacher instance
 	 */
 	static create(options?: FileCacherOptions): Promise<FileCacher>;
 	/**
-	 * Get or create optimized database for a namespace (domain)
+	 * Initialize the single database with optimized settings
 	 */
-	private getDatabase;
+	private initialize;
+	/**
+	 * Ensure database is initialized
+	 */
+	private ensureDb;
 	/**
 	 * Store a response in the cache
 	 */
@@ -74,6 +83,11 @@ declare class FileCacher {
 		value: T;
 		ttl?: number;
 	}>, namespace?: string): Promise<void>;
+	/**
+	 * LRU eviction - removes oldest entries when limit exceeded
+	 * Runs asynchronously to not block writes
+	 */
+	private maybeEvict;
 	/**
 	 * Retrieve a cached response
 	 */
@@ -95,22 +109,24 @@ declare class FileCacher {
 	 */
 	clear(namespace?: string): Promise<void>;
 	/**
-	 * Remove all expired entries
+	 * Remove all expired entries across all namespaces
 	 */
-	cleanup(namespace?: string): Promise<number>;
+	cleanup(): Promise<number>;
 	/**
-	 * Get cache statistics for a namespace
+	 * Get cache statistics
 	 */
 	stats(namespace?: string): Promise<{
 		count: number;
 		expired: number;
+		namespaces: number;
 	}>;
 	/**
-	 * Close all database connections
+	 * Close the database connection
 	 */
 	close(): Promise<void>;
 	get isClosed(): boolean;
 	get directory(): string;
+	get databasePath(): string;
 }
 export interface CrawlSession {
 	sessionId: string;
@@ -2063,6 +2079,13 @@ export interface QueueConfig {
 	intervalCap?: number;
 	/** Carry over unused interval capacity to next interval */
 	carryoverConcurrencyCount?: boolean;
+	/**
+	 * Reject the task promise when an error occurs (default: false)
+	 * When false, errors are swallowed and task.resolve(undefined) is called.
+	 * This prevents unhandled promise rejections but makes error handling harder.
+	 * When true, task.reject(error) is called, allowing proper try/catch handling.
+	 */
+	rejectOnError?: boolean;
 }
 /**
  * Task options when adding to queue
@@ -2268,8 +2291,12 @@ declare class RezoQueue<T = any> {
 	/**
 	 * Wait for queue size to be less than limit
 	 * @param limit - Size threshold
+	 * @param timeoutMs - Optional timeout in milliseconds (default: 0 = no timeout)
+	 *                    If timeout occurs, promise resolves (not rejects) to prevent blocking
 	 */
-	onSizeLessThan(limit: number): Promise<void>;
+	onSizeLessThan(limit: number, timeoutMs?: number): Promise<void>;
+	/** Maximum recommended handlers per event before warning */
+	private static readonly MAX_HANDLERS_WARNING;
 	/**
 	 * Register an event handler
 	 * @param event - Event name
@@ -6477,6 +6504,10 @@ export interface ICrawlerOptions {
 	} | {
 		enable: false;
 	} | undefined | false;
+	/** Maximum concurrent requests for crawler (default: 100) */
+	concurrency?: number;
+	/** Maximum concurrent requests for scraper - separate queue (default: same as concurrency) */
+	scraperConcurrency?: number;
 	/** Maximum crawl depth from start URL (0 = unlimited, default: 0) */
 	maxDepth?: number;
 	/** Maximum total URLs to crawl (0 = unlimited, default: 0) */
@@ -6575,6 +6606,10 @@ export declare class CrawlerOptions {
 	throwFatalError?: boolean;
 	/** Enable debug logging */
 	debug?: boolean;
+	/** Maximum concurrent requests for crawler (default: 100) */
+	concurrency: number;
+	/** Maximum concurrent requests for scraper (default: same as concurrency) */
+	scraperConcurrency: number;
 	/** Maximum crawl depth from start URL (0 = unlimited) */
 	maxDepth: number;
 	/** Maximum total URLs to crawl (0 = unlimited) */
@@ -6991,6 +7026,32 @@ export interface EmailDiscoveryEvent<T = Record<string, any>> {
 	timestamp: Date;
 	metadata: T;
 }
+export interface HealthSnapshot {
+	/** Timestamp of snapshot */
+	timestamp: number;
+	/** Requests per second (rolling average) */
+	requestsPerSecond: number;
+	/** Success rate percentage (0-100) */
+	successRate: number;
+	/** Failure rate percentage (0-100) */
+	failureRate: number;
+	/** Average response time in ms */
+	avgResponseTime: number;
+	/** 95th percentile response time in ms */
+	p95ResponseTime: number;
+	/** Current queue depth */
+	queueDepth: number;
+	/** Active concurrent requests */
+	activeRequests: number;
+	/** Total requests processed */
+	totalRequests: number;
+	/** Total successful requests */
+	totalSuccesses: number;
+	/** Total failed requests */
+	totalFailures: number;
+	/** Uptime in milliseconds */
+	uptimeMs: number;
+}
 interface RedirectEvent$1 {
 	originalUrl: string;
 	finalUrl: string;
@@ -7070,6 +7131,7 @@ export declare class Crawler {
 	 */
 	cacher: FileCacher;
 	private queue;
+	private scraperQueue;
 	private readonly isCacheEnabled;
 	readonly config: CrawlerOptions;
 	private urlStorage;
@@ -7085,15 +7147,10 @@ export declare class Crawler {
 	/** Adapter-specific request executor */
 	private adapterExecutor;
 	private adapterType;
-	/** Track pending execute() calls for proper done() behavior */
-	private pendingExecutions;
-	/**
-	 * Track pending visits that haven't yet added to the queue.
-	 * This prevents waitForAll() from exiting when execute() is still in its async preamble.
-	 */
-	private pendingVisitCount;
 	/** Track if the crawler has been destroyed */
 	private isDestroyed;
+	/** Track if graceful shutdown has been requested */
+	private shutdownRequested;
 	/** Original queue options for restoration */
 	private readonly queueOptions;
 	/** robots.txt parser and validator */
@@ -7105,14 +7162,30 @@ export declare class Crawler {
 	private crawlStats;
 	/** URL depth tracking for maxDepth limit */
 	private urlDepthMap;
+	/** Periodic cleanup interval for memory management */
+	private cleanupInterval?;
+	/** Auto-checkpoint interval for session persistence */
+	private checkpointInterval?;
+	/** Last checkpoint timestamp */
+	private lastCheckpointTime;
+	/** Memory monitor for auto-throttling */
+	private memoryMonitor;
+	/** Health metrics for monitoring */
+	private healthMetrics;
+	/** Original concurrency for restoration after memory pressure */
+	private originalConcurrency;
+	/** Shutdown handler reference for cleanup */
+	private shutdownHandler;
 	/** Lifecycle event handlers */
 	private startHandlers;
 	private finishHandlers;
 	private redirectHandlers;
-	/** Data collection for export */
+	/** Data collection for export - bounded to prevent memory issues */
 	private collectedData;
 	/** Flag to track if crawl has started */
 	private crawlStarted;
+	/** Promise lock for triggerStartHandlers to prevent race condition */
+	private startHandlersPromise;
 	/**
 	 * Creates a new Crawler instance with the specified configuration.
 	 *
@@ -7144,6 +7217,18 @@ export declare class Crawler {
 	 * ```
 	 */
 	constructor(crawlerOptions: ICrawlerOptions, http?: Rezo);
+	/**
+	 * Register process signal handlers for graceful shutdown
+	 */
+	private registerShutdownHandlers;
+	/**
+	 * Remove process signal handlers
+	 */
+	private removeShutdownHandlers;
+	/**
+	 * Graceful shutdown - finish current tasks and save state
+	 */
+	gracefulShutdown(): Promise<void>;
 	/**
 	 * Initialize the HTTP adapter based on configuration
 	 */
@@ -7212,8 +7297,30 @@ export declare class Crawler {
 	 */
 	setAdapter(adapter: CrawlerAdapterType): Promise<void>;
 	private rawResponseHandler;
+	/**
+	 * Wait for cache to be ready with timeout (non-recursive)
+	 * @param timeoutMs - Maximum time to wait in milliseconds (default: 30s)
+	 */
 	private waitForCache;
+	/**
+	 * Wait for storage to be ready with timeout (non-recursive)
+	 * @param timeoutMs - Maximum time to wait in milliseconds (default: 30s)
+	 */
 	private waitForStorage;
+	/**
+	 * Start periodic cleanup to prevent unbounded memory growth
+	 * Trims urlDepthMap and domainResponseTimes to reasonable sizes
+	 * Also monitors memory and auto-throttles if needed
+	 */
+	private startPeriodicCleanup;
+	/**
+	 * Start auto-checkpointing to save session progress every 5 minutes
+	 */
+	private startAutoCheckpoint;
+	/**
+	 * Save current crawl progress to navigation history
+	 */
+	saveCheckpoint(): Promise<void>;
 	private saveUrl;
 	private hasUrlInCache;
 	private saveCache;
@@ -7621,8 +7728,24 @@ export declare class Crawler {
 	 * Get current crawl statistics
 	 */
 	getStats(): CrawlStats;
+	/**
+	 * Get health metrics snapshot for monitoring
+	 */
+	getHealthSnapshot(): HealthSnapshot;
+	/**
+	 * Check if crawler is healthy based on thresholds
+	 */
+	isHealthy(options?: {
+		minSuccessRate?: number;
+		maxAvgResponseTime?: number;
+	}): boolean;
+	/**
+	 * Get Prometheus-formatted metrics for monitoring systems
+	 */
+	getPrometheusMetrics(prefix?: string): string;
 	/**
 	 * Trigger onStart handlers (called once on first visit)
+	 * Uses promise lock to prevent race condition with concurrent visits
 	 */
 	private triggerStartHandlers;
 	/**

package/dist/entries/crawler.cjs

@@ -1,4 +1,4 @@
-const _mod_g4a877 = require('../crawler/crawler.cjs');
-exports.Crawler = _mod_g4a877.Crawler;;
-const _mod_6xerar = require('../crawler/crawler-options.cjs');
-exports.CrawlerOptions = _mod_6xerar.CrawlerOptions;;
+const _mod_lzlskh = require('../crawler/crawler.cjs');
+exports.Crawler = _mod_lzlskh.Crawler;;
+const _mod_vbox0l = require('../crawler/crawler-options.cjs');
+exports.CrawlerOptions = _mod_vbox0l.CrawlerOptions;;

package/dist/index.cjs

@@ -1,30 +1,30 @@
-const _mod_vvm9wl = require('./core/rezo.cjs');
-exports.Rezo = _mod_vvm9wl.Rezo;
-exports.createRezoInstance = _mod_vvm9wl.createRezoInstance;
-exports.createDefaultInstance = _mod_vvm9wl.createDefaultInstance;;
-const _mod_17ffv0 = require('./errors/rezo-error.cjs');
-exports.RezoError = _mod_17ffv0.RezoError;
-exports.RezoErrorCode = _mod_17ffv0.RezoErrorCode;;
-const _mod_5w9162 = require('./utils/headers.cjs');
-exports.RezoHeaders = _mod_5w9162.RezoHeaders;;
-const _mod_20lu6e = require('./utils/form-data.cjs');
-exports.RezoFormData = _mod_20lu6e.RezoFormData;;
-const _mod_7vu526 = require('./utils/cookies.cjs');
-exports.RezoCookieJar = _mod_7vu526.RezoCookieJar;
-exports.Cookie = _mod_7vu526.Cookie;;
-const _mod_f9hxhz = require('./utils/curl.cjs');
-exports.toCurl = _mod_f9hxhz.toCurl;
-exports.fromCurl = _mod_f9hxhz.fromCurl;;
-const _mod_i6ylu6 = require('./core/hooks.cjs');
-exports.createDefaultHooks = _mod_i6ylu6.createDefaultHooks;
-exports.mergeHooks = _mod_i6ylu6.mergeHooks;;
-const _mod_o7hxgi = require('./proxy/manager.cjs');
-exports.ProxyManager = _mod_o7hxgi.ProxyManager;;
-const _mod_gzy9ii = require('./queue/index.cjs');
-exports.RezoQueue = _mod_gzy9ii.RezoQueue;
-exports.HttpQueue = _mod_gzy9ii.HttpQueue;
-exports.Priority = _mod_gzy9ii.Priority;
-exports.HttpMethodPriority = _mod_gzy9ii.HttpMethodPriority;;
+const _mod_nof5gk = require('./core/rezo.cjs');
+exports.Rezo = _mod_nof5gk.Rezo;
+exports.createRezoInstance = _mod_nof5gk.createRezoInstance;
+exports.createDefaultInstance = _mod_nof5gk.createDefaultInstance;;
+const _mod_4m1kqu = require('./errors/rezo-error.cjs');
+exports.RezoError = _mod_4m1kqu.RezoError;
+exports.RezoErrorCode = _mod_4m1kqu.RezoErrorCode;;
+const _mod_p9wchx = require('./utils/headers.cjs');
+exports.RezoHeaders = _mod_p9wchx.RezoHeaders;;
+const _mod_ib1mep = require('./utils/form-data.cjs');
+exports.RezoFormData = _mod_ib1mep.RezoFormData;;
+const _mod_fkghv0 = require('./utils/cookies.cjs');
+exports.RezoCookieJar = _mod_fkghv0.RezoCookieJar;
+exports.Cookie = _mod_fkghv0.Cookie;;
+const _mod_qucbgi = require('./utils/curl.cjs');
+exports.toCurl = _mod_qucbgi.toCurl;
+exports.fromCurl = _mod_qucbgi.fromCurl;;
+const _mod_6whv41 = require('./core/hooks.cjs');
+exports.createDefaultHooks = _mod_6whv41.createDefaultHooks;
+exports.mergeHooks = _mod_6whv41.mergeHooks;;
+const _mod_urv2c9 = require('./proxy/manager.cjs');
+exports.ProxyManager = _mod_urv2c9.ProxyManager;;
+const _mod_hfcxva = require('./queue/index.cjs');
+exports.RezoQueue = _mod_hfcxva.RezoQueue;
+exports.HttpQueue = _mod_hfcxva.HttpQueue;
+exports.Priority = _mod_hfcxva.Priority;
+exports.HttpMethodPriority = _mod_hfcxva.HttpMethodPriority;;
 const { RezoError } = require('./errors/rezo-error.cjs');
 const isRezoError = exports.isRezoError = RezoError.isRezoError;
 const Cancel = exports.Cancel = RezoError;
@@ -34,9 +34,9 @@ const isCancel = exports.isCancel = (error) => {
 };
 const all = exports.all = Promise.all.bind(Promise);
 const spread = exports.spread = (callback) => (array) => callback(...array);
-const _mod_wopl2b = require('./version.cjs');
-exports.VERSION = _mod_wopl2b.VERSION;
-exports.PACKAGE_NAME = _mod_wopl2b.PACKAGE_NAME;;
+const _mod_wqlmnp = require('./version.cjs');
+exports.VERSION = _mod_wqlmnp.VERSION;
+exports.PACKAGE_NAME = _mod_wqlmnp.PACKAGE_NAME;;
 const { executeRequest } = require('./adapters/http.cjs');
 const { setGlobalAdapter, createRezoInstance } = require('./core/rezo.cjs');
 setGlobalAdapter(executeRequest);

package/dist/index.d.ts

@@ -2030,6 +2030,13 @@ export interface QueueConfig {
 	intervalCap?: number;
 	/** Carry over unused interval capacity to next interval */
 	carryoverConcurrencyCount?: boolean;
+	/**
+	 * Reject the task promise when an error occurs (default: false)
+	 * When false, errors are swallowed and task.resolve(undefined) is called.
+	 * This prevents unhandled promise rejections but makes error handling harder.
+	 * When true, task.reject(error) is called, allowing proper try/catch handling.
+	 */
+	rejectOnError?: boolean;
 }
 /**
  * HTTP-specific queue configuration
@@ -2342,8 +2349,12 @@ export declare class RezoQueue<T = any> {
 	/**
 	 * Wait for queue size to be less than limit
 	 * @param limit - Size threshold
+	 * @param timeoutMs - Optional timeout in milliseconds (default: 0 = no timeout)
+	 *                    If timeout occurs, promise resolves (not rejects) to prevent blocking
 	 */
-	onSizeLessThan(limit: number): Promise<void>;
+	onSizeLessThan(limit: number, timeoutMs?: number): Promise<void>;
+	/** Maximum recommended handlers per event before warning */
+	private static readonly MAX_HANDLERS_WARNING;
 	/**
 	 * Register an event handler
 	 * @param event - Event name
@@ -4872,7 +4883,7 @@ export declare class HttpQueue extends RezoQueue<any> {
  *
  * IMPORTANT: Update these values when bumping package version.
  */
-export declare const VERSION = "1.0.71";
+export declare const VERSION = "1.0.73";
 export declare const PACKAGE_NAME = "rezo";
 export declare const isRezoError: typeof RezoError.isRezoError;
 export declare const Cancel: typeof RezoError;

package/dist/internal/agents/index.cjs

@@ -1,10 +1,10 @@
-const _mod_ciibkn = require('./base.cjs');
-exports.Agent = _mod_ciibkn.Agent;;
-const _mod_xw7r94 = require('./http-proxy.cjs');
-exports.HttpProxyAgent = _mod_xw7r94.HttpProxyAgent;;
-const _mod_tsiao5 = require('./https-proxy.cjs');
-exports.HttpsProxyAgent = _mod_tsiao5.HttpsProxyAgent;;
-const _mod_7qzeg0 = require('./socks-proxy.cjs');
-exports.SocksProxyAgent = _mod_7qzeg0.SocksProxyAgent;;
-const _mod_6f9tgw = require('./socks-client.cjs');
-exports.SocksClient = _mod_6f9tgw.SocksClient;;
+const _mod_z9dkod = require('./base.cjs');
+exports.Agent = _mod_z9dkod.Agent;;
+const _mod_sd66wk = require('./http-proxy.cjs');
+exports.HttpProxyAgent = _mod_sd66wk.HttpProxyAgent;;
+const _mod_pwlo59 = require('./https-proxy.cjs');
+exports.HttpsProxyAgent = _mod_pwlo59.HttpsProxyAgent;;
+const _mod_a4lzyf = require('./socks-proxy.cjs');
+exports.SocksProxyAgent = _mod_a4lzyf.SocksProxyAgent;;
+const _mod_6yne7d = require('./socks-client.cjs');
+exports.SocksClient = _mod_6yne7d.SocksClient;;

package/dist/platform/browser.d.ts

@@ -2011,6 +2011,13 @@ export interface QueueConfig {
 	intervalCap?: number;
 	/** Carry over unused interval capacity to next interval */
 	carryoverConcurrencyCount?: boolean;
+	/**
+	 * Reject the task promise when an error occurs (default: false)
+	 * When false, errors are swallowed and task.resolve(undefined) is called.
+	 * This prevents unhandled promise rejections but makes error handling harder.
+	 * When true, task.reject(error) is called, allowing proper try/catch handling.
+	 */
+	rejectOnError?: boolean;
 }
 /**
  * Task options when adding to queue
@@ -2216,8 +2223,12 @@ declare class RezoQueue<T = any> {
 	/**
 	 * Wait for queue size to be less than limit
 	 * @param limit - Size threshold
+	 * @param timeoutMs - Optional timeout in milliseconds (default: 0 = no timeout)
+	 *                    If timeout occurs, promise resolves (not rejects) to prevent blocking
 	 */
-	onSizeLessThan(limit: number): Promise<void>;
+	onSizeLessThan(limit: number, timeoutMs?: number): Promise<void>;
+	/** Maximum recommended handlers per event before warning */
+	private static readonly MAX_HANDLERS_WARNING;
 	/**
 	 * Register an event handler
 	 * @param event - Event name
@@ -4568,7 +4579,7 @@ export interface RezoInstance extends Rezo {
  *
  * IMPORTANT: Update these values when bumping package version.
  */
-export declare const VERSION = "1.0.71";
+export declare const VERSION = "1.0.73";
 export declare const isRezoError: typeof RezoError.isRezoError;
 export declare const Cancel: typeof RezoError;
 export declare const CancelToken: {

package/dist/platform/bun.d.ts

@@ -2011,6 +2011,13 @@ export interface QueueConfig {
 	intervalCap?: number;
 	/** Carry over unused interval capacity to next interval */
 	carryoverConcurrencyCount?: boolean;
+	/**
+	 * Reject the task promise when an error occurs (default: false)
+	 * When false, errors are swallowed and task.resolve(undefined) is called.
+	 * This prevents unhandled promise rejections but makes error handling harder.
+	 * When true, task.reject(error) is called, allowing proper try/catch handling.
+	 */
+	rejectOnError?: boolean;
 }
 /**
  * Task options when adding to queue
@@ -2216,8 +2223,12 @@ declare class RezoQueue<T = any> {
 	/**
 	 * Wait for queue size to be less than limit
 	 * @param limit - Size threshold
+	 * @param timeoutMs - Optional timeout in milliseconds (default: 0 = no timeout)
+	 *                    If timeout occurs, promise resolves (not rejects) to prevent blocking
 	 */
-	onSizeLessThan(limit: number): Promise<void>;
+	onSizeLessThan(limit: number, timeoutMs?: number): Promise<void>;
+	/** Maximum recommended handlers per event before warning */
+	private static readonly MAX_HANDLERS_WARNING;
 	/**
 	 * Register an event handler
 	 * @param event - Event name
@@ -4568,7 +4579,7 @@ export interface RezoInstance extends Rezo {
  *
  * IMPORTANT: Update these values when bumping package version.
  */
-export declare const VERSION = "1.0.71";
+export declare const VERSION = "1.0.73";
 export declare const isRezoError: typeof RezoError.isRezoError;
 export declare const Cancel: typeof RezoError;
 export declare const CancelToken: {

package/dist/platform/deno.d.ts

@@ -2011,6 +2011,13 @@ export interface QueueConfig {
 	intervalCap?: number;
 	/** Carry over unused interval capacity to next interval */
 	carryoverConcurrencyCount?: boolean;
+	/**
+	 * Reject the task promise when an error occurs (default: false)
+	 * When false, errors are swallowed and task.resolve(undefined) is called.
+	 * This prevents unhandled promise rejections but makes error handling harder.
+	 * When true, task.reject(error) is called, allowing proper try/catch handling.
+	 */
+	rejectOnError?: boolean;
 }
 /**
  * Task options when adding to queue
@@ -2216,8 +2223,12 @@ declare class RezoQueue<T = any> {
 	/**
 	 * Wait for queue size to be less than limit
 	 * @param limit - Size threshold
+	 * @param timeoutMs - Optional timeout in milliseconds (default: 0 = no timeout)
+	 *                    If timeout occurs, promise resolves (not rejects) to prevent blocking
 	 */
-	onSizeLessThan(limit: number): Promise<void>;
+	onSizeLessThan(limit: number, timeoutMs?: number): Promise<void>;
+	/** Maximum recommended handlers per event before warning */
+	private static readonly MAX_HANDLERS_WARNING;
 	/**
 	 * Register an event handler
 	 * @param event - Event name
@@ -4568,7 +4579,7 @@ export interface RezoInstance extends Rezo {
  *
  * IMPORTANT: Update these values when bumping package version.
  */
-export declare const VERSION = "1.0.71";
+export declare const VERSION = "1.0.73";
 export declare const isRezoError: typeof RezoError.isRezoError;
 export declare const Cancel: typeof RezoError;
 export declare const CancelToken: {

package/dist/platform/node.d.ts

@@ -2011,6 +2011,13 @@ export interface QueueConfig {
 	intervalCap?: number;
 	/** Carry over unused interval capacity to next interval */
 	carryoverConcurrencyCount?: boolean;
+	/**
+	 * Reject the task promise when an error occurs (default: false)
+	 * When false, errors are swallowed and task.resolve(undefined) is called.
+	 * This prevents unhandled promise rejections but makes error handling harder.
+	 * When true, task.reject(error) is called, allowing proper try/catch handling.
+	 */
+	rejectOnError?: boolean;
 }
 /**
  * Task options when adding to queue
@@ -2216,8 +2223,12 @@ declare class RezoQueue<T = any> {
 	/**
 	 * Wait for queue size to be less than limit
 	 * @param limit - Size threshold
+	 * @param timeoutMs - Optional timeout in milliseconds (default: 0 = no timeout)
+	 *                    If timeout occurs, promise resolves (not rejects) to prevent blocking
 	 */
-	onSizeLessThan(limit: number): Promise<void>;
+	onSizeLessThan(limit: number, timeoutMs?: number): Promise<void>;
+	/** Maximum recommended handlers per event before warning */
+	private static readonly MAX_HANDLERS_WARNING;
 	/**
 	 * Register an event handler
 	 * @param event - Event name
@@ -4568,7 +4579,7 @@ export interface RezoInstance extends Rezo {
  *
  * IMPORTANT: Update these values when bumping package version.
  */
-export declare const VERSION = "1.0.71";
+export declare const VERSION = "1.0.73";
 export declare const isRezoError: typeof RezoError.isRezoError;
 export declare const Cancel: typeof RezoError;
 export declare const CancelToken: {

package/dist/platform/react-native.d.ts

@@ -2011,6 +2011,13 @@ export interface QueueConfig {
 	intervalCap?: number;
 	/** Carry over unused interval capacity to next interval */
 	carryoverConcurrencyCount?: boolean;
+	/**
+	 * Reject the task promise when an error occurs (default: false)
+	 * When false, errors are swallowed and task.resolve(undefined) is called.
+	 * This prevents unhandled promise rejections but makes error handling harder.
+	 * When true, task.reject(error) is called, allowing proper try/catch handling.
+	 */
+	rejectOnError?: boolean;
 }
 /**
  * Task options when adding to queue
@@ -2216,8 +2223,12 @@ declare class RezoQueue<T = any> {
 	/**
 	 * Wait for queue size to be less than limit
 	 * @param limit - Size threshold
+	 * @param timeoutMs - Optional timeout in milliseconds (default: 0 = no timeout)
+	 *                    If timeout occurs, promise resolves (not rejects) to prevent blocking
 	 */
-	onSizeLessThan(limit: number): Promise<void>;
+	onSizeLessThan(limit: number, timeoutMs?: number): Promise<void>;
+	/** Maximum recommended handlers per event before warning */
+	private static readonly MAX_HANDLERS_WARNING;
 	/**
 	 * Register an event handler
 	 * @param event - Event name
@@ -4568,7 +4579,7 @@ export interface RezoInstance extends Rezo {
  *
  * IMPORTANT: Update these values when bumping package version.
  */
-export declare const VERSION = "1.0.71";
+export declare const VERSION = "1.0.73";
 export declare const isRezoError: typeof RezoError.isRezoError;
 export declare const Cancel: typeof RezoError;
 export declare const CancelToken: {