@crawlee/core 4.0.0-beta.15 → 4.0.0-beta.150

package/enqueue_links/shared.js

@@ -1,16 +1,45 @@
 import { URL } from 'node:url';
 import { Minimatch } from 'minimatch';
-import { purlToRegExp } from '@apify/pseudo_url';
+import { z } from 'zod';
 import { Request } from '../request.js';
-export { tryAbsoluteURL } from '@crawlee/utils';
+import { schemas } from '../validators.js';
 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();
+/**
+ * Accepts one {@link UrlPatternInput} — a glob string, a RegExp instance, or a `{ glob }` / `{ regexp }` object.
+ * @internal
+ */
+export const urlPatternSchema = z.union([
+    z.string(),
+    z.instanceof(RegExp),
+    schemas.objectWithKeys(['glob']),
+    schemas.objectWithKeys(['regexp']),
+]);
+/**
+ * Builds the `{ request, reason }` argument passed to a {@link SkippedRequestCallback}, constructing the
+ * `Request` lazily on first access to `request` (and caching it) since most skips are never observed by a
+ * real callback and building a `Request` isn't free.
+ * @ignore
+ */
+export function createSkippedRequestArgs(source, reason) {
+    const sourceReason = typeof source === 'string' ? undefined : source.skippedReason;
+    let request;
+    return {
+        reason: sourceReason ?? reason,
+        get request() {
+            request ??=
+                source instanceof Request
+                    ? source
+                    : new Request(typeof source === 'string' ? { url: source } : source);
+            return request;
+        },
+    };
+}
 /**
  * @ignore
  */
