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

package/autoscaling/autoscaled_pool.d.ts

@@ -1,6 +1,6 @@
 import type { CrawleeLogger } from '../log.js';
 import type { SnapshotterOptions } from './snapshotter.js';
-import type { SystemInfo, SystemStatusOptions } from './system_status.js';
+import type { SystemStatusOptions } from './system_status.js';
 export interface AutoscaledPoolOptions {
     /**
      * A function that performs an asynchronous resource-intensive task.
@@ -262,38 +262,38 @@ export declare class AutoscaledPool {
      *
      * It doesn't allow multiple concurrent runs of this method.
      */
-    protected _maybeRunTask(intervalCallback?: () => void): Promise<void>;
+    private maybeRunTask;
     /**
      * Gets called every autoScaleIntervalSecs and evaluates the current system status.
      * If the system IS NOT overloaded and the settings allow it, it scales up.
      * If the system IS overloaded and the settings allow it, it scales down.
      */
-    protected _autoscale(intervalCallback: () => void): void;
+    private autoscale;
     /**
      * Scales the pool up by increasing
      * the desired concurrency by the scaleUpStepRatio.
      *
      * @param systemStatus for logging
      */
-    protected _scaleUp(systemStatus: SystemInfo): void;
+    private scaleUp;
     /**
      * Scales the pool down by decreasing
      * the desired concurrency by the scaleDownStepRatio.
      *
      * @param systemStatus for logging
      */
-    protected _scaleDown(systemStatus: SystemInfo): void;
+    private scaleDown;
     /**
      * If there are no running tasks and this.isFinishedFunction() returns true then closes
      * the pool and resolves the pool's promise returned by the run() method.
      *
      * It doesn't allow multiple concurrent runs of this method.
      */
-    protected _maybeFinish(): Promise<void>;
+    private maybeFinish;
     /**
      * Cleans up resources.
      */
-    protected _destroy(): Promise<void>;
-    protected _incrementTasksDonePerSecond(intervalCallback: () => void): void;
-    protected get _isOverMaxRequestLimit(): boolean;
+    private destroy;
+    private incrementTasksDonePerSecond;
+    private get isOverMaxRequestLimit();
 }

package/autoscaling/autoscaled_pool.js

