@crawlee/core 4.0.0-beta.99 → 4.0.0-rc.0

package/enqueue_links/shared.d.ts

@@ -1,23 +1,27 @@
-import type { Awaitable } from '@crawlee/types';
+import type { Awaitable, Dictionary } from '@crawlee/types';
+import { z } from 'zod';
 import type { RequestOptions } from '../request.js';
-import type { EnqueueLinksOptions } from './enqueue_links.js';
-export { tryAbsoluteURL } from '@crawlee/utils';
-export type UrlPatternObject = {
+import type { EnqueueStrategyOption } from './enqueue_links.js';
+export { tryAbsoluteURL } from '@crawlee/utils/internal';
+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;
+/**
+ * Accepts one {@link UrlPatternInput} — a glob string, a RegExp instance, or a `{ glob }` / `{ regexp }` object.
+ * @internal
+ */
+export declare const urlPatternSchema: z.ZodType<UrlPatternInput>;
 export type SkippedRequestReason = 'robotsTxt' | 'limit' | 'enqueueLimit' | 'filters' | 'transform' | 'redirect' | 'depth';
 export type SkippedRequestCallback = (args: {
     url: string;
@@ -26,13 +30,7 @@ export type SkippedRequestCallback = (args: {
 /**
  * @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.
@@ -50,17 +48,29 @@ export declare function validateGlobPattern(glob: string): string;
  */
 export declare function constructRegExpObjectsFromRegExps(regexps: readonly RegExpInput[]): RegExpObject[];
 /**
- * Filters request options by URL patterns and merges pattern-level options (label, userData, method, payload, headers)
- * from the first matching pattern into each RequestOptions entry.
+ * 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 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 filterRequestOptionsByPatterns(requestOptions: RequestOptions[], includePatterns: UrlPatternObject[] | undefined, excludePatterns?: UrlPatternObject[], strategy?: EnqueueLinksOptions['strategy'], onSkippedUrl?: (url: string) => void): RequestOptions[];
+export declare function filterRequestOptionsByPatterns(requestOptions: RequestOptions[], includePatterns: UrlPatternObject[] | undefined, excludePatterns?: UrlPatternObject[], strategy?: EnqueueStrategyOption, onSkippedUrl?: (url: string) => void): RequestOptions[];
 /**
  * @ignore
  */
-export declare function createRequestOptions(sources: readonly (string | Record<string, unknown>)[], options?: Pick<EnqueueLinksOptions, 'label' | 'userData' | 'baseUrl' | 'skipNavigation' | 'sessionId' | 'strategy'>): RequestOptions[];
+export declare function createRequestOptions(sources: readonly (string | Record<string, unknown>)[], options?: {
+    label?: string;
+    userData?: Dictionary;
+    baseUrl?: string;
+    skipNavigation?: boolean;
+    sessionId?: string;
+    strategy?: EnqueueStrategyOption;
+}): 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.

package/enqueue_links/shared.js

@@ -1,15 +1,25 @@
 import { URL } from 'node:url';
 import { Minimatch } from 'minimatch';
-import { purlToRegExp } from '@apify/pseudo_url';
-export { tryAbsoluteURL } from '@crawlee/utils';
+import { z } from 'zod';
+import { schemas } from '../validators.js';
+export { tryAbsoluteURL } from '@crawlee/utils/internal';
 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']),
+]);
 /**
  * @ignore
  */
@@ -20,28 +30,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.
@@ -71,8 +59,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;
@@ -102,15 +89,31 @@ export function constructRegExpObjectsFromRegExps(regexps) {
             regexpObject = { regexp: item };
         }
         else {
-            regexpObject = item;
+            regexpObject = { regexp: item.regexp };
         }
         updateEnqueueLinksPatternCache(item, regexpObject);
         return regexpObject;
     });
 }
 /**
- * Filters request options by URL patterns and merges pattern-level options (label, userData, method, payload, headers)
- * from the first matching pattern into each RequestOptions entry.
+ * 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
@@ -130,9 +133,9 @@ export function filterRequestOptionsByPatterns(requestOptions, includePatterns,
         if (!includeMatchers) {
             return { ...opts, enqueueStrategy: strategy };
         }
-        for (const { match, glob, regexp, ...patternOptions } of includeMatchers) {
+        for (const { match } of includeMatchers) {
             if (match(opts.url)) {
-                return { ...opts, ...patternOptions, enqueueStrategy: strategy };
+                return { ...opts, enqueueStrategy: strategy };
             }
         }
         // didn't match any positive pattern
@@ -141,6 +144,16 @@ export function filterRequestOptionsByPatterns(requestOptions, includePatterns,
     })
         .filter((opts) => opts !== null);
 }
+function isAbsoluteUrl(url) {
+    try {
+        // eslint-disable-next-line no-new
+        new URL(url);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
 /**
  * @ignore
  */
