@crawlee/core 4.0.0-beta.105 → 4.0.0-beta.106

package/autoscaling/memory_load_signal.js

@@ -15,92 +15,91 @@ const CRITICAL_OVERLOAD_RATE_LIMIT_MILLIS = 10_000;
 export class MemoryLoadSignal {
     name = 'memInfo';
     overloadedRatio;
-    store = new SnapshotStore();
-    maxUsedRatio;
+    #store = new SnapshotStore();
+    #maxUsedRatio;
     /** All resolved in `start()`, before anything that reads them can fire. */
-    config;
-    log;
-    maxMemoryBytes;
-    events;
-    maxMemoryRatio;
-    lastLoggedCriticalMemoryOverloadAt = null;
+    #config;
+    #log;
+    #maxMemoryBytes;
+    #events;
+    #maxMemoryRatio;
+    #lastLoggedCriticalMemoryOverloadAt = null;
     constructor(options = {}) {
-        this.maxUsedRatio = options.maxUsedRatio ?? 0.9;
+        this.#maxUsedRatio = options.maxUsedRatio ?? 0.9;
         this.overloadedRatio = options.overloadedRatio ?? 0.2;
         this.handle = this.handle.bind(this);
     }
     async start(context) {
-        this.store.useSampleWindow(context.maxSampleWindowMillis);
+        this.#store.useSampleWindow(context.maxSampleWindowMillis);
         // A new session starts from a clean slate, so it is not judged on measurements from before the downtime.
-        this.store.clear();
+        this.#store.clear();
         // Resolved here rather than in the constructor: an instance built ahead of time (to be wrapped, or shared
         // between systems) must not capture whichever services happened to be registered at that moment.
-        this.config = serviceLocator.getConfiguration();
-        this.events = serviceLocator.getEventManager();
-        this.log = serviceLocator.getLogger().child({ prefix: 'MemoryLoadSignal' });
-        const memoryMbytes = this.config.memoryMbytes ?? 0;
+        this.#config = serviceLocator.getConfiguration();
+        this.#events = serviceLocator.getEventManager();
+        this.#log = serviceLocator.getLogger().child({ prefix: 'MemoryLoadSignal' });
+        const memoryMbytes = this.#config.memoryMbytes ?? 0;
         if (memoryMbytes > 0) {
-            this.maxMemoryBytes = memoryMbytes * 1024 * 1024;
+            this.#maxMemoryBytes = memoryMbytes * 1024 * 1024;
         }
         else {
-            this.maxMemoryRatio = this.config.availableMemoryRatio;
-            if (!this.maxMemoryRatio) {
+            this.#maxMemoryRatio = this.#config.availableMemoryRatio;
+            if (!this.#maxMemoryRatio) {
                 throw new Error('availableMemoryRatio is not set in configuration.');
             }
             else {
-                this.log.debug(`Setting max memory of this run to ${this.maxMemoryRatio * 100} % of available memory. ` +
+                this.#log.debug(`Setting max memory of this run to ${this.#maxMemoryRatio * 100} % of available memory. ` +
                     'Use the CRAWLEE_MEMORY_MBYTES or CRAWLEE_AVAILABLE_MEMORY_RATIO environment variable to override it.');
             }
             // Fallback memory measurement in case memTotalBytes is missing from SystemInfo.
-            this.maxMemoryBytes = await this._getTotalMemoryBytes();
+            this.#maxMemoryBytes = await this.getTotalMemoryBytes();
         }
-        this.events.on("systemInfo" /* EventType.SYSTEM_INFO */, this.handle);
+        this.#events.on("systemInfo" /* EventType.SYSTEM_INFO */, this.handle);
     }
     async stop() {
-        this.events?.off("systemInfo" /* EventType.SYSTEM_INFO */, this.handle);
-        this.events = undefined;
+        this.#events?.off("systemInfo" /* EventType.SYSTEM_INFO */, this.handle);
+        this.#events = undefined;
     }
     getSample(sampleDurationMillis) {
-        return this.store.getSample(sampleDurationMillis);
+        return this.#store.getSample(sampleDurationMillis);
     }
     /** @internal Records a snapshot from a `SYSTEM_INFO` payload. Exposed for tests. */
     handle(systemInfo) {
         const createdAt = systemInfo.createdAt ? new Date(systemInfo.createdAt) : new Date();
         const { memCurrentBytes, memTotalBytes } = systemInfo;
-        let maxMemoryBytes = this.maxMemoryBytes;
-        if (this.maxMemoryRatio !== undefined && this.maxMemoryRatio > 0) {
-            maxMemoryBytes = this.maxMemoryRatio * (memTotalBytes ?? this.maxMemoryBytes);
+        let maxMemoryBytes = this.#maxMemoryBytes;
+        if (this.#maxMemoryRatio !== undefined && this.#maxMemoryRatio > 0) {
+            maxMemoryBytes = this.#maxMemoryRatio * (memTotalBytes ?? this.#maxMemoryBytes);
         }
         const snapshot = {
             createdAt,
-            isOverloaded: memCurrentBytes / maxMemoryBytes > this.maxUsedRatio,
+            isOverloaded: memCurrentBytes / maxMemoryBytes > this.#maxUsedRatio,
             usedBytes: memCurrentBytes,
         };
-        this.store.push(snapshot, createdAt);
-        this._memoryOverloadWarning(systemInfo, maxMemoryBytes);
+        this.#store.push(snapshot, createdAt);
+        this.memoryOverloadWarning(systemInfo, maxMemoryBytes);
     }
-    /** @internal */
-    _memoryOverloadWarning(systemInfo, maxMemoryBytes) {
-        const effectiveMax = maxMemoryBytes ?? this.maxMemoryBytes;
+    memoryOverloadWarning(systemInfo, maxMemoryBytes) {
+        const effectiveMax = maxMemoryBytes ?? this.#maxMemoryBytes;
         const { memCurrentBytes } = systemInfo;
         const createdAt = systemInfo.createdAt ? new Date(systemInfo.createdAt) : new Date();
-        if (this.lastLoggedCriticalMemoryOverloadAt &&
-            +createdAt < +this.lastLoggedCriticalMemoryOverloadAt + CRITICAL_OVERLOAD_RATE_LIMIT_MILLIS)
+        if (this.#lastLoggedCriticalMemoryOverloadAt &&
+            +createdAt < +this.#lastLoggedCriticalMemoryOverloadAt + CRITICAL_OVERLOAD_RATE_LIMIT_MILLIS)
             return;
-        const maxDesiredMemoryBytes = this.maxUsedRatio * effectiveMax;
-        const reserveMemory = effectiveMax * (1 - this.maxUsedRatio) * RESERVE_MEMORY_RATIO;
+        const maxDesiredMemoryBytes = this.#maxUsedRatio * effectiveMax;
+        const reserveMemory = effectiveMax * (1 - this.#maxUsedRatio) * RESERVE_MEMORY_RATIO;
         const criticalOverloadBytes = maxDesiredMemoryBytes + reserveMemory;
         const isCriticalOverload = memCurrentBytes > criticalOverloadBytes;
         if (isCriticalOverload) {
             const usedPercentage = Math.round((memCurrentBytes / effectiveMax) * 100);
             const toMb = (bytes) => Math.round(bytes / 1024 ** 2);
-            this.log.warning('Memory is critically overloaded. ' +
+            this.#log.warning('Memory is critically overloaded. ' +
                 `Using ${toMb(memCurrentBytes)} MB of ${toMb(effectiveMax)} MB (${usedPercentage}%). Consider increasing available memory.`);
-            this.lastLoggedCriticalMemoryOverloadAt = createdAt;
+            this.#lastLoggedCriticalMemoryOverloadAt = createdAt;
         }
     }
-    async _getTotalMemoryBytes() {
-        const containerized = this.config.containerized ?? (await isContainerized());
+    async getTotalMemoryBytes() {
+        const containerized = this.#config.containerized ?? (await isContainerized());
         return (await getMemoryInfo({ containerized, logger: serviceLocator.getLogger() })).totalBytes;
     }
 }

package/autoscaling/snapshotter.d.ts

@@ -61,10 +61,7 @@ export type SnapshotterOptions = Omit<LoadSignalsOptions, 'custom'>;
  * @internal
  */
 export declare class Snapshotter {
-    private readonly memorySignal?;
-    private readonly eventLoopSignal?;
-    private readonly cpuSignal?;
-    private readonly clientSignal?;
+    #private;
     /**
      * Returns the enabled built-in signals, so `SystemStatus` can iterate them alongside any custom `LoadSignal`
      * instances. Signals switched off through the options are simply absent — the system status reports them as

package/autoscaling/snapshotter.js

@@ -13,10 +13,10 @@ import { MemoryLoadSignal } from './memory_load_signal.js';
  */
 export class Snapshotter {
     // Absent when switched off through the corresponding option (e.g. `client: false`).
-    memorySignal;
-    eventLoopSignal;
-    cpuSignal;
-    clientSignal;
+    #memorySignal;
+    #eventLoopSignal;
+    #cpuSignal;
+    #clientSignal;
     /**
      * Returns the enabled built-in signals, so `SystemStatus` can iterate them alongside any custom `LoadSignal`
      * instances. Signals switched off through the options are simply absent — the system status reports them as
@@ -24,10 +24,10 @@ export class Snapshotter {
      */
     getLoadSignals() {
         const builtin = [
-            this.memorySignal,
-            this.eventLoopSignal,
-            this.cpuSignal,
-            this.clientSignal,
+            this.#memorySignal,
+            this.#eventLoopSignal,
+            this.#cpuSignal,
+            this.#clientSignal,
         ];
         return builtin.filter((signal) => signal !== undefined);
     }
@@ -39,13 +39,13 @@ export class Snapshotter {
         // Each signal resolves its own ambient dependencies when started, and is told the window it will be sampled
         // over then too - so there is nothing to thread in here beyond the caller's tuning.
         if (memory !== false)
-            this.memorySignal = new MemoryLoadSignal(memory);
+            this.#memorySignal = new MemoryLoadSignal(memory);
         if (eventLoop !== false)
-            this.eventLoopSignal = new EventLoopLoadSignal(eventLoop);
+            this.#eventLoopSignal = new EventLoopLoadSignal(eventLoop);
         if (cpu !== false)
-            this.cpuSignal = new CpuLoadSignal(cpu);
+            this.#cpuSignal = new CpuLoadSignal(cpu);
         if (client !== false)
-            this.clientSignal = new ClientLoadSignal(client);
+            this.#clientSignal = new ClientLoadSignal(client);
     }
     /**
      * Starts capturing snapshots at configured intervals. The `context` carries the sample window the signals will

package/autoscaling/system_status.d.ts

@@ -105,9 +105,7 @@ export interface FinalStatistics {
  * @internal
  */
 export declare class SystemStatus {
-    private readonly currentHistoryMillis;
-    private readonly historyMillis;
-    private readonly signals;
+    #private;
     constructor(options: SystemStatusOptions);
     /**
      * The widest window any signal will be queried with, and therefore exactly how much history the signals are asked

package/autoscaling/system_status.js

@@ -32,14 +32,14 @@ const BUILTIN_SIGNAL_NAMES = new Set(Object.keys(BUILTIN_SIGNAL_OPTION_KEYS));
  * @internal
  */
 export class SystemStatus {
-    currentHistoryMillis;
-    historyMillis;
-    signals;
+    #currentHistoryMillis;
+    #historyMillis;
+    #signals;
     constructor(options) {
         const { currentHistorySecs = DEFAULT_CURRENT_HISTORY_SECS, historySecs = DEFAULT_SNAPSHOT_HISTORY_SECS, snapshotter, loadSignals = [], } = options;
-        this.currentHistoryMillis = currentHistorySecs * 1000;
-        this.historyMillis = historySecs * 1000;
-        this.signals = [...snapshotter.getLoadSignals(), ...loadSignals];
+        this.#currentHistoryMillis = currentHistorySecs * 1000;
+        this.#historyMillis = historySecs * 1000;
+        this.#signals = [...snapshotter.getLoadSignals(), ...loadSignals];
         this.assertUniqueSignalNames();
     }
     /**
@@ -48,7 +48,7 @@ export class SystemStatus {
      * defaults.
      */
     get maxSampleWindowMillis() {
-        return Math.max(this.currentHistoryMillis, this.historyMillis);
+        return Math.max(this.#currentHistoryMillis, this.#historyMillis);
     }
     /**
      * Signal names are the keys of the reported {@link SystemInfo}, so a duplicate would leave a status object that
@@ -57,7 +57,7 @@ export class SystemStatus {
      */
     assertUniqueSignalNames() {
         const seen = new Set();
-        for (const { name } of this.signals) {
+        for (const { name } of this.#signals) {
             if (!seen.has(name)) {
                 seen.add(name);
                 continue;
@@ -85,7 +85,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:
@@ -103,7 +103,7 @@ export class SystemStatus {
      * `historySecs` seconds and `true` otherwise.
      */
     getHistoricalStatus() {
-        return this.isSystemIdle(this.historyMillis);
+        return this.isSystemIdle(this.#historyMillis);
     }
     /**
      * Returns a system status object.
@@ -117,7 +117,7 @@ export class SystemStatus {
             clientInfo: { isOverloaded: false, limitRatio: 0, actualRatio: 0 },
         };
         let loadSignalInfo;
-        for (const signal of this.signals) {
+        for (const signal of this.#signals) {
             const sample = signal.getSample(sampleDurationMillis);
             const info = evaluateLoadSignalSample(sample, signal.overloadedRatio);
             if (info.isOverloaded) {

package/configuration.d.ts

@@ -123,12 +123,12 @@ export interface Configuration extends ResolvedConfigValues {
  * `containerized` | `CRAWLEE_CONTAINERIZED` | -
  */
 export declare class Configuration {
+    #private;
     /**
      * Field definitions for this configuration class.
      * Subclasses override this to register additional fields.
      */
     protected static fields: Record<string, ConfigField>;
-    private resolvedValues;
     /**
      * Creates new `Configuration` instance with provided options.
      * Constructor options take precedence over environment variables, which take precedence

package/configuration.js

@@ -147,7 +147,7 @@ export class Configuration {
      * Subclasses override this to register additional fields.
      */
     static fields = crawleeConfigFields;
-    resolvedValues;
+    #resolvedValues;
     /**
      * Creates new `Configuration` instance with provided options.
      * Constructor options take precedence over environment variables, which take precedence
@@ -156,7 +156,7 @@ export class Configuration {
     constructor(options = {}) {
         const fields = this.constructor.fields;
         const fileOptions = Configuration.loadFileOptions();
-        this.resolvedValues = Configuration.resolveAll(fields, options, fileOptions);
+        this.#resolvedValues = Configuration.resolveAll(fields, options, fileOptions);
         this.registerAccessors();
         // Set the log level
         const logLevel = this.logLevel;
@@ -209,7 +209,7 @@ export class Configuration {
         const descriptors = {};
         for (const key of Object.keys(fields)) {
             descriptors[key] = {
-                get: () => this.resolvedValues[key],
+                get: () => this.#resolvedValues[key],
                 set() {
                     throw new TypeError('Configuration is immutable. Pass options via the constructor instead.');
                 },

package/crawlers/context_pipeline.js

@@ -26,12 +26,12 @@ export class ContextPipeline {
  * properties from the `ContextPipeline` interface, making type checking more reliable.
  */
 class ContextPipelineImpl extends ContextPipeline {
-    middleware;
-    parent;
+    #middleware;
+    #parent;
     constructor(middleware, parent) {
         super();
-        this.middleware = middleware;
-        this.parent = parent;
+        this.#middleware = middleware;
+        this.#parent = parent;
     }
     /**
      * @inheritdoc
@@ -50,8 +50,8 @@ class ContextPipelineImpl extends ContextPipeline {
     *middlewareChain() {
         let step = this;
         while (step !== undefined) {
-            yield step.middleware;
-            step = step.parent;
+            yield step.#middleware;
+            step = step.#parent;
         }
     }
     /**

package/crawlers/statistics.d.ts

@@ -81,6 +81,7 @@ export interface CalculatedStatistics {
  * @category Crawlers
  */
 export declare class Statistics implements IStatistics {
+    #private;
     private static id;
     /**
      * An error tracker for final retry errors.
@@ -104,15 +105,7 @@ export declare class Statistics implements IStatistics {
     readonly requestRetryHistogram: number[];
     protected keyValueStore?: KeyValueStore;
     protected readonly persistStateKey: string;
-    private logIntervalMillis;
-    private logMessage;
-    private listener;
-    private requestsInProgress;
     private readonly log;
-    private instanceStart;
-    private logInterval;
-    private _events?;
-    private persistenceOptions;
     private get events();
     /**
      * Construct a statistics instance to pass to a crawler via its `statistics` option, e.g. to preconfigure

package/crawlers/statistics.js

@@ -6,14 +6,14 @@ import { ErrorTracker } from './error_tracker.js';
  * @ignore
  */
 class Job {
-    lastRunAt = null;
-    durationMillis;
+    #lastRunAt = null;
+    #durationMillis;
     run() {
-        this.lastRunAt = Date.now();
+        this.#lastRunAt = Date.now();
     }
     finish() {
-        this.durationMillis = Date.now() - this.lastRunAt;
-        return this.durationMillis;
+        this.#durationMillis = Date.now() - this.#lastRunAt;
+        return this.#durationMillis;
     }
 }
 const errorTrackerConfig = {
@@ -35,6 +35,7 @@ const errorTrackerConfig = {
  * @category Crawlers
  */
 export class Statistics {
+    // kept as TS-private: statistics tests read the static counter directly
     static id = 0;
     /**
      * An error tracker for final retry errors.
@@ -58,20 +59,20 @@ export class Statistics {
     requestRetryHistogram = [];
     keyValueStore = undefined;
     persistStateKey;
-    logIntervalMillis;
-    logMessage;
-    listener;
-    requestsInProgress = new Map();
+    #logIntervalMillis;
+    #logMessage;
+    #listener;
+    #requestsInProgress = new Map();
     log;
-    instanceStart;
-    logInterval;
-    _events;
-    persistenceOptions;
+    #instanceStart;
+    #logInterval;
+    #events;
+    #persistenceOptions;
     get events() {
-        if (!this._events) {
-            this._events = serviceLocator.getEventManager();
+        if (!this.#events) {
+            this.#events = serviceLocator.getEventManager();
         }
-        return this._events;
+        return this.#events;
     }
     /**
      * Construct a statistics instance to pass to a crawler via its `statistics` option, e.g. to preconfigure
@@ -95,11 +96,11 @@ export class Statistics {
         this.log = (options.log ?? serviceLocator.getLogger()).child({ prefix: 'Statistics' });
         this.errorTracker = new ErrorTracker({ ...errorTrackerConfig, saveErrorSnapshots });
         this.errorTrackerRetry = new ErrorTracker({ ...errorTrackerConfig, saveErrorSnapshots });
-        this.logIntervalMillis = logIntervalSecs * 1000;
-        this.logMessage = logMessage;
+        this.#logIntervalMillis = logIntervalSecs * 1000;
+        this.#logMessage = logMessage;
         this.keyValueStore = keyValueStore;
-        this.listener = this.persistState.bind(this);
-        this.persistenceOptions = persistenceOptions;
+        this.#listener = this.persistState.bind(this);
+        this.#persistenceOptions = persistenceOptions;
         // initialize by "resetting"
         this.reset();
     }
@@ -128,15 +129,15 @@ export class Statistics {
             retryErrors: this.errorTrackerRetry.result,
         };
         this.requestRetryHistogram.length = 0;
-        this.requestsInProgress.clear();
-        this.instanceStart = Date.now();
+        this.#requestsInProgress.clear();
+        this.#instanceStart = Date.now();
         this.teardown();
     }
     /**
      * @param options - Override the persistence options provided in the constructor
      */
     async resetStore(options) {
-        if (!this.persistenceOptions.enable && !options?.enable) {
+        if (!this.#persistenceOptions.enable && !options?.enable) {
             return;
         }
         if (!this.keyValueStore) {
@@ -159,18 +160,18 @@ export class Statistics {
      * @ignore
      */
     startJob(id) {
-        let job = this.requestsInProgress.get(id);
+        let job = this.#requestsInProgress.get(id);
         if (!job)
             job = new Job();
         job.run();
-        this.requestsInProgress.set(id, job);
+        this.#requestsInProgress.set(id, job);
     }
     /**
      * Mark job as finished and sets the state
      * @ignore
      */
     finishJob(id, retryCount) {
-        const job = this.requestsInProgress.get(id);
+        const job = this.#requestsInProgress.get(id);
         if (!job)
             return;
         const jobDurationMillis = job.finish();
@@ -181,20 +182,20 @@ export class Statistics {
             this.state.requestMinDurationMillis = jobDurationMillis;
         if (jobDurationMillis > this.state.requestMaxDurationMillis)
             this.state.requestMaxDurationMillis = jobDurationMillis;
-        this.requestsInProgress.delete(id);
+        this.#requestsInProgress.delete(id);
     }
     /**
      * Mark job as failed and sets the state
      * @ignore
      */
     failJob(id, retryCount) {
-        const job = this.requestsInProgress.get(id);
+        const job = this.#requestsInProgress.get(id);
         if (!job)
             return;
         this.state.requestTotalFailedDurationMillis += job.finish();
         this.state.requestsFailed++;
         this.saveRetryCountForJob(retryCount);
-        this.requestsInProgress.delete(id);
+        this.#requestsInProgress.delete(id);
     }
     /**
      * Discards a started job without affecting the finished/failed counters, e.g. when a request
@@ -202,14 +203,14 @@ export class Statistics {
      * @ignore
      */
     discardJob(id) {
-        this.requestsInProgress.delete(id);
+        this.#requestsInProgress.delete(id);
     }
     /**
      * Calculate the current statistics
      */
     calculate() {
         const { requestsFailed, requestsFinished, requestTotalFailedDurationMillis, requestTotalFinishedDurationMillis, } = this.state;
-        const totalMillis = Date.now() - this.instanceStart;
+        const totalMillis = Date.now() - this.#instanceStart;
         const totalMinutes = totalMillis / 1000 / 60;
         return {
             requestAvgFailedDurationMillis: Math.round(requestTotalFailedDurationMillis / requestsFailed) || Infinity,
@@ -228,23 +229,23 @@ export class Statistics {
     async startCapturing() {
         // A single instance drives one logging interval and one PERSIST_STATE listener, so a second concurrent
         // capture (e.g. sharing one instance across crawlers running at once) would orphan the first. Fail loudly.
-        if (this.logInterval) {
+        if (this.#logInterval) {
             throw new Error('Statistics.startCapturing() was already called - this instance is already capturing.');
         }
         this.keyValueStore ??= await KeyValueStore.open(null, { configuration: serviceLocator.getConfiguration() });
         if (this.state.crawlerStartedAt === null) {
             this.state.crawlerStartedAt = new Date();
         }
-        if (this.persistenceOptions.enable) {
+        if (this.#persistenceOptions.enable) {
             await this.maybeLoadStatistics();
-            this.events.on("persistState" /* EventType.PERSIST_STATE */, this.listener);
+            this.events.on("persistState" /* EventType.PERSIST_STATE */, this.#listener);
         }
-        this.logInterval = setInterval(() => {
-            this.log.info(this.logMessage, {
+        this.#logInterval = setInterval(() => {
+            this.log.info(this.#logMessage, {
                 ...this.calculate(),
                 retryHistogram: this.requestRetryHistogram,
             });
-        }, this.logIntervalMillis);
+        }, this.#logIntervalMillis);
     }
     /**
      * Stops logging and remove event listeners, then persist
@@ -265,7 +266,7 @@ export class Statistics {
      * @param options - Override the persistence options provided in the constructor
      */
     async persistState(options) {
-        if (!this.persistenceOptions.enable && !options?.enable) {
+        if (!this.#persistenceOptions.enable && !options?.enable) {
             return;
         }
         // this might be called before startCapturing was called without using await, should not crash
@@ -312,17 +313,17 @@ export class Statistics {
         this.state.crawlerStartedAt = savedState.crawlerStartedAt ? new Date(savedState.crawlerStartedAt) : null;
         this.state.statsPersistedAt = savedState.statsPersistedAt ? new Date(savedState.statsPersistedAt) : null;
         this.state.crawlerRuntimeMillis = savedState.crawlerRuntimeMillis;
-        this.instanceStart = Date.now() - (+this.state.statsPersistedAt - savedState.crawlerLastStartTimestamp);
+        this.#instanceStart = Date.now() - (+this.state.statsPersistedAt - savedState.crawlerLastStartTimestamp);
         this.log.debug('Loaded from KeyValueStore');
     }
     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)
-        this._events?.off("persistState" /* EventType.PERSIST_STATE */, this.listener);
-        if (this.logInterval) {
-            clearInterval(this.logInterval);
-            this.logInterval = null;
+        this.#events?.off("persistState" /* EventType.PERSIST_STATE */, this.#listener);
+        if (this.#logInterval) {
+            clearInterval(this.#logInterval);
+            this.#logInterval = null;
         }
     }
     /**
@@ -335,7 +336,7 @@ export class Statistics {
         // omit duplicated information
         const result = {
             ...this.state,
-            crawlerLastStartTimestamp: this.instanceStart,
+            crawlerLastStartTimestamp: this.#instanceStart,
             crawlerFinishedAt: this.state.crawlerFinishedAt
                 ? new Date(this.state.crawlerFinishedAt).toISOString()
                 : null,

package/events/event_manager.d.ts

@@ -41,12 +41,12 @@ interface Intervals {
     systemInfo?: BetterIntervalID;
 }
 export declare abstract class EventManager {
+    #private;
     protected events: AsyncEventEmitter<{}>;
     protected initialized: boolean;
     protected intervals: Intervals;
 // @ts-ignore optional peer dependency or compatibility with es2022
     protected log: import("@crawlee/types").CrawleeLogger;
-    private persistStateIntervalMillis;
     constructor(options: EventManagerOptions);
     /**
      * Initializes the event manager by starting the `persistState` event interval.

package/events/event_manager.js

@@ -15,9 +15,9 @@ export class EventManager {
     initialized = false;
     intervals = {};
     log = serviceLocator.getLogger().child({ prefix: 'Events' });
-    persistStateIntervalMillis;
+    #persistStateIntervalMillis;
     constructor(options) {
-        this.persistStateIntervalMillis = options.persistStateIntervalMillis;
+        this.#persistStateIntervalMillis = options.persistStateIntervalMillis;
         this.events.setMaxListeners(50);
     }
     /**
@@ -31,7 +31,7 @@ export class EventManager {
         this.intervals.persistState = betterSetInterval((intervalCallback) => {
             this.emit("persistState" /* EventType.PERSIST_STATE */, { isMigrating: false });
             intervalCallback();
-        }, this.persistStateIntervalMillis);
+        }, this.#persistStateIntervalMillis);
         this.initialized = true;
     }
     /**

package/events/local_event_manager.d.ts

@@ -5,7 +5,7 @@ export interface LocalEventManagerOptions extends EventManagerOptions {
     systemInfoIntervalMillis: number;
 }
 export declare class LocalEventManager extends EventManager {
-    private systemInfoIntervalMillis;
+    #private;
     constructor(options: LocalEventManagerOptions);
     /**
      * Creates a new `LocalEventManager` based on the provided `Configuration`.