@crawlee/core 4.0.0-beta.8 → 4.0.0-beta.81

package/system-info/cpu-info.js

@@ -0,0 +1,216 @@
+import { execSync } from 'node:child_process';
+import { readFile } from 'node:fs/promises';
+import os from 'node:os';
+import { getCgroupsVersion } from './runtime.js';
+const CPU_FILE_PATHS = {
+    STAT: {
+        V1: '/sys/fs/cgroup/cpuacct/cpuacct.usage',
+        V2: '/sys/fs/cgroup/cpu.stat',
+    },
+    QUOTA: {
+        V1: '/sys/fs/cgroup/cpu/cpu.cfs_quota_us',
+        V2: '/sys/fs/cgroup/cpu.max',
+    },
+    PERIOD: {
+        V1: '/sys/fs/cgroup/cpu/cpu.cfs_period_us',
+        V2: '/sys/fs/cgroup/cpu.max',
+    },
+};
+let CLOCK_TICKS_PER_SECOND = 100;
+let CLOCK_TICKS_CHECKED = false;
+const NANOSECONDS_PER_SECOND = 1e9;
+const previousTicks = { idle: 0, total: 0 };
+/**
+ * Gets the "bare metal" cpu load.
+ * Used in
+ *  - AWS Lambda
+ *  - Containers without a cGroup quota
+ *  - Uncontainerized environments
+ * @returns a number between 0 and 1 for the cpu load
+ * @internal
+ */
+export function getCurrentCpuTicks() {
+    const cpusCores = os.cpus();
+    const ticks = cpusCores.reduce((acc, cpu) => {
+        const cpuTimes = Object.values(cpu.times);
+        return {
+            idle: acc.idle + cpu.times.idle,
+            total: acc.total + cpuTimes.reduce((sum, num) => sum + num),
+        };
+    }, { idle: 0, total: 0 });
+    const idleTicksDelta = ticks.idle - previousTicks.idle;
+    const totalTicksDelta = ticks.total - previousTicks.total;
+    Object.assign(previousTicks, ticks);
+    return totalTicksDelta ? 1 - idleTicksDelta / totalTicksDelta : 0;
+}
+/**
+ * Reads the linux tick rate.
+ * @returns the number of ticks per second, or `null` if detection failed
+ */
+function getClockTicks() {
+    try {
+        return parseInt(execSync('getconf CLK_TCK').toString().trim(), 10);
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Reads the cgroup cpu quota.
+ * In V1, a quota of -1 means “unlimited.”
+ * In V2, a first field of "max" means unlimited.
+ * @param cgroupsVersion the cGroup version
+ * @returns The Cpu Quota
+ * @internal
+ */
+export async function getCpuQuota(cgroupsVersion) {
+    if (cgroupsVersion === 'V1') {
+        const quotaStr = await readFile(CPU_FILE_PATHS.QUOTA.V1, 'utf8');
+        const quota = parseInt(quotaStr.trim(), 10);
+        return quota === -1 ? null : quota;
+    }
+    // cgroup v2
+    const maxStr = await readFile(CPU_FILE_PATHS.QUOTA.V2, 'utf8');
+    const parts = maxStr.trim().split(/\s+/);
+    if (parts[0] === 'max') {
+        return null;
+    }
+    return parseInt(parts[0], 10);
+}
+/**
+ * Reads the cgroup cpu period.
+ * @param cgroupsVersion the cGroup version
+ * @returns The Cpu quota period
+ * @internal
+ */
+export async function getCpuPeriod(cgroupsVersion) {
+    if (cgroupsVersion === 'V1') {
+        const quotaStr = await readFile(CPU_FILE_PATHS.PERIOD.V1, 'utf8');
+        const quota = parseInt(quotaStr.trim(), 10);
+        return quota;
+    }
+    // cgroup v2
+    const maxStr = await readFile(CPU_FILE_PATHS.PERIOD.V2, 'utf8');
+    const parts = maxStr.trim().split(/\s+/);
+    return parseInt(parts[1], 10);
+}
+/**
+ * Reads the cgroup cpu usage of the container
+ *
+ * @param cgroupsVersion the cGroup version
+ * @returns the cpu usage
+ * @internal
+ */
+export async function getContainerCpuUsage(cgroupsVersion) {
+    if (cgroupsVersion === 'V1') {
+        const data = await readFile(CPU_FILE_PATHS.STAT.V1, 'utf8');
+        return Number(data.trim());
+    }
+    // cgroup v2
+    const data = await readFile(CPU_FILE_PATHS.STAT.V2, 'utf8');
+    const lines = data.split('\n');
+    let usageUsec = 0;
+    for (const line of lines) {
+        const parts = line.trim().split(/\s+/);
+        if (parts[0] === 'usage_usec') {
+            usageUsec = Number(parts[1]);
+            break;
+        }
+    }
+    // Convert microseconds to nanoseconds.
+    return usageUsec * 1000;
+}
+/**
+ * Reads the cgroup cpu usage of the system from cgroup
+ *
+ * @returns the cpu usage
+ * @internal
+ */
+export async function getSystemCpuUsage() {
+    const statData = await readFile('/proc/stat', 'utf8');
+    const lines = statData.split('\n');
+    for (const line of lines) {
+        if (line.startsWith('cpu ')) {
+            // Split the line and extract the first seven numeric fields:
+            // user, nice, system, idle, iowait, irq, softirq
+            const parts = line.split(/\s+/).slice(1, 8);
+            let totalTicks = 0;
+            for (const part of parts) {
+                totalTicks += Number(part);
+            }
+            // Convert clock ticks to nanoseconds.
+            return (totalTicks * NANOSECONDS_PER_SECOND) / CLOCK_TICKS_PER_SECOND;
+        }
+    }
+    throw new Error('no cpu line'); // shouldnt ever happen
+}
+/**
+ * Takes a CPU usage sample for both the container and the system.
+ *
+ * @returns An object containing the container and system CPU usage.
+ * @internal
+ */
+export async function sampleCpuUsage(cGroupsVersion) {
+    const [containerUsage, systemUsage] = await Promise.all([
+        getContainerCpuUsage(cGroupsVersion),
+        getSystemCpuUsage(),
+    ]);
+    return { containerUsage, systemUsage };
+}
+let previousSample = { containerUsage: 0, systemUsage: 0 };
+/**
+ * Gets the cpu usage of the system.
+ * If the crawler is running in a containerized environment, crawlee will check for a cgroup enforced cpu limit.
+ * If a cgroup limit is found, it will be taken as the maximum load against which the current load will be gauged.
+ * @returns a number between 0 and 1 for the cpu load
+ * @internal
+ */
+export async function getCurrentCpuTicksV2(options = {}) {
+    const { containerized = false, logger } = options;
+    try {
+        // if not containerized
+        if (!containerized) {
+            // bare metal cpu limit
+            return getCurrentCpuTicks();
+        }
+        if (!CLOCK_TICKS_CHECKED) {
+            const ticks = getClockTicks();
+            if (ticks === null) {
+                CLOCK_TICKS_PER_SECOND = 100;
+                logger?.warning('Failed to get clock ticks; defaulting to 100. CPU metrics may be inaccurate.');
+            }
+            else {
+                CLOCK_TICKS_PER_SECOND = ticks;
+            }
+            CLOCK_TICKS_CHECKED = true;
+        }
+        const cgroupsVersion = await getCgroupsVersion();
+        // if cgroup is not detected, return bare metal cpu limit
+        if (cgroupsVersion === null) {
+            logger?.warningOnce('Your environment is containerized, but your system does not support cgroups.\n' +
+                "If you're running containers with limited cpu, cpu auto-scaling will not work properly.");
+            return getCurrentCpuTicks();
+        }
+        // cgroup aware cpu limit. If no limits are set, default to returning getCurrentCpuTicks.
+        const quota = await getCpuQuota(cgroupsVersion);
+        if (quota === null) {
+            // no cgroup limit, return host cpu load
+            return getCurrentCpuTicks();
+        }
+        const period = await getCpuPeriod(cgroupsVersion);
+        // eg. having a 200000us quots per 100000us means the cGroup can fully use 2 cores
+        const cpuAllowance = quota / period;
+        const sample = await sampleCpuUsage(cgroupsVersion);
+        const containerDelta = sample.containerUsage - previousSample.containerUsage;
+        const systemDelta = sample.systemUsage - previousSample.systemUsage;
+        previousSample = sample;
+        const numCpus = os.cpus().length;
+        // Calculate the CPU usage percentage.
+        return ((containerDelta / systemDelta) * numCpus) / cpuAllowance;
+    }
+    catch (err) {
+        // if anything fails, default to bare metal metrics
+        logger?.warning('Cpu snapshot failed, falling back to bare-metal metrics.', { error: err });
+        return getCurrentCpuTicks();
+    }
+}

package/system-info/memory-info.d.ts

@@ -0,0 +1,31 @@
+import type { CrawleeLogger } from '@crawlee/types';
+/**
+ * Describes memory usage of the process.
+ */
+export interface MemoryInfo {
+    /** Total memory available in the system or container */
+    totalBytes: number;
+    /** Amount of free memory in the system or container */
+    freeBytes: number;
+    /** Amount of memory used (= totalBytes - freeBytes) */
+    usedBytes: number;
+    /** Amount of memory used the current Node.js process */
+    mainProcessBytes: number;
+    /** Amount of memory used by child processes of the current Node.js process */
+    childProcessesBytes: number;
+}
+/**
+ * Returns memory statistics of the process and the system, see {@link MemoryInfo}.
+ *
+ * If the process runs inside of a container, the `getMemoryInfo` gets container memory limits,
+ * otherwise it gets system memory limits.
+ *
+ * Beware that the function is quite inefficient because it spawns a new process.
+ * Therefore you shouldn't call it too often, like more than once per second.
+ * @returns An object containing the free and used memory metrics.
+ * @internal
+ */
+export declare function getMemoryInfo(options?: {
+    containerized?: boolean;
+    logger?: CrawleeLogger;
+}): Promise<MemoryInfo>;

package/system-info/memory-info.js

@@ -0,0 +1,115 @@
+import { execSync } from 'node:child_process';
+import { readFile } from 'node:fs/promises';
+import { freemem, totalmem } from 'node:os';
+import { getCgroupsVersion, isLambda } from './runtime.js';
+import { psTree } from './ps-tree.js';
+const MEMORY_FILE_PATHS = {
+    TOTAL: {
+        V1: '/sys/fs/cgroup/memory/memory.limit_in_bytes',
+        V2: '/sys/fs/cgroup/memory.max',
+    },
+    USED: {
+        V1: '/sys/fs/cgroup/memory/memory.usage_in_bytes',
+        V2: '/sys/fs/cgroup/memory.current',
+    },
+};
+/**
+ * Returns memory statistics of the process and the system, see {@link MemoryInfo}.
+ *
+ * If the process runs inside of a container, the `getMemoryInfo` gets container memory limits,
+ * otherwise it gets system memory limits.
+ *
+ * Beware that the function is quite inefficient because it spawns a new process.
+ * Therefore you shouldn't call it too often, like more than once per second.
+ * @returns An object containing the free and used memory metrics.
+ * @internal
+ */
+export async function getMemoryInfo(options = {}) {
+    const { containerized = false, logger } = options;
+    let mainProcessBytes = -1;
+    let childProcessesBytes = 0;
+    // lambda does *not* have `ps` and other command line tools
+    // required to extract memory usage.
+    if (isLambda()) {
+        // reported in bytes
+        mainProcessBytes = process.memoryUsage().rss;
+        // https://stackoverflow.com/a/55914335/129415
+        const memInfo = execSync('cat /proc/meminfo').toString();
+        const values = memInfo.split(/[\n: ]/).filter((val) => val.trim());
+        // /proc/meminfo reports in kb, not bytes, the total used memory is reported by meminfo
+        // subtract memory used by the main node process in order to infer memory used by any child processes
+        childProcessesBytes = +values[19] * 1000 - mainProcessBytes;
+    }
+    else {
+        // Query both root and child processes
+        const processes = await psTree(process.pid, true);
+        processes.forEach((rec) => {
+            // Obtain main process' memory separately
+            if (rec.PID === `${process.pid}`) {
+                mainProcessBytes = rec.RSS;
+                return;
+            }
+            childProcessesBytes += rec.RSS;
+        });
+    }
+    let totalBytes;
+    let usedBytes;
+    let freeBytes;
+    if (isLambda()) {
+        // memory size is defined in megabytes
+        totalBytes = parseInt(process.env.AWS_LAMBDA_FUNCTION_MEMORY_SIZE, 10) * 1000000;
+        usedBytes = mainProcessBytes + childProcessesBytes;
+        freeBytes = totalBytes - usedBytes;
+    }
+    else if (containerized) {
+        // When running inside a container, use container memory limits
+        const cgroupsVersion = await getCgroupsVersion();
+        try {
+            if (cgroupsVersion === null) {
+                throw new Error('cgroup not available');
+            }
+            let [totalBytesStr, usedBytesStr] = await Promise.all([
+                readFile(MEMORY_FILE_PATHS.TOTAL[cgroupsVersion], 'utf8'),
+                readFile(MEMORY_FILE_PATHS.USED[cgroupsVersion], 'utf8'),
+            ]);
+            // Cgroups V2 files contains newline character. Getting rid of it for better handling in later part of the code.
+            totalBytesStr = totalBytesStr.replace(/[^a-zA-Z0-9 ]/g, '');
+            usedBytesStr = usedBytesStr.replace(/[^a-zA-Z0-9 ]/g, '');
+            // Cgroups V2 contains 'max' string if memory is not limited
+            // See https://git.kernel.org/pub/scm/linux/kernel/git/tj/cgroup.git/tree/Documentation/admin-guide/cgroup-v2.rst (see "memory.max")
+            if (totalBytesStr === 'max') {
+                totalBytes = totalmem();
+                // Cgroups V1 is set to number related to platform and page size if memory is not limited
+                // See https://unix.stackexchange.com/q/420906
+            }
+            else {
+                totalBytes = parseInt(totalBytesStr, 10);
+                const containerRunsWithUnlimitedMemory = totalBytes > Number.MAX_SAFE_INTEGER;
+                if (containerRunsWithUnlimitedMemory)
+                    totalBytes = totalmem();
+            }
+            usedBytes = parseInt(usedBytesStr, 10);
+            freeBytes = totalBytes - usedBytes;
+        }
+        catch (err) {
+            logger?.warningOnce('Your environment is containerized, but your system does not support memory cgroups. ' +
+                "If you're running containers with limited memory, memory auto-scaling will not work properly.\n\n" +
+                `Cause: ${err.message}`);
+            totalBytes = totalmem();
+            freeBytes = freemem();
+            usedBytes = totalBytes - freeBytes;
+        }
+    }
+    else {
+        totalBytes = totalmem();
+        freeBytes = freemem();
+        usedBytes = totalBytes - freeBytes;
+    }
+    return {
+        totalBytes,
+        freeBytes,
+        usedBytes,
+        mainProcessBytes,
+        childProcessesBytes,
+    };
+}

package/system-info/ps-tree.d.ts

@@ -0,0 +1,17 @@
+export interface ProcessInfo {
+    PPID: string;
+    PID: string;
+    STAT: string | null;
+    RSS: number;
+    COMMAND: string;
+}
+/**
+ * Returns a promise that resolves with an array of ProcessInfo objects representing
+ * the children of the given PID.
+ *
+ * @param pid - The PID (number or string) for which to list child processes.
+ * @param includeRoot - Optional flag. When true, include the process with the given PID if found.
+ *                      Defaults to false.
+ * @internal
+ */
+export declare function psTree(pid: number | string, includeRoot?: boolean): Promise<ProcessInfo[]>;

package/system-info/ps-tree.js

@@ -0,0 +1,144 @@
+import { spawn } from 'node:child_process';
+import * as readline from 'node:readline';
+/**
+ * Returns a promise that resolves with an array of ProcessInfo objects representing
+ * the children of the given PID.
+ *
+ * @param pid - The PID (number or string) for which to list child processes.
+ * @param includeRoot - Optional flag. When true, include the process with the given PID if found.
+ *                      Defaults to false.
+ * @internal
+ */
+export async function psTree(pid, includeRoot = false) {
+    return new Promise((resolve, reject) => {
+        if (typeof pid === 'number') {
+            pid = pid.toString();
+        }
+        let processLister;
+        if (process.platform === 'win32') {
+            processLister = spawn('powershell', [
+                '-NoProfile',
+                '-Command',
+                'Get-CimInstance Win32_Process | Format-Table ProcessId,ParentProcessId,WorkingSetSize,Name',
+            ]);
+        }
+        else {
+            processLister = spawn('ps', ['-A', '-o', 'ppid,pid,stat,rss,comm']);
+        }
+        processLister.on('error', reject);
+        if (!processLister.stdout) {
+            reject(new Error('Child process stdout is null'));
+            return;
+        }
+        // Create a readline interface to process stdout line-by-line.
+        const rl = readline.createInterface({
+            input: processLister.stdout,
+        });
+        const rows = [];
+        let headers = null;
+        rl.on('line', (line) => {
+            const trimmed = line.trim();
+            if (trimmed === '') {
+                return; // Skip empty lines.
+            }
+            // When headers have been set, skip a dashed separator line.
+            const fields = trimmed.split(/\s+/);
+            if (headers !== null && fields.every((field) => /^-+$/.test(field))) {
+                return;
+            }
+            // The first nonempty line is assumed to be the header row.
+            if (!headers) {
+                headers = fields.map(normalizeHeader);
+                return;
+            }
+            // Copy the fields into an array to process.
+            const columns = fields.slice();
+            // Build the process row object.
+            const row = {};
+            const hdrs = headers.slice();
+            // For all headers except the last one, assign one column per header.
+            // The last header gets all remaining columns joined (in case the command name contains spaces).
+            for (const [index, header] of hdrs.entries()) {
+                let value;
+                if (index === hdrs.length - 1) {
+                    value = columns.join(' ');
+                }
+                else {
+                    value = columns.shift();
+                }
+                if (header === 'RSS') {
+                    row[header] = Number.parseInt(value, 10);
+                    if (process.platform !== 'win32') {
+                        // On Unix like systems, convert RSS (in KB) to bytes.
+                        row[header] *= 1024;
+                    }
+                }
+                else {
+                    row[header] = value;
+                }
+            }
+            // On Windows, add STAT with a null value for compatibility.
+            if (process.platform === 'win32') {
+                row.STAT = null;
+            }
+            rows.push(row);
+        });
+        rl.on('close', () => {
+            const parents = {};
+            const children = [];
+            // Seed with the provided PID.
+            parents[pid] = true;
+            // Build the list of child processes.
+            rows.forEach((proc) => {
+                // Skip the 'ps' or 'powershell' commands used by psTree to query the processes
+                if (proc.COMMAND === 'ps' || proc.COMMAND === 'powershell.exe') {
+                    return;
+                }
+                if (parents[proc.PPID]) {
+                    parents[proc.PID] = true;
+                    children.push(proc);
+                }
+                else if (includeRoot && pid === proc.PID) {
+                    children.push(proc);
+                }
+            });
+            resolve(children);
+        });
+        // Also listen for errors on the stdout stream.
+        processLister.stdout.on('error', reject);
+    });
+}
+/**
+ * Normalizes the header names so that the rest of the code can work uniformly.
+ *
+ * On non‑Windows systems, we only adjust "COMM" to "COMMAND" (e.g. on macOS).
+ * On Windows, the headers from Get-CimInstance + Format-Table are:
+ *
+ *    ProcessId, ParentProcessId, WorkingSetSize, Name
+ *
+ * which are mapped to:
+ *
+ *    PID, PPID, RSS, COMMAND
+ */
+function normalizeHeader(str) {
+    if (process.platform !== 'win32') {
+        // macOS may output "COMM" instead of "COMMAND"
+        if (str === 'COMM')
+            return 'COMMAND';
+        return str;
+    }
+    switch (str) {
+        case 'Name':
+            return 'COMMAND';
+        case 'ParentProcessId':
+            return 'PPID';
+        case 'ProcessId':
+            return 'PID';
+        case 'Status':
+            return 'STAT';
+        case 'WorkingSetSize':
+            return 'RSS';
+        default:
+            throw new Error(`Unknown process listing header: ${str}`);
+    }
+}

package/system-info/runtime.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Returns a `Promise` that resolves to true if the code is running in a Docker container.
+ */
+export declare function isDocker(forceReset?: boolean): Promise<boolean>;
+/**
+ * Detects if crawlee is running in a containerized environment.
+ */
+export declare function isContainerized(): Promise<boolean>;
+export declare function isLambda(): boolean;
+/**
+ * gets the cgroup version by checking for a file at /sys/fs/cgroup/memory
+ * @returns "V1" or "V2" for the version of cgroup or null if cgroup is not found.
+ */
+export declare function getCgroupsVersion(forceReset?: boolean): Promise<"V1" | "V2" | null>;

package/system-info/runtime.js

@@ -0,0 +1,80 @@
+import fs from 'node:fs/promises';
+let isDockerPromiseCache;
+async function createIsDockerPromise() {
+    const promise1 = fs
+        .stat('/.dockerenv')
+        .then(() => true)
+        .catch(() => false);
+    const promise2 = fs
+        .readFile('/proc/self/cgroup', 'utf8')
+        .then((content) => content.includes('docker'))
+        .catch(() => false);
+    const [result1, result2] = await Promise.all([promise1, promise2]);
+    return result1 || result2;
+}
+/**
+ * Returns a `Promise` that resolves to true if the code is running in a Docker container.
+ */
+export async function isDocker(forceReset) {
+    // Parameter forceReset is just internal for unit tests.
+    if (!isDockerPromiseCache || forceReset)
+        isDockerPromiseCache = createIsDockerPromise();
+    return isDockerPromiseCache;
+}
+let isContainerizedResult;
+/**
+ * Detects if crawlee is running in a containerized environment.
+ */
+export async function isContainerized() {
+    // Value is very unlikley to change. Cache the result after the first execution.
+    if (isContainerizedResult !== undefined) {
+        return isContainerizedResult;
+    }
+    // return false if running in aws lambda
+    if (isLambda()) {
+        isContainerizedResult = false;
+        return isContainerizedResult;
+    }
+    const dockerenvCheck = fs
+        .stat('/.dockerenv')
+        .then(() => true)
+        .catch(() => false);
+    const cgroupCheck = fs
+        .readFile('/proc/self/cgroup', 'utf8')
+        .then((content) => content.includes('docker'))
+        .catch(() => false);
+    const [dockerenvResult, cgroupResult] = await Promise.all([dockerenvCheck, cgroupCheck]);
+    isContainerizedResult = dockerenvResult || cgroupResult || !!process.env.KUBERNETES_SERVICE_HOST;
+    return isContainerizedResult;
+}
+export function isLambda() {
+    return !!process.env.AWS_LAMBDA_FUNCTION_MEMORY_SIZE;
+}
+let _cgroupsVersion;
+/**
+ * gets the cgroup version by checking for a file at /sys/fs/cgroup/memory
+ * @returns "V1" or "V2" for the version of cgroup or null if cgroup is not found.
+ */
+export async function getCgroupsVersion(forceReset) {
+    // Parameter forceReset is just internal for unit tests.
+    if (_cgroupsVersion !== undefined && !forceReset) {
+        return _cgroupsVersion;
+    }
+    try {
+        // If this directory does not exists, cgroups are not available
+        await fs.access('/sys/fs/cgroup/');
+    }
+    catch (e) {
+        _cgroupsVersion = null;
+        return null;
+    }
+    _cgroupsVersion = 'V1';
+    try {
+        // If this directory does not exists, assume the container is using cgroups V2
+        await fs.access('/sys/fs/cgroup/memory/');
+    }
+    catch (e) {
+        _cgroupsVersion = 'V2';
+    }
+    return _cgroupsVersion;
+}

package/typedefs.d.ts

@@ -6,5 +6,4 @@ export type Awaitable<T> = T | PromiseLike<T>;
 export declare function entries<T extends {}>(obj: T): [keyof T, T[keyof T]][];
 /** @ignore */
 export declare function keys<T extends {}>(obj: T): (keyof T)[];
-export declare type AllowedHttpMethods = 'GET' | 'HEAD' | 'POST' | 'PUT' | 'DELETE' | 'TRACE' | 'OPTIONS' | 'CONNECT' | 'PATCH';
-//# sourceMappingURL=typedefs.d.ts.map
+export type { AllowedHttpMethods } from '@crawlee/types';

package/typedefs.js

@@ -6,4 +6,3 @@ export function entries(obj) {
 export function keys(obj) {
     return Object.keys(obj);
 }
-//# sourceMappingURL=typedefs.js.map

package/validators.d.ts

@@ -17,5 +17,12 @@ export declare const validators: {
         validator: boolean;
         message: (label: string) => string;
     };
+    browserPool: (value: Dictionary) => {
+        validator: boolean;
+        message: (label: string) => string;
+    };
+    sessionPool: (value: Dictionary) => {
+        validator: boolean;
+        message: (label: string) => string;
+    };
 };
-//# sourceMappingURL=validators.d.ts.map

package/validators.js

@@ -7,8 +7,8 @@ export const validators = {
         message: (label) => `Expected argument '${label}' to be a Puppeteer Page, got something else.`,
     }),
     proxyConfiguration: (value) => ({
-        validator: ow.isValid(value, ow.object.hasKeys('newUrl', 'newProxyInfo')),
-        message: (label) => `Expected argument '${label}' to be a ProxyConfiguration, got something else.`,
+        validator: ow.isValid(value, ow.object.hasKeys('newProxyInfo')),
+        message: (label) => `Expected argument '${label}' to implement the IProxyConfiguration interface (missing 'newProxyInfo'), got something else.`,
     }),
     requestList: (value) => ({
         validator: ow.isValid(value, ow.object.hasKeys('fetchNextRequest', 'persistState')),
@@ -18,5 +18,12 @@ export const validators = {
         validator: ow.isValid(value, ow.object.hasKeys('fetchNextRequest', 'addRequest')),
         message: (label) => `Expected argument '${label}' to be a RequestQueue, got something else.`,
     }),
+    browserPool: (value) => ({
+        validator: ow.isValid(value, ow.object.hasKeys('newPage', 'closePage', 'extractPageState', 'injectPageState')),
+        message: (label) => `Expected argument '${label}' to implement the IBrowserPool interface (missing one of 'newPage', 'closePage', 'extractPageState', 'injectPageState'), got something else.`,
+    }),
+    sessionPool: (value) => ({
+        validator: ow.isValid(value, ow.object.hasKeys('getSession')),
+        message: (label) => `Expected argument '${label}' to implement the ISessionPool interface (missing 'getSession'), got something else.`,
+    }),
 };
-//# sourceMappingURL=validators.js.map