@@ -158,7 +171,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 = {
@@ -191,7 +209,7 @@ function createPatternObjectMatcher(urlPatternObject) {
     else {
         match = () => false;
     }
-    return { ...urlPatternObject, match };
+    return { match };
 }
 /**
  * Applies a {@link RequestTransform} function to a list of request options.

package/errors.d.ts

@@ -14,6 +14,16 @@ 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.
  *
@@ -21,18 +31,19 @@ export declare class MissingRouteError extends CriticalError {
  */
 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;
-        })[];
-    }[]);
+    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.
@@ -42,6 +53,26 @@ export declare class RequestValidationError extends NonRetryableError {
 export declare class RetryRequestError extends Error {
     constructor(message?: string);
 }
+/**
+ * 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 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.
  *

package/errors.js

@@ -15,6 +15,16 @@ 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.
  *
@@ -24,19 +34,26 @@ export class RequestValidationError extends NonRetryableError {
     label;
     issues;
     constructor(label, issues) {
-        const details = issues
-            .map((issue) => {
-            const path = (issue.path ?? [])
-                .map((segment) => (typeof segment === 'object' ? segment.key : segment))
-                .join('.');
-            return `- ${path ? `${path}: ` : ''}${issue.message}`;
-        })
-            .join('\n');
-        super(`Request userData for label '${String(label)}' failed schema validation:\n${details}`);
+        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.
  *
@@ -47,6 +64,28 @@ export class RetryRequestError extends Error {
         super(message ?? "Request is being retried at the user's request");
     }
 }
+/**
+ * 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.
  *

package/events/event_manager.d.ts

@@ -4,7 +4,7 @@ export interface EventManagerOptions {
     /** Interval between emitted `persistState` events in milliseconds. */
     persistStateIntervalMillis: number;
 }
-export declare const enum EventType {
+export declare enum EventType {
     PERSIST_STATE = "persistState",
     SYSTEM_INFO = "systemInfo",
     MIGRATING = "migrating",
@@ -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,10 +15,11 @@ export class EventManager {
     initialized = false;
     intervals = {};
     log = serviceLocator.getLogger().child({ prefix: 'Events' });
-    persistStateIntervalMillis;
+    #persistStateIntervalMillis;
     constructor(options) {
-        this.persistStateIntervalMillis = options.persistStateIntervalMillis;
-        this.events.setMaxListeners(50);
+        this.#persistStateIntervalMillis = options.persistStateIntervalMillis;
+        // One MIGRATING listener per RequestQueue, and ThrottlingRequestManager opens one per domain.
+        this.events.setMaxListeners(150);
     }
     /**
      * Initializes the event manager by starting the `persistState` event interval.
@@ -29,9 +30,9 @@ export class EventManager {
             return;
         }
         this.intervals.persistState = betterSetInterval((intervalCallback) => {
-            this.emit("persistState" /* EventType.PERSIST_STATE */, { isMigrating: false });
+            this.emit(EventType.PERSIST_STATE, { isMigrating: false });
             intervalCallback();
-        }, this.persistStateIntervalMillis);
+        }, this.#persistStateIntervalMillis);
         this.initialized = true;
     }
     /**
@@ -45,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();
     }

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`.

package/events/local_event_manager.js

@@ -1,11 +1,11 @@
 import { betterClearInterval, betterSetInterval } from '@apify/utilities';
 import { serviceLocator } from '../service_locator.js';
-import { EventManager } from './event_manager.js';
+import { EventManager, EventType } from './event_manager.js';
 export class LocalEventManager extends EventManager {
-    systemInfoIntervalMillis;
+    #systemInfoIntervalMillis;
     constructor(options) {
         super(options);
-        this.systemInfoIntervalMillis = options.systemInfoIntervalMillis;
+        this.#systemInfoIntervalMillis = options.systemInfoIntervalMillis;
     }
     /**
      * Creates a new `LocalEventManager` based on the provided `Configuration`.
@@ -28,7 +28,7 @@ export class LocalEventManager extends EventManager {
         }
         await super.init();
         this.emitSystemInfoEvent = this.emitSystemInfoEvent.bind(this);
-        this.intervals.systemInfo = betterSetInterval(this.emitSystemInfoEvent.bind(this), this.systemInfoIntervalMillis);
+        this.intervals.systemInfo = betterSetInterval(this.emitSystemInfoEvent.bind(this), this.#systemInfoIntervalMillis);
     }
     /**
      * @inheritDoc
@@ -47,7 +47,7 @@ export class LocalEventManager extends EventManager {
         const info = await this.createSystemInfo({
             maxUsedCpuRatio: serviceLocator.getConfiguration().maxUsedCpuRatio,
         });
-        this.events.emit("systemInfo" /* EventType.SYSTEM_INFO */, info);
+        this.events.emit(EventType.SYSTEM_INFO, info);
         intervalCallback();
     }
     /**

package/http.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Parses a `Retry-After` response header into a delay in milliseconds.
+ *
+ * The header holds either a non-negative number of seconds or an HTTP-date.
+ * See [MDN](https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Headers/Retry-After).
+ *
+ * @returns The delay in milliseconds, or `null` if the header is absent, unparseable, or already elapsed.
+ */
+export declare function parseRetryAfterHeader(value?: string | null): number | null;

