@crawlee/core 4.0.0-beta.1 → 4.0.0-beta.100

package/enqueue_links/enqueue_links.js

@@ -1,7 +1,7 @@
 import ow from 'ow';
 import { getDomain } from 'tldts';
-import log from '@apify/log';
-import { constructGlobObjectsFromGlobs, constructRegExpObjectsFromPseudoUrls, constructRegExpObjectsFromRegExps, createRequestOptions, createRequests, filterRequestsByPatterns, } from './shared.js';
+import { Request } from '../request.js';
+import { applyRequestTransform, constructUrlPatternObjects, createRequestOptions, filterRequestOptionsByPatterns, } from './shared.js';
 /**
  * The different enqueueing strategies available.
  *
@@ -58,17 +58,16 @@ export var EnqueueStrategy;
  * This function enqueues the urls provided to the {@link RequestQueue} provided. If you want to automatically find and enqueue links,
  * you should use the context-aware `enqueueLinks` function provided on the crawler contexts.
  *
- * Optionally, the function allows you to filter the target links' URLs using an array of globs or regular expressions
- * and override settings of the enqueued {@link Request} objects.
+ * Optionally, the function allows you to filter the target links' URLs using an array of glob or regexp patterns.
  *
  * **Example usage**
  *
  * ```javascript
  * await enqueueLinks({
  *   urls: aListOfFoundUrls,
- *   requestQueue,
+ *   requestManager,
  *   selector: 'a.product-detail',
- *   globs: [
+ *   include: [
  *       'https://www.example.com/handbags/*',
  *       'https://www.example.com/purses/*'
  *   ],
@@ -85,52 +84,33 @@ export async function enqueueLinks(options) {
             'Check out our guide on how to use enqueueLinks() here: https://crawlee.dev/js/docs/examples/crawl-relative-links',
         ].join('\n'));
     }
+    const urlPatternValidator = ow.any(ow.string, ow.regExp, ow.object.hasKeys('glob'), ow.object.hasKeys('regexp'));
     ow(options, ow.object.exactShape({
         urls: ow.array.ofType(ow.string),
-        requestQueue: ow.object.hasKeys('fetchNextRequest', 'addRequest'),
+        requestManager: ow.object.hasKeys('addRequestsBatched'),
         robotsTxtFile: ow.optional.object.hasKeys('isAllowed'),
+        respectRobotsTxtFile: ow.optional.any(ow.boolean, ow.object.exactShape({ userAgent: ow.optional.string })),
         onSkippedRequest: ow.optional.function,
         forefront: ow.optional.boolean,
         skipNavigation: ow.optional.boolean,
+        sessionId: ow.optional.string,
         limit: ow.optional.number,
         selector: ow.optional.string,
         baseUrl: ow.optional.string,
         userData: ow.optional.object,
         label: ow.optional.string,
-        pseudoUrls: ow.optional.array.ofType(ow.any(ow.string, ow.object.hasKeys('purl'))),
-        globs: ow.optional.array.ofType(ow.any(ow.string, ow.object.hasKeys('glob'))),
-        exclude: ow.optional.array.ofType(ow.any(ow.string, ow.regExp, ow.object.hasKeys('glob'), ow.object.hasKeys('regexp'))),
-        regexps: ow.optional.array.ofType(ow.any(ow.regExp, ow.object.hasKeys('regexp'))),
+        include: ow.optional.array.minLength(1).ofType(urlPatternValidator),
+        exclude: ow.optional.array.ofType(urlPatternValidator),
         transformRequestFunction: ow.optional.function,
         strategy: ow.optional.string.oneOf(Object.values(EnqueueStrategy)),
         waitForAllRequestsToBeAdded: ow.optional.boolean,
     }));
-    const { requestQueue, limit, urls, pseudoUrls, exclude, globs, regexps, transformRequestFunction, forefront, waitForAllRequestsToBeAdded, robotsTxtFile, onSkippedRequest, } = options;
-    const urlExcludePatternObjects = [];
-    const urlPatternObjects = [];
-    if (exclude?.length) {
-        for (const excl of exclude) {
-            if (typeof excl === 'string' || 'glob' in excl) {
-                urlExcludePatternObjects.push(...constructGlobObjectsFromGlobs([excl]));
-            }
-            else if (excl instanceof RegExp || 'regexp' in excl) {
-                urlExcludePatternObjects.push(...constructRegExpObjectsFromRegExps([excl]));
-            }
-        }
-    }
-    if (pseudoUrls?.length) {
-        log.deprecated('`pseudoUrls` option is deprecated, use `globs` or `regexps` instead');
-        urlPatternObjects.push(...constructRegExpObjectsFromPseudoUrls(pseudoUrls));
-    }
-    if (globs?.length) {
-        urlPatternObjects.push(...constructGlobObjectsFromGlobs(globs));
-    }
-    if (regexps?.length) {
-        urlPatternObjects.push(...constructRegExpObjectsFromRegExps(regexps));
-    }
-    if (!urlPatternObjects.length) {
-        options.strategy ??= EnqueueStrategy.SameHostname;
-    }
+    const { requestManager, limit, urls, include, exclude, transformRequestFunction, forefront, waitForAllRequestsToBeAdded, robotsTxtFile, onSkippedRequest, } = options;
+    const urlExcludePatternObjects = exclude?.length ? constructUrlPatternObjects(exclude) : [];
+    const urlPatternObjects = include?.length ? constructUrlPatternObjects(include) : [];
+    // The strategy always applies, even when `include` patterns are provided - the two are AND-ed together
+    // (a URL must match an `include` pattern *and* satisfy the strategy). This mirrors crawlee-python.
+    options.strategy ??= EnqueueStrategy.SameHostname;
     const enqueueStrategyPatterns = [];
     if (options.baseUrl) {
         const url = new URL(options.baseUrl);
@@ -167,44 +147,60 @@ export async function enqueueLinks(options) {
                 break;
         }
     }
+    async function reportSkippedRequests(skippedRequests, reason) {
+        if (onSkippedRequest && skippedRequests.length > 0) {
+            await Promise.all(skippedRequests.map((request) => {
+                return onSkippedRequest({
+                    url: request.url,
+                    reason: request.skippedReason ?? reason,
+                });
+            }));
+        }
+    }
     let requestOptions = createRequestOptions(urls, options);
-    if (robotsTxtFile) {
+    if (robotsTxtFile && options.respectRobotsTxtFile !== false) {
+        const robotsUserAgent = typeof options.respectRobotsTxtFile === 'object' ? (options.respectRobotsTxtFile.userAgent ?? '*') : '*';
         const skippedRequests = [];
         requestOptions = requestOptions.filter((request) => {
-            if (robotsTxtFile.isAllowed(request.url)) {
+            if (robotsTxtFile.isAllowed(request.url, robotsUserAgent)) {
                 return true;
             }
             skippedRequests.push(request);
             return false;
         });
-        if (onSkippedRequest && skippedRequests.length > 0) {
-            await Promise.all(skippedRequests.map((request) => {
-                return onSkippedRequest({ url: request.url, reason: 'robotsTxt' });
-            }));
-        }
+        await reportSkippedRequests(skippedRequests, 'robotsTxt');
     }
-    if (transformRequestFunction) {
-        requestOptions = requestOptions
-            .map((request) => transformRequestFunction(request))
-            .filter((r) => !!r);
-    }
-    function createFilteredRequests() {
-        // No user provided patterns means we can skip an extra filtering step
+    async function createFilteredRequests() {
+        const skippedRequests = [];
+        // Step 1: Filter request options by exclude patterns, user include patterns, and strategy patterns.
+        let filteredOptions;
         if (urlPatternObjects.length === 0) {
-            return createRequests(requestOptions, enqueueStrategyPatterns, urlExcludePatternObjects, options.strategy);
+            filteredOptions = filterRequestOptionsByPatterns(requestOptions, enqueueStrategyPatterns.length > 0 ? enqueueStrategyPatterns : undefined, urlExcludePatternObjects, options.strategy, (url) => skippedRequests.push(url));
+        }
+        else {
+            // Filter by user patterns first (with exclude)
+            const afterUserPatterns = filterRequestOptionsByPatterns(requestOptions, urlPatternObjects, urlExcludePatternObjects, options.strategy, (url) => skippedRequests.push(url));
+            // ...then filter by the enqueue links strategy (making this an AND check)
+            filteredOptions = filterRequestOptionsByPatterns(afterUserPatterns, enqueueStrategyPatterns.length > 0 ? enqueueStrategyPatterns : undefined, [], options.strategy, (url) => skippedRequests.push(url));
         }
-        // Generate requests based on the user patterns first
-        const generatedRequestsFromUserFilters = createRequests(requestOptions, urlPatternObjects, urlExcludePatternObjects, options.strategy);
-        // ...then filter them by the enqueue links strategy (making this an AND check)
-        return filterRequestsByPatterns(generatedRequestsFromUserFilters, enqueueStrategyPatterns);
+        await reportSkippedRequests(skippedRequests.map((url) => ({ url })), 'filters');
+        // Step 2: Apply transformRequestFunction on request options - it has the highest priority
+        if (transformRequestFunction) {
+            const skippedByTransform = [];
+            filteredOptions = applyRequestTransform(filteredOptions, transformRequestFunction, (r) => skippedByTransform.push(r));
+            await reportSkippedRequests(skippedByTransform, 'transform');
+        }
+        // Step 3: Create Request instances from the final request options
+        return filteredOptions.map((opts) => new Request(opts));
     }
-    let requests = createFilteredRequests();
-    if (limit)
-        requests = requests.slice(0, limit);
-    const { addedRequests } = await requestQueue.addRequestsBatched(requests, {
+    const { addedRequests, requestsOverLimit } = await requestManager.addRequestsBatched(await createFilteredRequests(), {
         forefront,
         waitForAllRequestsToBeAdded,
+        maxNewRequests: limit,
     });
+    if (requestsOverLimit?.length !== undefined && requestsOverLimit.length > 0) {
+        await reportSkippedRequests(requestsOverLimit.map((r) => ({ url: typeof r === 'string' ? r : r.url })), 'enqueueLimit');
+    }
     return { processedRequests: addedRequests, unprocessedRequests: [] };
 }
 /**
@@ -242,9 +238,8 @@ export function resolveBaseUrlForEnqueueLinksFiltering({ enqueueStrategy, finalR
     return originalUrlOrigin;
 }
 /**
- * Internal function that changes the enqueue globs to match both http and https
+ * Internal function that changes the enqueue glob patterns to match both http and https
  */
 function ignoreHttpSchema(pattern) {
     return pattern.replace(/^(https?):\/\//, 'http{s,}://');
 }
-//# sourceMappingURL=enqueue_links.js.map

package/enqueue_links/index.d.ts

@@ -1,3 +1,2 @@
 export * from './enqueue_links.js';
 export * from './shared.js';
-//# sourceMappingURL=index.d.ts.map

package/enqueue_links/index.js

@@ -1,3 +1,2 @@
 export * from './enqueue_links.js';
 export * from './shared.js';
-//# sourceMappingURL=index.js.map

package/enqueue_links/shared.d.ts

@@ -1,33 +1,30 @@
+import type { Awaitable } from '@crawlee/types';
 import type { RequestOptions } from '../request.js';
-import { Request } from '../request.js';
 import type { EnqueueLinksOptions } from './enqueue_links.js';
 export { tryAbsoluteURL } from '@crawlee/utils';
-export type UrlPatternObject = {
+export interface UrlPatternObject {
     glob?: string;
     regexp?: RegExp;
-} & Pick<RequestOptions, 'method' | 'payload' | 'label' | 'userData' | 'headers'>;
-export type PseudoUrlObject = {
-    purl: string;
-} & Pick<RequestOptions, 'method' | 'payload' | 'label' | 'userData' | 'headers'>;
-export type PseudoUrlInput = string | PseudoUrlObject;
-export type GlobObject = {
+}
+export interface GlobObject {
     glob: string;
-} & Pick<RequestOptions, 'method' | 'payload' | 'label' | 'userData' | 'headers'>;
+}
 export type GlobInput = string | GlobObject;
-export type RegExpObject = {
+export interface RegExpObject {
     regexp: RegExp;
-} & Pick<RequestOptions, 'method' | 'payload' | 'label' | 'userData' | 'headers'>;
+}
 export type RegExpInput = RegExp | RegExpObject;
+/** Unified URL pattern input — accepts glob strings, glob objects, RegExp instances, or regexp objects. */
+export type UrlPatternInput = GlobInput | RegExpInput;
+export type SkippedRequestReason = 'robotsTxt' | 'limit' | 'enqueueLimit' | 'filters' | 'transform' | 'redirect' | 'depth';
+export type SkippedRequestCallback = (args: {
+    url: string;
+    reason: SkippedRequestReason;
+}) => Awaitable<void>;
 /**
  * @ignore
  */
-export declare function updateEnqueueLinksPatternCache(item: GlobInput | RegExpInput | PseudoUrlInput, pattern: RegExpObject | GlobObject): void;
-/**
- * Helper factory used in the `enqueueLinks()` and enqueueLinksByClickingElements() function
- * to construct RegExps from PseudoUrl strings.
- * @ignore
- */
-export declare function constructRegExpObjectsFromPseudoUrls(pseudoUrls: readonly PseudoUrlInput[]): RegExpObject[];
+export declare function updateEnqueueLinksPatternCache(item: GlobInput | RegExpInput, pattern: RegExpObject | GlobObject): void;
 /**
  * Helper factory used in the `enqueueLinks()` and enqueueLinksByClickingElements() function
  * to construct Glob objects from Glob pattern strings.
@@ -45,23 +42,39 @@ export declare function validateGlobPattern(glob: string): string;
  */
 export declare function constructRegExpObjectsFromRegExps(regexps: readonly RegExpInput[]): RegExpObject[];
 /**
+ * Helper factory used in the `enqueueLinks()` function to construct UrlPatternObjects
+ * from a mixed array of glob strings, glob objects, RegExp instances, and regexp objects.
  * @ignore
  */
-export declare function createRequests(requestOptions: (string | RequestOptions)[], urlPatternObjects?: UrlPatternObject[], excludePatternObjects?: UrlPatternObject[], strategy?: EnqueueLinksOptions['strategy']): Request[];
-export declare function filterRequestsByPatterns(requests: Request[], patterns?: UrlPatternObject[]): Request[];
+export declare function constructUrlPatternObjects(patterns: readonly UrlPatternInput[]): UrlPatternObject[];
 /**
+ * Filters request options by URL patterns.
+ *
+ * When `includePatterns` is empty/undefined, all options pass through (only exclude filtering applies).
  * @ignore
  */
-export declare function createRequestOptions(sources: readonly (string | Record<string, unknown>)[], options?: Pick<EnqueueLinksOptions, 'label' | 'userData' | 'baseUrl' | 'skipNavigation' | 'strategy'>): RequestOptions[];
+export declare function filterRequestOptionsByPatterns(requestOptions: RequestOptions[], includePatterns: UrlPatternObject[] | undefined, excludePatterns?: UrlPatternObject[], strategy?: EnqueueLinksOptions['strategy'], onSkippedUrl?: (url: string) => void): RequestOptions[];
 /**
- * Takes an Apify {@link RequestOptions} object and changes its attributes in a desired way. This user-function is used
- * {@link enqueueLinks} to modify requests before enqueuing them.
+ * @ignore
+ */
+export declare function createRequestOptions(sources: readonly (string | Record<string, unknown>)[], options?: Pick<EnqueueLinksOptions, 'label' | 'userData' | 'baseUrl' | 'skipNavigation' | 'sessionId' | 'strategy'>): RequestOptions[];
+/**
+ * Takes a {@link RequestOptions} object and changes its attributes in a desired way. This user-function is used
+ * by {@link enqueueLinks} to modify request options before they are converted to {@link Request} instances.
  */
 export interface RequestTransform {
     /**
      * @param original Request options to be modified.
-     * @returns The modified request options to enqueue.
+     * @returns The modified request options to enqueue, `'unchanged'` to keep the original options as-is,
+     *   or a falsy value / `'skip'` to exclude the request from the queue.
      */
-    (original: RequestOptions): RequestOptions | false | undefined | null;
+    (original: RequestOptions): RequestOptions | false | undefined | null | 'skip' | 'unchanged';
 }
-//# sourceMappingURL=shared.d.ts.map
+/**
+ * Applies a {@link RequestTransform} function to a list of request options.
+ * Options for which the transform returns a falsy value are removed from the list.
+ * @param onSkipped Called with the original request options when the transform returns a falsy value (i.e. the request is skipped).
+ * @ignore
+ * @internal
+ */
+export declare function applyRequestTransform(requestOptions: RequestOptions[], transformFn: RequestTransform, onSkipped?: (requestOptions: RequestOptions) => void): RequestOptions[];

package/enqueue_links/shared.js

@@ -1,13 +1,10 @@
 import { URL } from 'node:url';
-import { minimatch } from 'minimatch';
-import { purlToRegExp } from '@apify/pseudo_url';
-import { Request } from '../request.js';
+import { Minimatch } from 'minimatch';
 export { tryAbsoluteURL } from '@crawlee/utils';
 const MAX_ENQUEUE_LINKS_CACHE_SIZE = 1000;
 /**
- * To enable direct use of the Actor UI `globs`/`regexps`/`pseudoUrls` output while keeping high performance,
- * all the regexps from the output are only constructed once and kept in a cache
- * by the `enqueueLinks()` function.
+ * To keep high performance when the same patterns are passed on every `enqueueLinks()` call,
+ * each glob/regexp is only compiled once and then kept in a cache.
  * @ignore
  */
 const enqueueLinksPatternCache = new Map();
@@ -21,28 +18,6 @@ export function updateEnqueueLinksPatternCache(item, pattern) {
         enqueueLinksPatternCache.delete(key);
     }
 }
