@crawlee/core 4.0.0-beta.121 → 4.0.0-beta.123

package/autoscaling/autoscaled_pool.js

@@ -1,8 +1,26 @@
-import ow from 'ow';
+import { z } from 'zod';
 import { addTimeoutToPromise } from '@apify/timeout';
 import { betterClearInterval, betterSetInterval } from '@apify/utilities';
 import { CriticalError } from '../errors.js';
 import { serviceLocator } from '../service_locator.js';
+import { parseArgument, schemas, validators } from '../validators.js';
+// `schemas.anyObject` and `objectWithKeys`-based validators pass values through by reference
+// (object schemas return a pruned plain copy), so class instances like loggers and the
+// concurrency system keep their prototype.
+const autoscaledPoolOptionsSchema = z.strictObject({
+    runTaskFunction: schemas.anyFunction,
+    isFinishedFunction: schemas.anyFunction,
+    isTaskReadyFunction: schemas.anyFunction,
+    maybeRunIntervalSecs: schemas.anyNumber
+        .refine((value) => value > 0, 'Expected a number greater than 0')
+        .default(0.5),
+    taskTimeoutSecs: schemas.anyNumber
+        .refine((value) => value >= 0, 'Expected a number greater than or equal to 0')
+        .default(0),
+    log: validators.logger.default(() => serviceLocator.getLogger()),
+    concurrencySystem: schemas.anyObject,
+    consumer: schemas.anyObject.refine((value) => typeof value.id === 'string' && value.id.length > 0, "Expected an object with a non-empty string 'id'"),
+});
 /**
  * Manages a pool of asynchronous resource-intensive tasks that are executed in parallel.
  * The pool only starts new tasks while its {@link IConcurrencySystem|concurrency system} reports free capacity —
@@ -78,17 +96,7 @@ export class AutoscaledPool {
      */
     #ownConcurrency = 0;
     constructor(options) {
-        ow(options, ow.object.exactShape({
-            runTaskFunction: ow.function,
-            isFinishedFunction: ow.function,
-            isTaskReadyFunction: ow.function,
-            maybeRunIntervalSecs: ow.optional.number.greaterThan(0),
-            taskTimeoutSecs: ow.optional.number.greaterThanOrEqual(0),
-            log: ow.optional.object,
-            concurrencySystem: ow.object,
-            consumer: ow.object.partialShape({ id: ow.string.nonEmpty }),
-        }));
-        const { runTaskFunction, isFinishedFunction, isTaskReadyFunction, maybeRunIntervalSecs = 0.5, taskTimeoutSecs = 0, log = serviceLocator.getLogger(), concurrencySystem, consumer, } = options;
+        const { runTaskFunction, isFinishedFunction, isTaskReadyFunction, maybeRunIntervalSecs, taskTimeoutSecs, log, concurrencySystem, consumer, } = parseArgument(options, autoscaledPoolOptionsSchema, 'AutoscaledPoolOptions');
         this.#log = log.child({ prefix: 'AutoscaledPool' });
         // Configurable properties.
         this.#maybeRunIntervalMillis = maybeRunIntervalSecs * 1000;

package/autoscaling/concurrency_system.d.ts

@@ -53,8 +53,8 @@ export interface ConcurrencySystemOptions {
     autoscaleIntervalSecs?: number;
     /**
      * The signals that tell the system whether the machine is overloaded: per-resource tuning for the built-in four
-     * (memory, event loop, CPU, client) plus any {@link LoadSignalsOptions.custom|`custom`} implementations of
-     * your own. See {@link LoadSignalsOptions}.
+     * (memory, event loop, CPU, storage backend) plus any {@link LoadSignalsOptions.custom|`custom`}
+     * implementations of your own. See {@link LoadSignalsOptions}.
      */
     loadSignals?: LoadSignalsOptions;
     /**

package/autoscaling/concurrency_system.js

@@ -1,8 +1,34 @@
-import ow from 'ow';
+import { z } from 'zod';
 import { betterClearInterval, betterSetInterval } from '@apify/utilities';
 import { serviceLocator } from '../service_locator.js';
+import { parseArgument, schemas, validators } from '../validators.js';
 import { Snapshotter } from './snapshotter.js';
 import { SystemStatus } from './system_status.js';
+const concurrencySchema = z.number().int().gte(1).optional();
+// `schemas.anyObject` passes values through by reference, so the load signal instances inside
+// `loadSignals` and class instances like loggers keep their prototype.
+const concurrencySystemOptionsSchema = z.strictObject({
+    maxConcurrency: z.number().int().gte(1).default(200),
+    minConcurrency: z.number().int().gte(1).default(1),
+    desiredConcurrency: z.number().int().gte(1).optional(),
+    desiredConcurrencyRatio: z.number().gt(0).lt(1).default(0.9),
+    scaleUpStepRatio: z.number().gt(0).lt(1).default(0.05),
+    scaleDownStepRatio: z.number().gt(0).lt(1).default(0.05),
+    loggingIntervalSecs: schemas.anyNumber
+        .refine((value) => value > 0, 'Expected a number greater than 0')
+        .nullish()
+        .default(60),
+    autoscaleIntervalSecs: schemas.anyNumber
+        .refine((value) => value > 0, 'Expected a number greater than 0')
+        .default(10),
+    loadSignals: schemas.anyObject.default(() => ({})),
+    snapshotHistorySecs: schemas.anyNumber.refine((value) => value > 0, 'Expected a number greater than 0').optional(),
+    currentHistorySecs: schemas.anyNumber.refine((value) => value > 0, 'Expected a number greater than 0').optional(),
+    log: validators.logger.default(() => serviceLocator.getLogger()),
+    maxTasksPerMinute: z
+        .union([z.number().int().gte(1), z.literal(Number.POSITIVE_INFINITY)])
+        .default(Number.POSITIVE_INFINITY),
+});
 /**
  * The shareable "governor" behind an {@link AutoscaledPool}: it decides whether there is free compute for one more
  * task by combining live system load (via an internal {@link Snapshotter}) with a concurrency budget it autoscales
@@ -44,22 +70,7 @@ export class ConcurrencySystem {
     /** Set once per session, so a pool outliving `stop()` is reported once rather than every half second. */
     #warnedAboutQueryWhileStopped = false;
     constructor(options = {}) {
-        ow(options, ow.object.exactShape({
-            maxConcurrency: ow.optional.number.integer.greaterThanOrEqual(1),
-            minConcurrency: ow.optional.number.integer.greaterThanOrEqual(1),
-            desiredConcurrency: ow.optional.number.integer.greaterThanOrEqual(1),
-            desiredConcurrencyRatio: ow.optional.number.greaterThan(0).lessThan(1),
-            scaleUpStepRatio: ow.optional.number.greaterThan(0).lessThan(1),
-            scaleDownStepRatio: ow.optional.number.greaterThan(0).lessThan(1),
-            loggingIntervalSecs: ow.any(ow.number.greaterThan(0), ow.nullOrUndefined),
-            autoscaleIntervalSecs: ow.optional.number.greaterThan(0),
-            loadSignals: ow.optional.object,
-            snapshotHistorySecs: ow.optional.number.greaterThan(0),
-            currentHistorySecs: ow.optional.number.greaterThan(0),
-            log: ow.optional.object,
-            maxTasksPerMinute: ow.optional.number.integerOrInfinite.greaterThanOrEqual(1),
-        }));
-        const { maxConcurrency = 200, minConcurrency = 1, desiredConcurrency, desiredConcurrencyRatio = 0.9, scaleUpStepRatio = 0.05, scaleDownStepRatio = 0.05, loggingIntervalSecs = 60, autoscaleIntervalSecs = 10, loadSignals = {}, snapshotHistorySecs, currentHistorySecs, log = serviceLocator.getLogger(), maxTasksPerMinute = Infinity, } = options;
+        const { maxConcurrency, minConcurrency, desiredConcurrency, desiredConcurrencyRatio, scaleUpStepRatio, scaleDownStepRatio, loggingIntervalSecs, autoscaleIntervalSecs, loadSignals, snapshotHistorySecs, currentHistorySecs, log, maxTasksPerMinute, } = parseArgument(options, concurrencySystemOptionsSchema, 'ConcurrencySystemOptions');
         this.log = log.child({ prefix: 'ConcurrencySystem' });
         this.desiredConcurrencyRatio = desiredConcurrencyRatio;
         this.scaleUpStepRatio = scaleUpStepRatio;
@@ -99,7 +110,7 @@ export class ConcurrencySystem {
      * If you're not sure, just keep the default value and the concurrency will scale up automatically.
      */
     set minConcurrency(value) {
-        ow(value, ow.optional.number.integer.greaterThanOrEqual(1));
+        parseArgument(value, concurrencySchema);
         this.#minConcurrency = value;
         this.clampDesiredConcurrency();
     }
@@ -116,7 +127,7 @@ export class ConcurrencySystem {
      * limit as they settle).
      */
     set maxConcurrency(value) {
-        ow(value, ow.optional.number.integer.greaterThanOrEqual(1));
+        parseArgument(value, concurrencySchema);
         this.#maxConcurrency = value;
         this.clampDesiredConcurrency();
     }
@@ -132,7 +143,7 @@ export class ConcurrencySystem {
      * in parallel if there's large enough supply of tasks.
      */
     set desiredConcurrency(value) {
-        ow(value, ow.optional.number.integer.greaterThanOrEqual(1));
+        parseArgument(value, concurrencySchema);
         this.#desiredConcurrency = value;
         this.clampDesiredConcurrency();
     }

package/autoscaling/index.d.ts

@@ -1,9 +1,9 @@
 export * from './autoscaled_pool.js';
 export * from './concurrency_system.js';
-export * from './client_load_signal.js';
 export * from './cpu_load_signal.js';
 export * from './event_loop_load_signal.js';
 export * from './load_signal.js';
 export * from './memory_load_signal.js';
 export * from './snapshotter.js';
+export * from './storage_backend_load_signal.js';
 export * from './system_status.js';

package/autoscaling/index.js

@@ -1,9 +1,9 @@
 export * from './autoscaled_pool.js';
 export * from './concurrency_system.js';
-export * from './client_load_signal.js';
 export * from './cpu_load_signal.js';
 export * from './event_loop_load_signal.js';
 export * from './load_signal.js';
 export * from './memory_load_signal.js';
 export * from './snapshotter.js';
+export * from './storage_backend_load_signal.js';
 export * from './system_status.js';

package/autoscaling/load_signal.d.ts

@@ -1,4 +1,4 @@
-import type { ClientInfo } from './system_status.js';
+import type { LoadSignalInfo } from './system_status.js';
 /**
  * A snapshot of a resource's overload state at a point in time.
  */
@@ -22,7 +22,7 @@ export interface LoadSignalStartContext {
  * A signal that reports whether a particular resource is overloaded. The {@link ConcurrencySystem} aggregates
  * several of them — if any one reports overload, the system is overloaded.
  *
- * The built-in signals cover memory, CPU, event loop and storage-client rate limits. Implement this interface to add
+ * The built-in signals cover memory, CPU, event loop and storage backend rate limits. Implement this interface to add
  * your own (navigation timeouts, proxy health, …) and pass them via
  * {@link LoadSignalsOptions.custom|`loadSignals.custom`}; {@link SnapshotStore} does the time-windowed
  * bookkeeping if you want it. Each built-in is also a public class, so one can be *wrapped* rather than reimplemented
@@ -32,8 +32,8 @@ export interface LoadSignal {
     /**
      * This signal's key in the reported {@link SystemInfo}, also used in logging — so it must be unique among the
      * signals of one {@link ConcurrencySystem}, which throws on a duplicate. The four built-in names (`memInfo`,
-     * `eventLoopInfo`, `cpuInfo`, `clientInfo`) land in the correspondingly named `SystemInfo` fields rather than the
-     * `loadSignalInfo` bag; taking one over means switching that built-in off.
+     * `eventLoopInfo`, `cpuInfo`, `storageBackendInfo`) land in the correspondingly named `SystemInfo` fields rather
+     * than the `loadSignalInfo` bag; taking one over means switching that built-in off.
      */
     readonly name: string;
     /**
@@ -79,7 +79,8 @@ export declare class SnapshotStore<T extends LoadSnapshot = LoadSnapshot> {
     getSample(sampleDurationMillis?: number): T[];
     /**
      * Direct, unwindowed access to the underlying array — used by signals whose handler needs the previous snapshot
-     * to compute a delta (e.g. the event loop and client signals read the last entry to measure change since it).
+     * to compute a delta (e.g. the event loop and storage backend signals read the last entry to measure change since
+     * it).
      */
     getAll(): T[];
     /**
@@ -96,4 +97,4 @@ export declare class SnapshotStore<T extends LoadSnapshot = LoadSnapshot> {
  * evaluation logic used by `SystemStatus` for all signal types.
  * @internal
  */
-export declare function evaluateLoadSignalSample(sample: LoadSnapshot[], overloadedRatio: number): ClientInfo;
+export declare function evaluateLoadSignalSample(sample: LoadSnapshot[], overloadedRatio: number): LoadSignalInfo;

package/autoscaling/load_signal.js

@@ -57,7 +57,8 @@ export class SnapshotStore {
     }
     /**
      * Direct, unwindowed access to the underlying array — used by signals whose handler needs the previous snapshot
-     * to compute a delta (e.g. the event loop and client signals read the last entry to measure change since it).
+     * to compute a delta (e.g. the event loop and storage backend signals read the last entry to measure change since
+     * it).
      */
     getAll() {
         return this.#snapshots;

package/autoscaling/snapshotter.d.ts

@@ -1,8 +1,8 @@
-import type { ClientLoadSignalOptions } from './client_load_signal.js';
 import type { CpuLoadSignalOptions } from './cpu_load_signal.js';
 import type { EventLoopLoadSignalOptions } from './event_loop_load_signal.js';
 import type { LoadSignal, LoadSignalStartContext } from './load_signal.js';
 import type { MemoryLoadSignalOptions } from './memory_load_signal.js';
+import type { StorageBackendLoadSignalOptions } from './storage_backend_load_signal.js';
 /**
  * The load signals a {@link ConcurrencySystem} watches to decide whether the machine is overloaded.
  *
@@ -31,11 +31,11 @@ export interface LoadSignalsOptions {
      */
     cpu?: CpuLoadSignalOptions | false;
     /**
-     * Tuning for the built-in {@link ClientLoadSignal} (snapshot interval + error limit + overload ratio), or
-     * `false` to switch it off — worth doing when the storage backend reports no rate-limit statistics, since the
+     * Tuning for the built-in {@link StorageBackendLoadSignal} (snapshot interval + error limit + overload ratio),
+     * or `false` to switch it off — worth doing when the storage backend reports no rate-limit statistics, since the
      * signal otherwise polls it every second to no purpose.
      */
-    client?: ClientLoadSignalOptions | false;
+    storageBackend?: StorageBackendLoadSignalOptions | false;
     /**
      * Additional {@link LoadSignal} implementations — e.g. navigation timeouts or proxy health — evaluated
      * alongside the built-in four. If any signal reports overload, the system counts as overloaded. Their lifecycle
@@ -53,8 +53,8 @@ export interface LoadSignalsOptions {
 export type SnapshotterOptions = Omit<LoadSignalsOptions, 'custom'>;
 /**
  * Owns the four built-in {@link LoadSignal} instances — {@link MemoryLoadSignal},
- * {@link EventLoopLoadSignal}, {@link CpuLoadSignal} and {@link ClientLoadSignal} — constructing the ones
- * that were not switched off and driving their shared lifecycle.
+ * {@link EventLoopLoadSignal}, {@link CpuLoadSignal} and {@link StorageBackendLoadSignal} — constructing
+ * the ones that were not switched off and driving their shared lifecycle.
  *
  * Configured indirectly through {@link ConcurrencySystemOptions.loadSignals|`loadSignals`}, whose per-signal bags
  * are simply forwarded to the corresponding constructor.

package/autoscaling/snapshotter.js

@@ -1,22 +1,22 @@
-import { ClientLoadSignal } from './client_load_signal.js';
 import { CpuLoadSignal } from './cpu_load_signal.js';
 import { EventLoopLoadSignal } from './event_loop_load_signal.js';
 import { MemoryLoadSignal } from './memory_load_signal.js';
+import { StorageBackendLoadSignal } from './storage_backend_load_signal.js';
 /**
  * Owns the four built-in {@link LoadSignal} instances — {@link MemoryLoadSignal},
- * {@link EventLoopLoadSignal}, {@link CpuLoadSignal} and {@link ClientLoadSignal} — constructing the ones
- * that were not switched off and driving their shared lifecycle.
+ * {@link EventLoopLoadSignal}, {@link CpuLoadSignal} and {@link StorageBackendLoadSignal} — constructing
+ * the ones that were not switched off and driving their shared lifecycle.
  *
  * Configured indirectly through {@link ConcurrencySystemOptions.loadSignals|`loadSignals`}, whose per-signal bags
  * are simply forwarded to the corresponding constructor.
  * @internal
  */
 export class Snapshotter {
-    // Absent when switched off through the corresponding option (e.g. `client: false`).
+    // Absent when switched off through the corresponding option (e.g. `storageBackend: false`).
     #memorySignal;
     #eventLoopSignal;
     #cpuSignal;
-    #clientSignal;
+    #storageBackendSignal;
     /**
      * 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
@@ -27,7 +27,7 @@ export class Snapshotter {
             this.#memorySignal,
             this.#eventLoopSignal,
             this.#cpuSignal,
-            this.#clientSignal,
+            this.#storageBackendSignal,
         ];
         return builtin.filter((signal) => signal !== undefined);
     }
@@ -35,7 +35,7 @@ export class Snapshotter {
      * @param [options] All `Snapshotter` configuration options.
      */
     constructor(options = {}) {
-        const { memory = {}, eventLoop = {}, cpu = {}, client = {} } = options;
+        const { memory = {}, eventLoop = {}, cpu = {}, storageBackend = {} } = options;
         // 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)
@@ -44,8 +44,8 @@ export class Snapshotter {
             this.#eventLoopSignal = new EventLoopLoadSignal(eventLoop);
         if (cpu !== false)
             this.#cpuSignal = new CpuLoadSignal(cpu);
-        if (client !== false)
-            this.#clientSignal = new ClientLoadSignal(client);
+        if (storageBackend !== false)
+            this.#storageBackendSignal = new StorageBackendLoadSignal(storageBackend);
     }
     /**
      * Starts capturing snapshots at configured intervals. The `context` carries the sample window the signals will

package/autoscaling/{client_load_signal.d.ts → storage_backend_load_signal.d.ts}

@@ -1,18 +1,19 @@
 import type { LoadSignal, LoadSignalStartContext, LoadSnapshot } from './load_signal.js';
 /**
- * A snapshot produced by the built-in client (rate-limit) signal.
+ * A snapshot produced by the built-in storage backend (rate-limit) signal.
  * @internal
  */
-export interface ClientSnapshot extends LoadSnapshot {
+export interface StorageBackendSnapshot extends LoadSnapshot {
     rateLimitErrorCount: number;
 }
 /**
- * Tuning for the built-in **client** (rate-limit) load signal, as accepted both by {@link ClientLoadSignal} and by
- * the {@link LoadSignalsOptions.client|`client`} shorthand on {@link LoadSignalsOptions}.
+ * Tuning for the built-in **storage backend** (rate-limit) load signal, as accepted both by
+ * {@link StorageBackendLoadSignal} and by the
+ * {@link LoadSignalsOptions.storageBackend|`storageBackend`} shorthand on {@link LoadSignalsOptions}.
  */
-export interface ClientLoadSignalOptions {
+export interface StorageBackendLoadSignalOptions {
     /**
-     * Defines the interval of checking the current state of the remote API client, in seconds.
+     * Defines the interval of checking the current state of the storage backend, in seconds.
      * @default 1
      */
     snapshotIntervalSecs?: number;
@@ -22,7 +23,7 @@ export interface ClientLoadSignalOptions {
      */
     maxErrors?: number;
     /**
-     * Maximum ratio of overloaded snapshots in a sample before the client counts as overloaded.
+     * Maximum ratio of overloaded snapshots in a sample before the storage backend counts as overloaded.
      * @default 0.3
      */
     overloadedRatio?: number;
@@ -33,16 +34,16 @@ export interface ClientLoadSignalOptions {
  *
  * Built by default; construct one yourself only to wrap or adapt it — see {@link LoadSignal}.
  *
- * Switch it off entirely ({@link LoadSignalsOptions.client|`client: false`}) if the storage backend reports no
- * rate-limit statistics, since it otherwise polls it every second to no purpose.
+ * Switch it off entirely ({@link LoadSignalsOptions.storageBackend|`storageBackend: false`}) if the storage backend
+ * reports no rate-limit statistics, since it otherwise polls it every second to no purpose.
  *
  * @category Scaling
  */
-export declare class ClientLoadSignal implements LoadSignal {
+export declare class StorageBackendLoadSignal implements LoadSignal {
     #private;
-    readonly name = "clientInfo";
+    readonly name = "storageBackendInfo";
     readonly overloadedRatio: number;
-    constructor(options?: ClientLoadSignalOptions);
+    constructor(options?: StorageBackendLoadSignalOptions);
     start(context: LoadSignalStartContext): Promise<void>;
     stop(): Promise<void>;
     getSample(sampleDurationMillis?: number): LoadSnapshot[];

package/autoscaling/{client_load_signal.js → storage_backend_load_signal.js}

@@ -1,26 +1,26 @@
 import { betterClearInterval, betterSetInterval } from '@apify/utilities';
 import { serviceLocator } from '../service_locator.js';
 import { SnapshotStore } from './load_signal.js';
-const CLIENT_RATE_LIMIT_ERROR_RETRY_COUNT = 2;
+const RATE_LIMIT_ERROR_RETRY_COUNT = 2;
 /**
  * Periodically checks the storage backend for rate-limit errors (HTTP 429) and reports overload when the error delta
  * exceeds a threshold.
  *
  * Built by default; construct one yourself only to wrap or adapt it — see {@link LoadSignal}.
  *
- * Switch it off entirely ({@link LoadSignalsOptions.client|`client: false`}) if the storage backend reports no
- * rate-limit statistics, since it otherwise polls it every second to no purpose.
+ * Switch it off entirely ({@link LoadSignalsOptions.storageBackend|`storageBackend: false`}) if the storage backend
+ * reports no rate-limit statistics, since it otherwise polls it every second to no purpose.
  *
  * @category Scaling
  */
-export class ClientLoadSignal {
-    name = 'clientInfo';
+export class StorageBackendLoadSignal {
+    name = 'storageBackendInfo';
     overloadedRatio;
     #store = new SnapshotStore();
     #intervalMillis;
     #maxErrors;
     #interval;
-    #client;
+    #storageBackend;
     constructor(options = {}) {
         this.overloadedRatio = options.overloadedRatio ?? 0.3;
         this.#intervalMillis = (options.snapshotIntervalSecs ?? 1) * 1000;
@@ -30,18 +30,18 @@ export class ClientLoadSignal {
     async start(context) {
         this.#store.useSampleWindow(context.maxSampleWindowMillis);
         // A new session starts from a clean slate, or its first measurement diffs the error count against the previous
-        // session's — possibly against a different backend, since the client is resolved afresh just below.
+        // session's — possibly against a different backend, since it is resolved afresh just below.
         this.#store.clear();
         // Resolved here rather than in the constructor, where asking for the backend would instantiate a default one
         // as a side effect - long before the crawler that owns the run has had a chance to register its own.
-        this.#client = serviceLocator.getStorageBackend();
+        this.#storageBackend = serviceLocator.getStorageBackend();
         this.#interval = betterSetInterval(this.handle, this.#intervalMillis);
     }
     async stop() {
         if (this.#interval)
             betterClearInterval(this.#interval);
         this.#interval = undefined;
-        this.#client = undefined;
+        this.#storageBackend = undefined;
     }
     getSample(sampleDurationMillis) {
         return this.#store.getSample(sampleDurationMillis);
@@ -53,8 +53,8 @@ export class ClientLoadSignal {
      */
     handle(intervalCallback) {
         const now = new Date();
-        const allErrorCounts = this.#client?.stats?.rateLimitErrors ?? [];
-        const currentErrCount = allErrorCounts[CLIENT_RATE_LIMIT_ERROR_RETRY_COUNT] || 0;
+        const allErrorCounts = this.#storageBackend?.stats?.rateLimitErrors ?? [];
+        const currentErrCount = allErrorCounts[RATE_LIMIT_ERROR_RETRY_COUNT] || 0;
         const snapshot = {
             createdAt: now,
             isOverloaded: false,

package/autoscaling/system_status.d.ts

@@ -6,10 +6,10 @@ import type { Snapshotter } from './snapshotter.js';
 export interface SystemInfo {
     /** If false, system is being overloaded. */
     isSystemIdle: boolean;
-    memInfo: ClientInfo;
-    eventLoopInfo: ClientInfo;
-    cpuInfo: ClientInfo;
-    clientInfo: ClientInfo;
+    memInfo: LoadSignalInfo;
+    eventLoopInfo: LoadSignalInfo;
+    cpuInfo: LoadSignalInfo;
+    storageBackendInfo: LoadSignalInfo;
     memTotalBytes?: number;
     memCurrentBytes?: number;
     /**
@@ -31,7 +31,7 @@ export interface SystemInfo {
      * Status of additional load signals beyond the built-in four.
      * Keys are `LoadSignal.name` values, values are overload info.
      */
-    loadSignalInfo?: Record<string, ClientInfo>;
+    loadSignalInfo?: Record<string, LoadSignalInfo>;
 }
 /**
  * How far back the *current* system status looks by default — the window that gates task dispatch.
@@ -69,12 +69,12 @@ export interface SystemStatusOptions {
     /**
      * Additional load signals to include in the system status evaluation.
      * These are evaluated alongside the built-in memory, CPU, event loop,
-     * and client signals. If any signal reports overload, the system is
-     * considered overloaded. Each signal carries its own overload ratio.
+     * and storage backend signals. If any signal reports overload, the system
+     * is considered overloaded. Each signal carries its own overload ratio.
      */
     loadSignals?: LoadSignal[];
 }
-export interface ClientInfo {
+export interface LoadSignalInfo {
     isOverloaded: boolean;
     limitRatio: number;
     actualRatio: number;

package/autoscaling/system_status.js

@@ -15,7 +15,7 @@ const BUILTIN_SIGNAL_OPTION_KEYS = {
     memInfo: 'memory',
     eventLoopInfo: 'eventLoop',
     cpuInfo: 'cpu',
-    clientInfo: 'client',
+    storageBackendInfo: 'storageBackend',
 };
 const BUILTIN_SIGNAL_NAMES = new Set(Object.keys(BUILTIN_SIGNAL_OPTION_KEYS));
 /**
@@ -114,7 +114,7 @@ export class SystemStatus {
             memInfo: { isOverloaded: false, limitRatio: 0, actualRatio: 0 },
             eventLoopInfo: { isOverloaded: false, limitRatio: 0, actualRatio: 0 },
             cpuInfo: { isOverloaded: false, limitRatio: 0, actualRatio: 0 },
-            clientInfo: { isOverloaded: false, limitRatio: 0, actualRatio: 0 },
+            storageBackendInfo: { isOverloaded: false, limitRatio: 0, actualRatio: 0 },
         };
         let loadSignalInfo;
         for (const signal of this.#signals) {

package/configuration.d.ts

@@ -6,47 +6,47 @@ export interface ConfigField<T extends z.ZodType = z.ZodType> {
 }
 export declare function field<T extends z.ZodType>(schema: T, envVar?: string | string[]): ConfigField<T>;
 /** Zod preprocessor treating `'0'` and `'false'` as falsy. */
-export declare const coerceBoolean: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodBoolean>;
-export declare const coerceNumber: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNumber>;
+export declare const coerceBoolean: z.ZodPreprocess<z.ZodBoolean>;
+export declare const coerceNumber: z.ZodPreprocess<z.ZodNumber>;
 export declare const crawleeConfigFields: {
     /** @default 'default' */
     defaultDatasetId: ConfigField<z.ZodDefault<z.ZodString>>;
     /** @default true */
-    purgeOnStart: ConfigField<z.ZodDefault<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodBoolean>>>;
+    purgeOnStart: ConfigField<z.ZodDefault<z.ZodPreprocess<z.ZodBoolean>>>;
     /** @default 'default' */
     defaultKeyValueStoreId: ConfigField<z.ZodDefault<z.ZodString>>;
     /** @default 'default' */
     defaultRequestQueueId: ConfigField<z.ZodDefault<z.ZodString>>;
     /** @default 0.95 */
-    maxUsedCpuRatio: ConfigField<z.ZodDefault<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNumber>>>;
+    maxUsedCpuRatio: ConfigField<z.ZodDefault<z.ZodPreprocess<z.ZodNumber>>>;
     /** @default 0.25 */
-    availableMemoryRatio: ConfigField<z.ZodDefault<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNumber>>>;
-    memoryMbytes: ConfigField<z.ZodOptional<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNumber>>>;
+    availableMemoryRatio: ConfigField<z.ZodDefault<z.ZodPreprocess<z.ZodNumber>>>;
+    memoryMbytes: ConfigField<z.ZodOptional<z.ZodPreprocess<z.ZodNumber>>>;
     /** @default 60_000 */
-    persistStateIntervalMillis: ConfigField<z.ZodDefault<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNumber>>>;
+    persistStateIntervalMillis: ConfigField<z.ZodDefault<z.ZodPreprocess<z.ZodNumber>>>;
     /**
      * Internal safety-net timeout for a single request, in milliseconds. When unset the crawler derives it from
      * the request handler timeout (twice it, and never below 5 minutes).
      */
-    internalTimeoutMillis: ConfigField<z.ZodOptional<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNumber>>>;
+    internalTimeoutMillis: ConfigField<z.ZodOptional<z.ZodPreprocess<z.ZodNumber>>>;
     /** @default 1_000 */
-    systemInfoIntervalMillis: ConfigField<z.ZodDefault<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNumber>>>;
+    systemInfoIntervalMillis: ConfigField<z.ZodDefault<z.ZodPreprocess<z.ZodNumber>>>;
     /** @default 'INPUT' */
     inputKey: ConfigField<z.ZodDefault<z.ZodString>>;
     /** @default true */
-    headless: ConfigField<z.ZodDefault<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodBoolean>>>;
+    headless: ConfigField<z.ZodDefault<z.ZodPreprocess<z.ZodBoolean>>>;
     /** @default false */
-    xvfb: ConfigField<z.ZodDefault<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodBoolean>>>;
+    xvfb: ConfigField<z.ZodDefault<z.ZodPreprocess<z.ZodBoolean>>>;
     chromeExecutablePath: ConfigField<z.ZodOptional<z.ZodString>>;
     defaultBrowserPath: ConfigField<z.ZodOptional<z.ZodString>>;
     /** @default false */
-    disableBrowserSandbox: ConfigField<z.ZodDefault<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodBoolean>>>;
-    logLevel: ConfigField<z.ZodOptional<z.ZodPipe<z.ZodTransform<{} | null | undefined, unknown>, z.ZodEnum<typeof LogLevel>>>>;
+    disableBrowserSandbox: ConfigField<z.ZodDefault<z.ZodPreprocess<z.ZodBoolean>>>;
+    logLevel: ConfigField<z.ZodOptional<z.ZodPreprocess<z.ZodEnum<typeof LogLevel>>>>;
     /** @default true */
-    persistStorage: ConfigField<z.ZodDefault<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodBoolean>>>;
+    persistStorage: ConfigField<z.ZodDefault<z.ZodPreprocess<z.ZodBoolean>>>;
     /** @default './storage' */
     storageDir: ConfigField<z.ZodDefault<z.ZodString>>;
-    containerized: ConfigField<z.ZodOptional<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodBoolean>>>;
+    containerized: ConfigField<z.ZodOptional<z.ZodPreprocess<z.ZodBoolean>>>;
 };
 export type FieldsInput<F extends Record<string, ConfigField>> = {
     [K in keyof F]?: z.output<F[K]['schema']>;

package/configuration.js

@@ -36,7 +36,7 @@ const logLevelSchema = z.preprocess((val) => {
     if (key in LogLevel)
         return LogLevel[key];
     return val;
-}, z.nativeEnum(LogLevel));
+}, z.enum(LogLevel));
 // --- Crawlee config field definitions ---
 export const crawleeConfigFields = {
     /** @default 'default' */
@@ -196,8 +196,8 @@ export class Configuration {
                 continue;
             }
             // 4. Schema default (by parsing undefined through the schema)
-            const result = fieldDef.schema.safeParse(undefined);
-            values[key] = result.success ? result.data : undefined;
+            const parsed = fieldDef.schema.safeParse(undefined);
+            values[key] = parsed.success ? parsed.data : undefined;
         }
         return values;
     }