package/http.js

@@ -0,0 +1,28 @@
+/**
+ * Parses a `Retry-After` response header into a delay in milliseconds.
+ *
+ * The header holds either a non-negative number of seconds or an HTTP-date.
+ * See [MDN](https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Headers/Retry-After).
+ *
+ * @returns The delay in milliseconds, or `null` if the header is absent, unparseable, or already elapsed.
+ */
+export function parseRetryAfterHeader(value) {
+    if (!value) {
+        return null;
+    }
+    const trimmed = value.trim();
+    // Per the spec this is a `delay-seconds`: digits only, so a negative or fractional value is not one.
+    if (/^\d+$/.test(trimmed)) {
+        // `Retry-After: 0` names no future deadline, same as an HTTP-date that has already passed. Reporting it
+        // as a zero delay would leave the domain unthrottled while still counting as a rate-limit event, so the
+        // caller would defer the request for free and re-send it immediately.
+        const delayMs = Number(trimmed) * 1000;
+        return delayMs > 0 ? delayMs : null;
+    }
+    const date = Date.parse(trimmed);
+    if (!Number.isNaN(date)) {
+        const delayMs = date - Date.now();
+        return delayMs > 0 ? delayMs : null;
+    }
+    return null;
+}

package/index.d.ts

@@ -17,6 +17,6 @@ export * from './storages/index.js';
 export * from './memory-storage/index.js';
 export * from './validators.js';
 export * from './cookie_utils.js';
+export * from './http.js';
 export * from './recoverable_state.js';
-export { PseudoUrl } from '@apify/pseudo_url';
 export type { StorageBackend } from '@crawlee/types';

package/index.js

@@ -17,5 +17,5 @@ export * from './storages/index.js';
 export * from './memory-storage/index.js';
 export * from './validators.js';
 export * from './cookie_utils.js';
+export * from './http.js';
 export * from './recoverable_state.js';
-export { PseudoUrl } from '@apify/pseudo_url';

package/log.js

@@ -30,6 +30,8 @@ import log, { Log, Logger, LoggerJson, LoggerText, LogLevel } from '@apify/log';
  * ```
  */
 export class BaseCrawleeLogger {
+    // kept as TS-private: the adaptive crawler's log proxy calls non-intercepted methods with `this === proxy`,
+    // where `#`-field access would throw at runtime
     options;
     warningsLogged = new Set();
     constructor(options = {}) {
@@ -87,7 +89,9 @@ export class BaseCrawleeLogger {
  */
 export class ApifyLogAdapter extends BaseCrawleeLogger {
     apifyLog;
-    constructor(apifyLog, options) {
+    constructor(
+    // kept as a TS-private parameter property: reached through the adaptive crawler's log proxy, see above
+    apifyLog, options) {
         super(options ?? {});
         this.apifyLog = apifyLog;
     }

package/memory-storage/memory-storage.d.ts

@@ -10,12 +10,8 @@ export interface MemoryStorageOptions {
     logger?: CrawleeLogger;
 }
 export declare class MemoryStorageBackend implements storage.StorageBackend {
+    #private;
     readonly logger?: CrawleeLogger;
-    /**
-     * Unique per-instance cache partition key. Mirrors the way `FileSystemStorageBackend` partitions its
-     * cache by storage directory: two distinct `MemoryStorageBackend` instances must not share cached backends.
-     */
-    private readonly instanceCacheKey;
     readonly keyValueStoreBackendCache: KeyValueStoreBackend[];
     readonly datasetBackendCache: DatasetBackend[];
     readonly requestQueueBackendCache: RequestQueueBackend[];
@@ -25,17 +21,13 @@ export declare class MemoryStorageBackend implements storage.StorageBackend {
      * cache partitions in the storage backend cache.
      */
     getStorageBackendCacheKey(): string;
-    private static resolveStorageKey;
     createDatasetBackend(options?: storage.StorageIdentifier): Promise<storage.DatasetBackend>;
     createKeyValueStoreBackend(options?: storage.StorageIdentifier): Promise<storage.KeyValueStoreBackend>;
     createRequestQueueBackend(options?: storage.StorageIdentifier): Promise<RequestQueueBackend>;
     storageExists(id: string, type: 'Dataset' | 'KeyValueStore' | 'RequestQueue'): Promise<boolean>;
     /**
-     * Cleans up the default storages before the run starts. For the in-memory storage this simply
-     * resets the in-memory state of the cached default dataset, key-value store and request queue.
-     *
-     * As with `FileSystemStorageBackend`, the run's input (the `INPUT` key in the default key-value
-     * store) is preserved — only the rest of the default storages is cleared.
+     * Cleans up the run-scoped storages before the run starts. For the in-memory storage this simply
+     * resets the in-memory state of the cached backends.
      */
     purge(): Promise<void>;
     /**