-/**
- * Helper factory used in the `enqueueLinks()` and enqueueLinksByClickingElements() function
- * to construct RegExps from PseudoUrl strings.
- * @ignore
- */
-export function constructRegExpObjectsFromPseudoUrls(pseudoUrls) {
-    return pseudoUrls.map((item) => {
-        // Get pseudoUrl object from cache.
-        let regexpObject = enqueueLinksPatternCache.get(item);
-        if (regexpObject)
-            return regexpObject;
-        if (typeof item === 'string') {
-            regexpObject = { regexp: purlToRegExp(item) };
-        }
-        else {
-            const { purl, ...requestOptions } = item;
-            regexpObject = { regexp: purlToRegExp(purl), ...requestOptions };
-        }
-        updateEnqueueLinksPatternCache(item, regexpObject);
-        return regexpObject;
-    });
-}
 /**
  * Helper factory used in the `enqueueLinks()` and enqueueLinksByClickingElements() function
  * to construct Glob objects from Glob pattern strings.
@@ -72,8 +47,7 @@ export function constructGlobObjectsFromGlobs(globs) {
             globObject = { glob: validateGlobPattern(item) };
         }
         else {
-            const { glob, ...requestOptions } = item;
-            globObject = { glob: validateGlobPattern(glob), ...requestOptions };
+            globObject = { glob: validateGlobPattern(item.glob) };
         }
         updateEnqueueLinksPatternCache(item, globObject);
         return globObject;
@@ -103,58 +77,60 @@ export function constructRegExpObjectsFromRegExps(regexps) {
             regexpObject = { regexp: item };
         }
         else {
-            regexpObject = item;
+            regexpObject = { regexp: item.regexp };
         }
         updateEnqueueLinksPatternCache(item, regexpObject);
         return regexpObject;
     });
 }
 /**
+ * Helper factory used in the `enqueueLinks()` function to construct UrlPatternObjects
+ * from a mixed array of glob strings, glob objects, RegExp instances, and regexp objects.
+ * @ignore
+ */
+export function constructUrlPatternObjects(patterns) {
+    const result = [];
+    for (const item of patterns) {
+        if (typeof item === 'string' || 'glob' in item) {
+            result.push(...constructGlobObjectsFromGlobs([item]));
+        }
+        else if (item instanceof RegExp || 'regexp' in item) {
+            result.push(...constructRegExpObjectsFromRegExps([item]));
+        }
+    }
+    return result;
+}
+/**
+ * Filters request options by URL patterns.
+ *
+ * When `includePatterns` is empty/undefined, all options pass through (only exclude filtering applies).
  * @ignore
  */