@@ -128,9 +128,9 @@ export class AutoscaledPool {
         this.isStopped = false;
         this.resolve = null;
         this.reject = null;
-        this._autoscale = this._autoscale.bind(this);
-        this._maybeRunTask = this._maybeRunTask.bind(this);
-        this._incrementTasksDonePerSecond = this._incrementTasksDonePerSecond.bind(this);
+        this.autoscale = this.autoscale.bind(this);
+        this.maybeRunTask = this.maybeRunTask.bind(this);
+        this.incrementTasksDonePerSecond = this.incrementTasksDonePerSecond.bind(this);
         // Create instances with correct options.
         const ssoCopy = { ...systemStatusOptions };
         ssoCopy.snapshotter ??= new Snapshotter({
@@ -203,14 +203,14 @@ export class AutoscaledPool {
         await this.snapshotter.start();
         await Promise.all(this.loadSignals.map((s) => s.start()));
         // This interval checks the system status and updates the desired concurrency accordingly.
-        this.autoscaleInterval = betterSetInterval(this._autoscale, this.autoscaleIntervalMillis);
+        this.autoscaleInterval = betterSetInterval(this.autoscale, this.autoscaleIntervalMillis);
         // This is here because if we scale down to let's say 1, then after each promise is finished
-        // this._maybeRunTask() doesn't trigger another one. So if that 1 instance gets stuck it results
+        // this.maybeRunTask() doesn't trigger another one. So if that 1 instance gets stuck it results
         // in the crawler getting stuck and even after scaling up it never triggers another promise.
-        this.maybeRunInterval = betterSetInterval(this._maybeRunTask, this.maybeRunIntervalMillis);
+        this.maybeRunInterval = betterSetInterval(this.maybeRunTask, this.maybeRunIntervalMillis);
         if (this.maxTasksPerMinute !== Infinity) {
             // Start the interval that resets the counter of tasks per minute.
-            this.tasksDonePerSecondInterval = betterSetInterval(this._incrementTasksDonePerSecond, 1000);
+            this.tasksDonePerSecondInterval = betterSetInterval(this.incrementTasksDonePerSecond, 1000);
         }
         try {
             await poolPromise;
@@ -218,7 +218,7 @@ export class AutoscaledPool {
         finally {
             // If resolve is null, the pool is already destroyed.
             if (this.resolve)
-                await this._destroy();
+                await this.destroy();
         }
     }
     /**
@@ -236,7 +236,7 @@ export class AutoscaledPool {
         this.isStopped = true;
         if (this.resolve) {
             this.resolve();
-            await this._destroy();
+            await this.destroy();
         }
     }
     /**
@@ -291,7 +291,7 @@ export class AutoscaledPool {
      * every `maybeRunIntervalSecs` seconds. If you want to trigger the processing immediately, use this method.
      */
     async notify() {
-        setImmediate(this._maybeRunTask);
+        setImmediate(this.maybeRunTask);
     }
     /**
      * Starts a new task
@@ -301,7 +301,7 @@ export class AutoscaledPool {
      *
      * It doesn't allow multiple concurrent runs of this method.
      */
-    async _maybeRunTask(intervalCallback) {
+    async maybeRunTask(intervalCallback) {
         this.log.perf('Attempting to run a task.');
         // Check if the function was invoked by the maybeRunInterval and use an empty function if not.
         const done = intervalCallback || (() => { });
@@ -352,12 +352,12 @@ export class AutoscaledPool {
             this.log.perf('Task will not run. No tasks are ready.');
             done();
             // No tasks could mean that we're finished with all tasks.
-            return this._maybeFinish();
+            return this.maybeFinish();
         }
         // - we have already reached the maximum tasks per minute
         // we need to check this *after* checking if a task is ready to prevent hanging the pool
         // for an extra minute if there are no more tasks
-        if (this._isOverMaxRequestLimit) {
+        if (this.isOverMaxRequestLimit) {
             this.log.perf('Task will not run. Maximum tasks per minute reached.');
             return done();
         }
@@ -367,7 +367,7 @@ export class AutoscaledPool {
             this._tasksPerMinute[0]++;
             // Try to run next task to build up concurrency,
             // but defer it so it doesn't create a cycle.
-            setImmediate(this._maybeRunTask);
+            setImmediate(this.maybeRunTask);
             // We need to restart interval here, so that it doesn't get blocked by a stalled task.
             done();
             // Execute the current task.
@@ -381,7 +381,7 @@ export class AutoscaledPool {
             this.log.perf('Task finished.');
             this._currentConcurrency--;
             // Run task after the previous one finished.
-            setImmediate(this._maybeRunTask);
+            setImmediate(this.maybeRunTask);
         }
         catch (e) {
             const err = e;
@@ -404,12 +404,12 @@ export class AutoscaledPool {
      * If the system IS NOT overloaded and the settings allow it, it scales up.
      * If the system IS overloaded and the settings allow it, it scales down.
      */
-    _autoscale(intervalCallback) {
+    autoscale(intervalCallback) {
         // Don't scale if paused.
         if (this.isStopped)
             return intervalCallback();
         // Don't scale if we've hit the maximum requests per minute
-        if (this._isOverMaxRequestLimit)
+        if (this.isOverMaxRequestLimit)
             return intervalCallback();
         // Only scale up if:
         // - system has not been overloaded lately.
@@ -421,14 +421,14 @@ export class AutoscaledPool {
         const minCurrentConcurrency = Math.floor(this._desiredConcurrency * this.desiredConcurrencyRatio);
         const weAreReachingDesiredConcurrency = this._currentConcurrency >= minCurrentConcurrency;
         if (isSystemIdle && weAreNotAtMax && weAreReachingDesiredConcurrency)
-            this._scaleUp(systemStatus);
+            this.scaleUp(systemStatus);
         // Always scale down if:
         // - the system has been overloaded lately.
         const isSystemOverloaded = !isSystemIdle;
         // - we're over min concurrency.
         const weAreNotAtMin = this._desiredConcurrency > this._minConcurrency;
         if (isSystemOverloaded && weAreNotAtMin)
-            this._scaleDown(systemStatus);
+            this.scaleDown(systemStatus);
         // On periodic intervals, print comprehensive log information
         if (this.loggingIntervalMillis > 0) {
             const now = Date.now();
@@ -453,7 +453,7 @@ export class AutoscaledPool {
      *
      * @param systemStatus for logging
      */
-    _scaleUp(systemStatus) {
+    scaleUp(systemStatus) {
         const step = Math.ceil(this._desiredConcurrency * this.scaleUpStepRatio);
         this._desiredConcurrency = Math.min(this._maxConcurrency, this._desiredConcurrency + step);
         this.log.debug('scaling up', {
@@ -468,7 +468,7 @@ export class AutoscaledPool {
      *
      * @param systemStatus for logging
      */
-    _scaleDown(systemStatus) {
+    scaleDown(systemStatus) {
         const step = Math.ceil(this._desiredConcurrency * this.scaleDownStepRatio);
         this._desiredConcurrency = Math.max(this._minConcurrency, this._desiredConcurrency - step);
         this.log.debug('scaling down', {
@@ -483,7 +483,7 @@ export class AutoscaledPool {
      *
      * It doesn't allow multiple concurrent runs of this method.
      */
-    async _maybeFinish() {
+    async maybeFinish() {
         if (this.queryingIsFinished)
             return;
         if (this._currentConcurrency > 0)
@@ -509,7 +509,7 @@ export class AutoscaledPool {
     /**
      * Cleans up resources.
      */
-    async _destroy() {
+    async destroy() {
         this.resolve = null;
         this.reject = null;
         betterClearInterval(this.autoscaleInterval);
@@ -520,12 +520,12 @@ export class AutoscaledPool {
             await this.snapshotter.stop();
         await Promise.all(this.loadSignals.map((s) => s.stop()));
     }
-    _incrementTasksDonePerSecond(intervalCallback) {
+    incrementTasksDonePerSecond(intervalCallback) {
         this._tasksPerMinute.unshift(0);
         this._tasksPerMinute.pop();
         return intervalCallback();
     }
-    get _isOverMaxRequestLimit() {
+    get isOverMaxRequestLimit() {
         if (this.maxTasksPerMinute === Infinity) {
             return false;
         }

package/autoscaling/snapshotter.d.ts

@@ -6,7 +6,6 @@ import type { CpuSnapshot } from './cpu_load_signal.js';
 import type { EventLoopSnapshot } from './event_loop_load_signal.js';
 import type { LoadSignal } from './load_signal.js';
 import type { MemorySnapshot } from './memory_load_signal.js';
-import type { SystemInfo } from './system_status.js';
 export interface SnapshotterOptions {
     /**
      * Defines the interval of measuring the event loop response time.
@@ -77,9 +76,9 @@ export interface SnapshotterOptions {
  * @category Scaling
  */
 export declare class Snapshotter {
-    log: CrawleeLogger;
-    client: StorageBackend;
-    config: Configuration;
+    readonly log: CrawleeLogger;
+    readonly client: StorageBackend;
+    readonly config: Configuration;
     private readonly memorySignal;
     private readonly eventLoopSignal;
     private readonly cpuSignal;
@@ -125,28 +124,4 @@ export declare class Snapshotter {
      * by the sampleDurationMillis parameter. If omitted, it returns a full snapshot history.
      */
     getClientSample(sampleDurationMillis?: number): ClientSnapshot[];
-    /**
-     * @deprecated Kept for backward compatibility.
-     */
-    protected _snapshotMemory(systemInfo: SystemInfo): void;
-    /**
-     * @deprecated Kept for backward compatibility.
-     */
-    protected _memoryOverloadWarning(systemInfo: SystemInfo): void;
-    /**
-     * @deprecated Kept for backward compatibility.
-     */
-    protected _snapshotEventLoop(intervalCallback: () => unknown): void;
-    /**
-     * @deprecated Kept for backward compatibility.
-     */
-    protected _snapshotCpu(systemInfo: SystemInfo): void;
-    /**
-     * @deprecated Kept for backward compatibility.
-     */
-    protected _snapshotClient(intervalCallback: () => unknown): void;
-    /**
-     * @deprecated Pruning is now handled by individual signals.
-     */
-    protected _pruneSnapshots(_snapshots: any[], _now: Date): void;
 }

package/autoscaling/snapshotter.js

@@ -150,40 +150,4 @@ export class Snapshotter {
     getClientSample(sampleDurationMillis) {
         return this.clientSignal.getSample(sampleDurationMillis);
     }
-    /**
-     * @deprecated Kept for backward compatibility.
-     */
-    _snapshotMemory(systemInfo) {
-        this.memorySignal._onSystemInfo(systemInfo);
-    }
-    /**
-     * @deprecated Kept for backward compatibility.
-     */
-    _memoryOverloadWarning(systemInfo) {
-        this.memorySignal._memoryOverloadWarning(systemInfo);
-    }
-    /**
-     * @deprecated Kept for backward compatibility.
-     */
-    _snapshotEventLoop(intervalCallback) {
-        this.eventLoopSignal.handle(intervalCallback);
-    }
-    /**
-     * @deprecated Kept for backward compatibility.
-     */
-    _snapshotCpu(systemInfo) {
-        this.cpuSignal.handle(systemInfo);
-    }
-    /**
-     * @deprecated Kept for backward compatibility.
-     */
-    _snapshotClient(intervalCallback) {
-        this.clientSignal.handle(intervalCallback);
-    }
-    /**
-     * @deprecated Pruning is now handled by individual signals.
-     */
-    _pruneSnapshots(_snapshots, _now) {
-        // no-op — signals prune themselves
-    }
 }

package/autoscaling/system_status.d.ts

@@ -162,5 +162,5 @@ export declare class SystemStatus {
     /**
      * Returns a system status object.
      */
-    protected _isSystemIdle(sampleDurationMillis?: number): SystemInfo;
+    private isSystemIdle;
 }

package/autoscaling/system_status.js

@@ -75,7 +75,7 @@ export class SystemStatus {
      * and `true` otherwise.
      */
     getCurrentStatus() {
-        return this._isSystemIdle(this.currentHistoryMillis);
+        return this.isSystemIdle(this.currentHistoryMillis);
     }
     /**
      * Returns an {@link SystemInfo} object with the following structure:
@@ -94,12 +94,12 @@ export class SystemStatus {
      * (which is configurable in the {@link Snapshotter}) and `true` otherwise.
      */
     getHistoricalStatus() {
-        return this._isSystemIdle();
+        return this.isSystemIdle();
     }
     /**
      * Returns a system status object.
      */
-    _isSystemIdle(sampleDurationMillis) {
+    isSystemIdle(sampleDurationMillis) {
         const result = {
             isSystemIdle: true,
             memInfo: { isOverloaded: false, limitRatio: 0, actualRatio: 0 },

package/crawlers/statistics.d.ts

@@ -26,11 +26,11 @@ export declare class Statistics {
     /**
      * An error tracker for final retry errors.
      */
-    errorTracker: ErrorTracker;
+    readonly errorTracker: ErrorTracker;
     /**
      * An error tracker for retry errors prior to the final retry.
      */
-    errorTrackerRetry: ErrorTracker;
+    readonly errorTrackerRetry: ErrorTracker;
     /**
      * Statistic instance id.
      */
@@ -44,7 +44,7 @@ export declare class Statistics {
      */
     readonly requestRetryHistogram: number[];
     protected keyValueStore?: KeyValueStore;
-    protected persistStateKey: string;
+    protected readonly persistStateKey: string;
     private logIntervalMillis;
     private logMessage;
     private listener;
@@ -113,7 +113,7 @@ export declare class Statistics {
      * Stops logging and remove event listeners, then persist
      */
     stopCapturing(): Promise<void>;
-    protected _saveRetryCountForJob(retryCount: number): void;
+    private saveRetryCountForJob;
     /**
      * Persist internal state to the key value store
      * @param options - Override the persistence options provided in the constructor
@@ -122,8 +122,8 @@ export declare class Statistics {
     /**
      * Loads the current statistic from the key value store if any
      */
-    protected _maybeLoadStatistics(): Promise<void>;
-    protected _teardown(): void;
+    protected maybeLoadStatistics(): Promise<void>;
+    private teardown;
     /**
      * Make this class serializable when called with `JSON.stringify(statsInstance)` directly
      * or through `keyValueStore.setValue('KEY', statsInstance)`

package/crawlers/statistics.js

@@ -129,7 +129,7 @@ export class Statistics {
         this.requestRetryHistogram.length = 0;
         this.requestsInProgress.clear();
         this.instanceStart = Date.now();
-        this._teardown();
+        this.teardown();
     }
     /**
      * @param options - Override the persistence options provided in the constructor
@@ -175,7 +175,7 @@ export class Statistics {
         const jobDurationMillis = job.finish();
         this.state.requestsFinished++;
         this.state.requestTotalFinishedDurationMillis += jobDurationMillis;
-        this._saveRetryCountForJob(retryCount);
+        this.saveRetryCountForJob(retryCount);
         if (jobDurationMillis < this.state.requestMinDurationMillis)
             this.state.requestMinDurationMillis = jobDurationMillis;
         if (jobDurationMillis > this.state.requestMaxDurationMillis)
@@ -192,7 +192,7 @@ export class Statistics {
             return;
         this.state.requestTotalFailedDurationMillis += job.finish();
         this.state.requestsFailed++;
-        this._saveRetryCountForJob(retryCount);
+        this.saveRetryCountForJob(retryCount);
         this.requestsInProgress.delete(id);
     }
     /**
@@ -230,7 +230,7 @@ export class Statistics {
             this.state.crawlerStartedAt = new Date();
         }
         if (this.persistenceOptions.enable) {
-            await this._maybeLoadStatistics();
+            await this.maybeLoadStatistics();
             this.events.on("persistState" /* EventType.PERSIST_STATE */, this.listener);
         }
         this.logInterval = setInterval(() => {
@@ -244,11 +244,11 @@ export class Statistics {
      * Stops logging and remove event listeners, then persist
      */
     async stopCapturing() {
-        this._teardown();
+        this.teardown();
         this.state.crawlerFinishedAt = new Date();
         await this.persistState();
     }
-    _saveRetryCountForJob(retryCount) {
+    saveRetryCountForJob(retryCount) {
         if (retryCount > 0)
             this.state.requestsRetries++;
         this.requestRetryHistogram[retryCount] ??= 0;
@@ -274,7 +274,7 @@ export class Statistics {
     /**
      * Loads the current statistic from the key value store if any
      */
-    async _maybeLoadStatistics() {
+    async maybeLoadStatistics() {
         // this might be called before startCapturing was called without using await, should not crash
         if (!this.keyValueStore) {
             return;
@@ -309,7 +309,7 @@ export class Statistics {
         this.instanceStart = Date.now() - (+this.state.statsPersistedAt - savedState.crawlerLastStartTimestamp);
         this.log.debug('Loaded from KeyValueStore');
     }
-    _teardown() {
+    teardown() {
         // this can be called before a call to startCapturing happens (or in a 'finally' block)
         // Only unsubscribe if event manager was already resolved — avoid eagerly resolving it
         // (e.g. during the constructor's reset() call, which would capture the wrong context)

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@crawlee/core",
-    "version": "4.0.0-beta.80",
+    "version": "4.0.0-beta.81",
     "description": "The scalable web crawling and scraping library for JavaScript/Node.js. Enables development of data extraction and web automation jobs (not only) with headless Chrome and Puppeteer.",
     "engines": {
         "node": ">=22.0.0"
@@ -53,9 +53,9 @@
         "@apify/pseudo_url": "^2.0.59",
         "@apify/timeout": "^0.3.2",
         "@apify/utilities": "^2.15.5",
-        "@crawlee/fs-storage": "4.0.0-beta.80",
-        "@crawlee/types": "4.0.0-beta.80",
-        "@crawlee/utils": "4.0.0-beta.80",
+        "@crawlee/fs-storage": "4.0.0-beta.81",
+        "@crawlee/types": "4.0.0-beta.81",
+        "@crawlee/utils": "4.0.0-beta.81",
         "@sapphire/async-queue": "^1.5.5",
         "@sapphire/shapeshift": "^4.0.0",
         "@vladfrangu/async_event_emitter": "^2.4.6",
@@ -79,5 +79,5 @@
             }
         }
     },
-    "gitHead": "96c57b4a0c999e4b2bd198792490af28db7aa42d"
+    "gitHead": "80dc6b4fc82237e63a51a71153809ec8dfd0cc50"
 }

package/proxy_configuration.d.ts

@@ -24,6 +24,23 @@ export interface ProxyConfigurationOptions {
 interface NewUrlOptions {
     request?: Request;
 }
+/**
+ * Minimal contract that any object passed to a crawler as its `proxyConfiguration`
+ * option must satisfy.
+ *
+ * Implement this interface to plug a custom proxy-provisioning strategy into any Crawlee
+ * crawler — for example a remote proxy service or a thin wrapper around the built-in
+ * `ProxyConfiguration` with different rotation rules. *
+ *
+ * @category Scaling
+ */
+export interface IProxyConfiguration {
+    /**
+     * Creates a new {@link ProxyInfo} object describing the proxy to use for the given
+     * request. Returns `undefined` when no proxy should be used.
+     */
+    newProxyInfo(options?: NewUrlOptions): Promise<ProxyInfo | undefined>;
+}
 /**
  * Configures connection to a proxy server with the provided options. Proxy servers are used to prevent target websites from blocking
  * your crawlers based on IP address rate limits or blacklists. Setting proxy configuration in your crawlers automatically configures
@@ -52,14 +69,11 @@ interface NewUrlOptions {
  * ```
  * @category Scaling
  */
-export declare class ProxyConfiguration {
-    isManInTheMiddle: boolean;
-    protected nextCustomUrlIndex: number;
-    protected proxyUrls?: UrlList;
-    protected usedProxyUrls: Map<string, string | null>;
-    protected newUrlFunction?: ProxyConfigurationFunction;
-// @ts-ignore optional peer dependency or compatibility with es2022
-    protected log: import("@crawlee/types").CrawleeLogger;
+export declare class ProxyConfiguration implements IProxyConfiguration {
+    readonly isManInTheMiddle = false;
+    private nextCustomUrlIndex;
+    private proxyUrls?;
+    private newUrlFunction?;
     /**
      * Creates a {@link ProxyConfiguration} instance based on the provided options. Proxy servers are used to prevent target websites from
      * blocking your crawlers based on IP address rate limits or blacklists. Setting proxy configuration in your crawlers automatically configures
@@ -98,14 +112,12 @@ export declare class ProxyConfiguration {
      *  For example, `http://bob:password123@proxy.example.com:8000`
      */
     newUrl(options?: NewUrlOptions): Promise<string | undefined>;
-    protected _handleProxyUrlsList(): string | null;
+    private handleProxyUrlsList;
     /**
      * Calls the custom newUrlFunction and checks format of its return value
      */
-    protected _callNewUrlFunction(options?: {
-        request?: Request;
-    }): Promise<string | null>;
-    protected _throwCannotCombineCustomMethods(): never;
-    protected _throwNoOptionsProvided(): never;
+    private callNewUrlFunction;
+    private throwCannotCombineCustomMethods;
+    private throwNoOptionsProvided;
 }
 export {};

package/proxy_configuration.js

@@ -1,5 +1,4 @@
 import ow from 'ow';
-import { serviceLocator } from './service_locator.js';
 /**
  * Configures connection to a proxy server with the provided options. Proxy servers are used to prevent target websites from blocking
  * your crawlers based on IP address rate limits or blacklists. Setting proxy configuration in your crawlers automatically configures
@@ -32,9 +31,7 @@ export class ProxyConfiguration {
     isManInTheMiddle = false;
     nextCustomUrlIndex = 0;
     proxyUrls;
-    usedProxyUrls = new Map();
     newUrlFunction;
-    log = serviceLocator.getLogger().child({ prefix: 'ProxyConfiguration' });
     /**
      * Creates a {@link ProxyConfiguration} instance based on the provided options. Proxy servers are used to prevent target websites from
      * blocking your crawlers based on IP address rate limits or blacklists. Setting proxy configuration in your crawlers automatically configures
@@ -67,9 +64,9 @@ export class ProxyConfiguration {
         }));
         const { proxyUrls, newUrlFunction } = options;
         if (proxyUrls && newUrlFunction)
-            this._throwCannotCombineCustomMethods();
+            this.throwCannotCombineCustomMethods();
         if (!proxyUrls && !newUrlFunction && validateRequired)
-            this._throwNoOptionsProvided();
+            this.throwNoOptionsProvided();
         this.proxyUrls = proxyUrls;
         this.newUrlFunction = newUrlFunction;
     }
@@ -103,17 +100,17 @@ export class ProxyConfiguration {
      */
     async newUrl(options) {
         if (this.newUrlFunction) {
-            return (await this._callNewUrlFunction({ request: options?.request })) ?? undefined;
+            return (await this.callNewUrlFunction({ request: options?.request })) ?? undefined;
         }
-        return this._handleProxyUrlsList() ?? undefined;
+        return this.handleProxyUrlsList() ?? undefined;
     }
-    _handleProxyUrlsList() {
+    handleProxyUrlsList() {
         return this.proxyUrls[this.nextCustomUrlIndex++ % this.proxyUrls.length];
     }
     /**
      * Calls the custom newUrlFunction and checks format of its return value
      */
-    async _callNewUrlFunction(options) {
+    async callNewUrlFunction(options) {
         const proxyUrl = await this.newUrlFunction(options);
         try {
             if (proxyUrl) {
@@ -125,10 +122,10 @@ export class ProxyConfiguration {
             throw new Error(`The provided newUrlFunction did not return a valid URL.\nCause: ${err.message}`);
         }
     }
-    _throwCannotCombineCustomMethods() {
+    throwCannotCombineCustomMethods() {
         throw new Error('Cannot combine custom proxies "options.proxyUrls" with custom generating function "options.newUrlFunction".');
     }
-    _throwNoOptionsProvided() {
+    throwNoOptionsProvided() {
         throw new Error('One of "options.proxyUrls" or "options.newUrlFunction" needs to be provided.');
     }
 }

package/router.d.ts

@@ -168,7 +168,7 @@ export declare class Router<Context extends Omit<RestrictedCrawlingContext, 'enq
      * use Router.create() instead!
      * @ignore
      */
-    protected constructor();
+    private constructor();
     /**
      * Registers new route handler for given label. When the router declares a route map, the
      * `label` is restricted to the declared labels and `request.userData` is typed accordingly.

package/session_pool/session.d.ts

@@ -66,7 +66,7 @@ export interface SessionOptions {
  */
 export declare class Session implements ISession {
     readonly id: string;
-    userData: Dictionary;
+    readonly userData: Dictionary;
     private _maxErrorScore;
     private _errorScoreDecrement;
     private _createdAt;
@@ -157,5 +157,5 @@ export declare class Session implements ISession {
     /**
      * Checks if session is not usable. if it is not retires the session.
      */
-    protected _maybeSelfRetire(): void;
+    private maybeSelfRetire;
 }