@@ -21,28 +50,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 +79,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,62 +109,70 @@ 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 createRequests(requestOptions, urlPatternObjects, excludePatternObjects = [], strategy, onSkippedUrl) {
-    const excludePatternObjectMatchers = excludePatternObjects.map(createPatternObjectMatcher);
-    const urlPatternObjectMatchers = urlPatternObjects?.map(createPatternObjectMatcher);
+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 filterRequestOptionsByPatterns(requestOptions, includePatterns, excludePatterns = [], strategy, onSkippedRequestOptions) {
+    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 }) => {
-        const matchesExcludePatterns = excludePatternObjectMatchers.some(({ match }) => match(url));
-        if (matchesExcludePatterns) {
-            onSkippedUrl?.(url);
+        .filter((opts) => {
+        const matchesExclude = excludeMatchers.some(({ match }) => match(opts.url));
+        if (matchesExclude) {
+            onSkippedRequestOptions?.(opts);
         }
-        return !matchesExcludePatterns;
+        return !matchesExclude;
     })
-        .map(({ url, opts }) => {
-        if (!urlPatternObjectMatchers || !urlPatternObjectMatchers.length) {
-            return new Request(typeof opts === 'string' ? { url: opts, enqueueStrategy: strategy } : { ...opts });
-        }
-        for (const urlPatternObject of urlPatternObjectMatchers) {
-            const { match, glob, regexp, ...requestRegExpOptions } = urlPatternObject;
-            if (match(url)) {
-                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?.(url);
+        onSkippedRequestOptions?.(opts);
         return null;
     })
-        .filter((request) => request);
+        .filter((opts) => opts !== null);
 }
-export function filterRequestsByPatterns(requests, patterns, onSkippedUrl) {
-    if (!patterns?.length) {
-        return requests;
+function isAbsoluteUrl(url) {
+    try {
+        // eslint-disable-next-line no-new
+        new URL(url);
+        return true;
     }
-    const filtered = [];
-    const patternMatchers = patterns?.map(createPatternObjectMatcher);
-    for (const request of requests) {
-        const matchingPattern = patternMatchers.find(({ match }) => match(request.url));
-        if (matchingPattern !== undefined) {
-            filtered.push(request);
-        }
-        else {
-            onSkippedUrl?.(request.url);
-        }
+    catch {
+        return false;
     }
-    return filtered;
 }
 /**
  * @ignore
@@ -177,7 +191,12 @@ export function createRequestOptions(sources, options = {}) {
         }
     })
         .map((requestOptions) => {
-        requestOptions.url = new URL(requestOptions.url, options.baseUrl).href;
+        // Leave already-absolute URLs untouched - re-deriving them via `new URL()` would normalize them
+        // (e.g. adding a trailing slash to a bare domain), which is surprising for URLs that didn't need
+        // resolving against `baseUrl` in the first place.
+        if (!isAbsoluteUrl(requestOptions.url)) {
+            requestOptions.url = new URL(requestOptions.url, options.baseUrl).href;
+        }
         requestOptions.userData ??= options.userData ?? {};
         if (typeof options.label === 'string') {
             requestOptions.userData = {
@@ -188,6 +207,9 @@ export function createRequestOptions(sources, options = {}) {
         if (options.skipNavigation) {
             requestOptions.skipNavigation = true;
         }
+        if (options.sessionId) {
+            requestOptions.sessionId = options.sessionId;
+        }
         return requestOptions;
     });
 }
@@ -207,6 +229,31 @@ function createPatternObjectMatcher(urlPatternObject) {
     else {
         match = () => false;
     }
-    return { ...urlPatternObject, match };
+    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);
 }
-//# sourceMappingURL=shared.js.map

package/errors.d.ts

@@ -14,6 +14,37 @@ export declare class CriticalError extends NonRetryableError {
  */
 export declare class MissingRouteError extends CriticalError {
 }
+/**
+ * A schema validation issue, structurally compatible with `StandardSchemaV1.Issue`. Declared here so that
+ * error types do not have to depend on `@standard-schema/spec`.
+ */
+export interface SchemaIssue {
+    readonly message: string;
+    readonly path?: readonly (PropertyKey | {
+        key: PropertyKey;
+    })[];
+}
+/**
+ * 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 SchemaIssue[];
+    constructor(label: string | symbol, issues: readonly SchemaIssue[]);
+}
+/**
+ * Thrown by {@link RecoverableState} when a persisted state record does not match its `stateSchema`.
+ *
+ * Whether a corrupt record should abort the run or be discarded in favour of the defaults depends on what the
+ * state is for, so {@link RecoverableState.initialize} always throws and leaves the choice to the caller.
+ */
+export declare class StateValidationError extends Error {
+    readonly persistStateKey: string;
+    readonly issues: readonly SchemaIssue[];
+    constructor(persistStateKey: string, issues: readonly SchemaIssue[]);
+}
 /**
  * Errors of `RetryRequestError` type will always be retried by the crawler.
  *
@@ -23,13 +54,39 @@ export declare class RetryRequestError extends Error {
     constructor(message?: string);
 }
 /**
- * Errors of `SessionError` type will trigger a session rotation.
+ * Thrown when a domain has rate-limited us and the request should simply be attempted again later.
  *
- * This error doesn't respect the `maxRequestRetries` option and has a separate limit of `maxSessionRotations`.
+ * The request is reclaimed without recording a failure: it costs neither a retry nor session reputation, because
+ * nothing about the request or the session was at fault. A {@link ThrottlingRequestManager} holds it back until
+ * the domain's backoff expires, so retries are paced rather than immediate.
  */
-export declare class SessionError extends RetryRequestError {
+export declare class RequestThrottledError extends RetryRequestError {
     constructor(message?: string);
 }
+/**
+ * Thrown when a domain has rate-limited us for so long that no request has got through, and the crawl is
+ * abandoned rather than kept waiting.
+ *
+ * Waiting longer will not help: at this point the concurrency is too high for the domain, or it has blocked us.
+ * The affected requests are deliberately left in their queue, so re-running the crawl without purging storages
+ * resumes them once the domain recovers.
+ */
+export declare class PersistentRateLimitError extends CriticalError {
+}
+/**
+ * Errors of `SessionError` type retire the session associated with the request and trigger a regular retry.
+ *
+ * The retry counts towards the `maxRequestRetries` limit, just like any other error.
+ */
+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);
 }
@@ -42,4 +99,15 @@ export declare class ContextPipelineCleanupError extends CriticalError {
 export declare class RequestHandlerError extends Error {
     constructor(error: unknown, options?: ErrorOptions);
 }
-//# sourceMappingURL=errors.d.ts.map
+/**
+ * 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 {
+}

package/errors.js

@@ -1,3 +1,4 @@
+import { inspectValue } from './debug.js';
 /**
  * Errors of `NonRetryableError` type will never be retried by the crawler.
  */
@@ -14,6 +15,45 @@ export class CriticalError extends NonRetryableError {
  */
 export class MissingRouteError extends CriticalError {
 }
+function formatIssues(issues) {
+    return issues
+        .map((issue) => {
+        const path = (issue.path ?? [])
+            .map((segment) => (typeof segment === 'object' ? segment.key : segment))
+            .join('.');
+        return `- ${path ? `${path}: ` : ''}${issue.message}`;
+    })
+        .join('\n');
+}
+/**
+ * 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 class RequestValidationError extends NonRetryableError {
+    label;
+    issues;
+    constructor(label, issues) {
+        super(`Request userData for label '${String(label)}' failed schema validation:\n${formatIssues(issues)}`);
+        this.label = label;
+        this.issues = issues;
+    }
+}
+/**
+ * Thrown by {@link RecoverableState} when a persisted state record does not match its `stateSchema`.
+ *
+ * Whether a corrupt record should abort the run or be discarded in favour of the defaults depends on what the
+ * state is for, so {@link RecoverableState.initialize} always throws and leaves the choice to the caller.
+ */
+export class StateValidationError extends Error {
+    persistStateKey;
+    issues;
+    constructor(persistStateKey, issues) {
+        super(`State persisted under key '${persistStateKey}' failed schema validation:\n${formatIssues(issues)}`);
+        this.persistStateKey = persistStateKey;
+        this.issues = issues;
+    }
+}
 /**
  * Errors of `RetryRequestError` type will always be retried by the crawler.
  *
@@ -25,13 +65,43 @@ export class RetryRequestError extends Error {
     }
 }
 /**
- * Errors of `SessionError` type will trigger a session rotation.
+ * Thrown when a domain has rate-limited us and the request should simply be attempted again later.
+ *
+ * The request is reclaimed without recording a failure: it costs neither a retry nor session reputation, because
+ * nothing about the request or the session was at fault. A {@link ThrottlingRequestManager} holds it back until
+ * the domain's backoff expires, so retries are paced rather than immediate.
+ */
+export class RequestThrottledError extends RetryRequestError {
+    constructor(message) {
+        super(message ?? 'Request is being retried later because its domain is rate-limiting us');
+    }
+}
+/**
+ * Thrown when a domain has rate-limited us for so long that no request has got through, and the crawl is
+ * abandoned rather than kept waiting.
+ *
+ * Waiting longer will not help: at this point the concurrency is too high for the domain, or it has blocked us.
+ * The affected requests are deliberately left in their queue, so re-running the crawl without purging storages
+ * resumes them once the domain recovers.
+ */
+export class PersistentRateLimitError extends CriticalError {
+}
+/**
+ * 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 class SessionError extends RetryRequestError {
+export class SessionError extends Error {
     constructor(message) {
-        super(`Detected a session error, rotating session... ${message ? `\n${message}` : ''}`);
+        super(`Detected a session error, retiring session... ${message ? `\n${message}` : ''}`);
+    }
+}
+/**
+ * Thrown when a requested session is not found in the referenced SessionPool.
+ */
+export class MissingSessionError extends Error {
+    constructor(sessionId) {
+        super(`The current SessionPool instance couldn't find a valid session${sessionId ? ` for the following id: ${sessionId}.` : '.'}`);
     }
 }
 export class ContextPipelineInterruptedError extends Error {
@@ -54,4 +124,18 @@ export class RequestHandlerError extends Error {
         super(undefined, { cause: error, ...options });
     }
 }
-//# sourceMappingURL=errors.js.map
+/**
+ * Thrown when attempting to set a different service instance after one has already been retrieved.
+ */
+export class ServiceConflictError extends Error {
+    constructor(serviceName, newValue, existingValue) {
+        super(`Service ${serviceName} is already in use. ` +
+            `Existing value: ${inspectValue(existingValue)}, attempted new value: ${inspectValue(newValue)}.`);
+    }
+}
+/**
+ * Thrown by crawlers when `skipNavigation` is used on a request.
+ * Subclasses can catch this error to skip their own navigation-dependent logic.
+ */
+export class NavigationSkippedError extends NonRetryableError {
+}

package/events/event_manager.d.ts

@@ -1,28 +1,55 @@
 import { AsyncEventEmitter } from '@vladfrangu/async_event_emitter';
 import type { BetterIntervalID } from '@apify/utilities';
-import { Configuration } from '../configuration.js';
-export declare const enum EventType {
+export interface EventManagerOptions {
+    /** Interval between emitted `persistState` events in milliseconds. */
+    persistStateIntervalMillis: number;
+}
+export declare enum EventType {
     PERSIST_STATE = "persistState",
     SYSTEM_INFO = "systemInfo",
     MIGRATING = "migrating",
     ABORTING = "aborting",
-    EXIT = "exit"
+    EXIT = "exit",
+    STATUS_MESSAGE = "statusMessage"
+}
+export type EventTypeName = EventType | 'systemInfo' | 'persistState' | 'migrating' | 'aborting' | 'exit' | 'statusMessage';
+/**
+ * Payload emitted with the {@link EventType.STATUS_MESSAGE|`statusMessage`} event.
+ *
+ * The crawler broadcasts these whenever it wants to report its progress (e.g. periodically, or on
+ * start/finish). Consumers such as the Apify SDK can listen for the event and propagate the message
+ * to the platform. This keeps the crawler decoupled from any specific status-reporting backend.
+ */
+export interface EventStatusMessageData {
+    /**
+     * Identifies the crawler that emitted the message.
+     *
+     * Either the user-provided `id` from the crawler options, or a randomly generated one.
+     * Since a single event manager may be shared by multiple crawlers, consumers can use this
+     * to attribute the message to a specific crawler instance.
+     */
+    crawlerId: string;
+    /** The human-readable status message. */
+    message: string;
+    /** Whether this is the final status message of the run. */
+    isStatusMessageTerminal?: boolean;
+    /** The log level the message was logged with. */
+    level?: 'DEBUG' | 'INFO' | 'WARNING' | 'ERROR';
 }
-export type EventTypeName = EventType | 'systemInfo' | 'persistState' | 'migrating' | 'aborting' | 'exit';
 interface Intervals {
     persistState?: BetterIntervalID;
     systemInfo?: BetterIntervalID;
 }
 export declare abstract class EventManager {
-    readonly config: Configuration;
+    #private;
     protected events: AsyncEventEmitter<{}>;
     protected initialized: boolean;
     protected intervals: Intervals;
 // @ts-ignore optional peer dependency or compatibility with es2022
-    protected log: import("@apify/log").Log;
-    constructor(config?: Configuration);
+    protected log: import("@crawlee/types").CrawleeLogger;
+    constructor(options: EventManagerOptions);
     /**
-     * Initializes the event manager by creating the `persistState` event interval.
+     * Initializes the event manager by starting the `persistState` event interval.
      * This is automatically called at the beginning of `crawler.run()`.
      */
     init(): Promise<void>;
@@ -49,4 +76,3 @@ export declare abstract class EventManager {
     waitForAllListenersToComplete(): Promise<boolean>;
 }
 export {};
-//# sourceMappingURL=event_manager.d.ts.map

package/events/event_manager.js

@@ -1,7 +1,6 @@
 import { AsyncEventEmitter } from '@vladfrangu/async_event_emitter';
-import log from '@apify/log';
 import { betterClearInterval, betterSetInterval } from '@apify/utilities';
-import { Configuration } from '../configuration.js';
+import { serviceLocator } from '../service_locator.js';
 export var EventType;
 (function (EventType) {
     EventType["PERSIST_STATE"] = "persistState";
@@ -9,30 +8,31 @@ export var EventType;
     EventType["MIGRATING"] = "migrating";
     EventType["ABORTING"] = "aborting";
     EventType["EXIT"] = "exit";
+    EventType["STATUS_MESSAGE"] = "statusMessage";
 })(EventType || (EventType = {}));
 export class EventManager {
-    config;
     events = new AsyncEventEmitter();
     initialized = false;
     intervals = {};
-    log = log.child({ prefix: 'Events' });
-    constructor(config = Configuration.getGlobalConfig()) {
-        this.config = config;
-        this.events.setMaxListeners(50);
+    log = serviceLocator.getLogger().child({ prefix: 'Events' });
+    #persistStateIntervalMillis;
+    constructor(options) {
+        this.#persistStateIntervalMillis = options.persistStateIntervalMillis;
+        // One MIGRATING listener per RequestQueue, and ThrottlingRequestManager opens one per domain.
+        this.events.setMaxListeners(150);
     }
     /**
-     * Initializes the event manager by creating the `persistState` event interval.
+     * Initializes the event manager by starting the `persistState` event interval.
      * This is automatically called at the beginning of `crawler.run()`.
      */
     async init() {
         if (this.initialized) {
             return;
         }
-        const persistStateIntervalMillis = this.config.get('persistStateIntervalMillis');
         this.intervals.persistState = betterSetInterval((intervalCallback) => {
-            this.emit("persistState" /* EventType.PERSIST_STATE */, { isMigrating: false });
+            this.emit(EventType.PERSIST_STATE, { isMigrating: false });
             intervalCallback();
-        }, persistStateIntervalMillis);
+        }, this.#persistStateIntervalMillis);
         this.initialized = true;
     }
     /**
@@ -46,7 +46,7 @@ export class EventManager {
         betterClearInterval(this.intervals.persistState);
         this.initialized = false;
         // Emit final PERSIST_STATE event
-        this.emit("persistState" /* EventType.PERSIST_STATE */, { isMigrating: false });
+        this.emit(EventType.PERSIST_STATE, { isMigrating: false });
         // Wait for PERSIST_STATE to process
         await this.waitForAllListenersToComplete();
     }
@@ -86,4 +86,3 @@ export class EventManager {
         return this.events.waitForAllListenersToComplete();
     }
 }
-//# sourceMappingURL=event_manager.js.map

package/events/index.d.ts

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

package/events/index.js

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

package/events/local_event_manager.d.ts

@@ -1,7 +1,19 @@
-import { EventManager } from './event_manager.js';
+import type { Configuration } from '../configuration.js';
+import { EventManager, type EventManagerOptions } from './event_manager.js';
+export interface LocalEventManagerOptions extends EventManagerOptions {
+    /** Interval between emitted `systemInfo` events in milliseconds. */
+    systemInfoIntervalMillis: number;
+}
 export declare class LocalEventManager extends EventManager {
+    #private;
+    constructor(options: LocalEventManagerOptions);
+    /**
+     * Creates a new `LocalEventManager` based on the provided `Configuration`.
+     * Uses the global configuration from the service locator if none is provided.
+     */
+    static fromConfiguration(configuration?: Configuration): LocalEventManager;
     /**
-     * Initializes the EventManager and sets up periodic `systemInfo` and `persistState` events.
+     * Initializes the EventManager and sets up periodic `systemInfo` events.
      * This is automatically called at the beginning of `crawler.run()`.
      */
     init(): Promise<void>;
@@ -23,5 +35,5 @@ export declare class LocalEventManager extends EventManager {
     private createSystemInfo;
     private createCpuInfo;
     private createMemoryInfo;
+    private getMemoryInfo;
 }
-//# sourceMappingURL=local_event_manager.d.ts.map