-export function createRequests(requestOptions, urlPatternObjects, excludePatternObjects = [], strategy) {
+export function filterRequestOptionsByPatterns(requestOptions, includePatterns, excludePatterns = [], strategy, onSkippedUrl) {
+    const excludeMatchers = excludePatterns.map(createPatternObjectMatcher);
+    const includeMatchers = includePatterns?.length ? includePatterns.map(createPatternObjectMatcher) : undefined;
     return requestOptions
-        .map((opts) => ({ url: typeof opts === 'string' ? opts : opts.url, opts }))
         .filter(({ url }) => {
-        return !excludePatternObjects.some((excludePatternObject) => {
-            const { regexp, glob } = excludePatternObject;
-            return (regexp && url.match(regexp)) || (glob && minimatch(url, glob, { nocase: true }));
-        });
+        const matchesExclude = excludeMatchers.some(({ match }) => match(url));
+        if (matchesExclude) {
+            onSkippedUrl?.(url);
+        }
+        return !matchesExclude;
     })
-        .map(({ url, opts }) => {
-        if (!urlPatternObjects || !urlPatternObjects.length) {
-            return new Request(typeof opts === 'string' ? { url: opts, enqueueStrategy: strategy } : { ...opts });
-        }
-        for (const urlPatternObject of urlPatternObjects) {
-            const { regexp, glob, ...requestRegExpOptions } = urlPatternObject;
-            if ((regexp && url.match(regexp)) || (glob && minimatch(url, glob, { nocase: true }))) {
-                const request = typeof opts === 'string'
-                    ? { url: opts, ...requestRegExpOptions, enqueueStrategy: strategy }
-                    : { ...opts, ...requestRegExpOptions, enqueueStrategy: strategy };
-                return new Request(request);
+        .map((opts) => {
+        if (!includeMatchers) {
+            return { ...opts, enqueueStrategy: strategy };
+        }
+        for (const { match } of includeMatchers) {
+            if (match(opts.url)) {
+                return { ...opts, enqueueStrategy: strategy };
             }
         }
         // didn't match any positive pattern
+        onSkippedUrl?.(opts.url);
         return null;
     })
-        .filter((request) => request);
-}
-export function filterRequestsByPatterns(requests, patterns) {
-    if (!patterns?.length) {
-        return requests;
-    }
-    const filtered = [];
-    for (const request of requests) {
-        for (const urlPatternObject of patterns) {
-            const { regexp, glob } = urlPatternObject;
-            if ((regexp && request.url.match(regexp)) || (glob && minimatch(request.url, glob, { nocase: true }))) {
-                filtered.push(request);
-                // Break the pattern loop, as we already matched this request once
-                break;
-            }
-        }
-    }
-    return filtered;
+        .filter((opts) => opts !== null);
 }
 /**
  * @ignore
@@ -184,7 +160,53 @@ export function createRequestOptions(sources, options = {}) {
         if (options.skipNavigation) {
             requestOptions.skipNavigation = true;
         }
+        if (options.sessionId) {
+            requestOptions.sessionId = options.sessionId;
+        }
         return requestOptions;
     });
 }
-//# sourceMappingURL=shared.js.map
+/**
+ * @ignore
+ */
+function createPatternObjectMatcher(urlPatternObject) {
+    const { regexp, glob } = urlPatternObject;
+    let match;
+    if (regexp) {
+        match = (url) => regexp.test(url);
+    }
+    else if (glob) {
+        const m = new Minimatch(glob, { nocase: true });
+        match = (url) => m.match(url);
+    }
+    else {
+        match = () => false;
+    }
+    return { match };
+}
+/**
+ * Applies a {@link RequestTransform} function to a list of request options.
+ * Options for which the transform returns a falsy value are removed from the list.
+ * @param onSkipped Called with the original request options when the transform returns a falsy value (i.e. the request is skipped).
+ * @ignore
+ * @internal
+ */
+export function applyRequestTransform(requestOptions, transformFn, onSkipped) {
+    return requestOptions
+        .map((opts) => {
+        const transformed = transformFn(opts);
+        if (transformed === 'skip') {
+            onSkipped?.(opts);
+            return null;
+        }
+        if (transformed === 'unchanged') {
+            return opts;
+        }
+        if (!transformed) {
+            onSkipped?.(opts);
+            return null;
+        }
+        return transformed;
+    })
+        .filter((r) => r !== null);
+}

package/errors.d.ts

@@ -14,6 +14,26 @@ export declare class CriticalError extends NonRetryableError {
  */
 export declare class MissingRouteError extends CriticalError {
 }
+/**
+ * Thrown when a request's `userData` does not match the {@link RouteSchemas|Standard Schema} registered for its label.
+ *
+ * As the `userData` does not change between attempts, this error is non-retryable.
+ */
+export declare class RequestValidationError extends NonRetryableError {
+    readonly label: string | symbol;
+    readonly issues: readonly {
+        readonly message: string;
+        readonly path?: readonly (PropertyKey | {
+            key: PropertyKey;
+        })[];
+    }[];
+    constructor(label: string | symbol, issues: readonly {
+        readonly message: string;
+        readonly path?: readonly (PropertyKey | {
+            key: PropertyKey;
+        })[];
+    }[]);
+}
 /**
  * Errors of `RetryRequestError` type will always be retried by the crawler.
  *
@@ -23,11 +43,40 @@ export declare class RetryRequestError extends Error {
     constructor(message?: string);
 }
 /**
- * Errors of `SessionError` type will trigger a session rotation.
+ * Errors of `SessionError` type retire the session associated with the request and trigger a regular retry.
  *
- * This error doesn't respect the `maxRequestRetries` option and has a separate limit of `maxSessionRotations`.
+ * The retry counts towards the `maxRequestRetries` limit, just like any other error.
  */
-export declare class SessionError extends RetryRequestError {
+export declare class SessionError extends Error {
+    constructor(message?: string);
+}
+/**
+ * Thrown when a requested session is not found in the referenced SessionPool.
+ */
+export declare class MissingSessionError extends Error {
+    constructor(sessionId?: string);
+}
+export declare class ContextPipelineInterruptedError extends Error {
     constructor(message?: string);
 }
-//# sourceMappingURL=errors.d.ts.map
+export declare class ContextPipelineInitializationError extends Error {
+    constructor(error: unknown, options?: ErrorOptions);
+}
+export declare class ContextPipelineCleanupError extends CriticalError {
+    constructor(error: unknown, options?: ErrorOptions);
+}
+export declare class RequestHandlerError extends Error {
+    constructor(error: unknown, options?: ErrorOptions);
+}
+/**
+ * Thrown when attempting to set a different service instance after one has already been retrieved.
+ */
+export declare class ServiceConflictError extends Error {
+    constructor(serviceName: string, newValue: unknown, existingValue: unknown);
+}
+/**
+ * Thrown by crawlers when `skipNavigation` is used on a request.
+ * Subclasses can catch this error to skip their own navigation-dependent logic.
+ */
+export declare class NavigationSkippedError extends NonRetryableError {
+}