@crawlee/core 4.0.0-beta.71 → 4.0.0-beta.72

package/memory-storage/utils.d.ts

@@ -1,4 +1,10 @@
 import { isBuffer, isStream, toBuffer } from '@crawlee/utils';
+/**
+ * Resolves `segment` against `baseDirectory` and ensures the result stays within `baseDirectory`.
+ * Storage names and record keys are used as filesystem path components, so a value containing `..`
+ * or an absolute path could otherwise escape the intended directory.
+ */
+export declare function resolveWithinDirectory(baseDirectory: string, segment: string): string;
 /**
  * Removes all properties with a null value
  * from the provided object.
@@ -9,4 +15,3 @@ export declare function purgeNullsFromObject<T>(object: T): T;
  */
 export declare function uniqueKeyToRequestId(uniqueKey: string): string;
 export { isBuffer, isStream, toBuffer };
-//# sourceMappingURL=utils.d.ts.map

package/memory-storage/utils.js

@@ -1,6 +1,21 @@
 import { createHash } from 'node:crypto';
+import { resolve, sep } from 'node:path';
 import { isBuffer, isStream, toBuffer } from '@crawlee/utils';
 import { REQUEST_ID_LENGTH } from './consts.js';
+/**
+ * Resolves `segment` against `baseDirectory` and ensures the result stays within `baseDirectory`.
+ * Storage names and record keys are used as filesystem path components, so a value containing `..`
+ * or an absolute path could otherwise escape the intended directory.
+ */
+export function resolveWithinDirectory(baseDirectory, segment) {
+    const base = resolve(baseDirectory);
+    const resolved = resolve(base, segment);
+    if (resolved !== base && !resolved.startsWith(`${base}${sep}`)) {
+        throw new Error(`"${segment}" is not allowed because it would resolve outside of the storage directory. ` +
+            `Storage names and record keys must not contain path traversal segments ("..") or absolute paths.`);
+    }
+    return resolved;
+}
 /**
  * Removes all properties with a null value
  * from the provided object.
@@ -25,4 +40,3 @@ export function uniqueKeyToRequestId(uniqueKey) {
     return str.length > REQUEST_ID_LENGTH ? str.slice(0, REQUEST_ID_LENGTH) : str;
 }
 export { isBuffer, isStream, toBuffer };
-//# sourceMappingURL=utils.js.map

package/package.json

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

package/proxy_configuration.d.ts

@@ -109,4 +109,3 @@ export declare class ProxyConfiguration {
     protected _throwNoOptionsProvided(): never;
 }
 export {};
-//# sourceMappingURL=proxy_configuration.d.ts.map

package/proxy_configuration.js

@@ -132,4 +132,3 @@ export class ProxyConfiguration {
         throw new Error('One of "options.proxyUrls" or "options.newUrlFunction" needs to be provided.');
     }
 }
-//# sourceMappingURL=proxy_configuration.js.map

package/recoverable_state.d.ts

@@ -118,4 +118,3 @@ export declare class RecoverableState<TStateModel = Record<string, unknown>> {
      */
     private loadSavedState;
 }
-//# sourceMappingURL=recoverable_state.d.ts.map

package/recoverable_state.js

@@ -139,4 +139,3 @@ export class RecoverableState {
         }
     }
 }
-//# sourceMappingURL=recoverable_state.js.map

package/request.d.ts

@@ -310,4 +310,3 @@ export interface InternalSource {
     regex?: RegExp;
 }
 export { CrawleeRequest as Request };
-//# sourceMappingURL=request.d.ts.map

package/request.js

@@ -417,4 +417,3 @@ class CrawleeRequest {
     }
 }
 export { CrawleeRequest as Request };
-//# sourceMappingURL=request.js.map

package/router.d.ts

@@ -1,14 +1,57 @@
 import type { Dictionary } from '@crawlee/types';
+import type { StandardSchemaV1 } from '@standard-schema/spec';
 import type { CrawlingContext, LoadedRequest, RestrictedCrawlingContext } from './crawlers/crawler_commons.js';
 import type { Request } from './request.js';
 import type { Awaitable } from './typedefs.js';
-export interface RouterHandler<Context extends Omit<RestrictedCrawlingContext, 'enqueueLinks'> = CrawlingContext> extends Router<Context> {
+/**
+ * The key of the default route — the fallback handler registered via {@link Router.addDefaultHandler}.
+ * Use it in a {@link RouteSchemas} map to register a schema that validates the `userData` of every request
+ * that falls through to the default handler (i.e. whose label has no route of its own).
+ */
+export declare const defaultRoute: unique symbol;
+/**
+ * The crawling context received by a route handler, with `request.userData` narrowed to `UserData`.
+ */
+export type RouterHandlerContext<Context, UserData extends Dictionary> = Omit<Context, 'request'> & {
+    request: LoadedRequest<Request<UserData>>;
+};
+/**
+ * A map of request labels to a [Standard Schema](https://standardschema.dev) (Zod, Valibot, ArkType, …)
+ * validating that label's `request.userData`. Pass it to {@link Router.create} or a `createXRouter`
+ * factory to derive the per-label `request.userData` types *and* validate them at runtime. The optional
+ * {@link defaultRoute} key registers a schema for requests handled by the default route.
+ */
+export type RouteSchemas = Record<string, StandardSchemaV1> & {
+    [defaultRoute]?: StandardSchemaV1;
+};
+/**
+ * Derives a route map (label → `userData` type) from a {@link RouteSchemas} map by inferring each
+ * schema's output type. Outputs that are not object-shaped fall back to a plain {@link Dictionary}. The
+ * {@link defaultRoute} schema drives runtime validation only, so it is excluded from the typed route map.
+ */
+export type RoutesFromSchemas<Schemas extends RouteSchemas> = {
+    [Label in Extract<keyof Schemas, string>]: StandardSchemaV1.InferOutput<Schemas[Label]> extends Dictionary ? StandardSchemaV1.InferOutput<Schemas[Label]> : Dictionary;
+};
+/**
+ * Validates `userData` against a {@link RouteSchemas|Standard Schema}, returning the parsed (and coerced)
+ * value. Throws a {@link RequestValidationError} when validation fails.
+ * @internal
+ */
+export declare function validateUserData(label: string | symbol, schema: StandardSchemaV1, userData: unknown): Promise<Dictionary>;
+/**
+ * The set of labels accepted by {@link Router.addHandler}. When the router declares a concrete
+ * route map (e.g. `{ PRODUCT: ...; CATEGORY: ... }`), only those labels (plus symbols) are
+ * allowed — unknown labels become a compile-time error. When the map is left open (the default
+ * `Record<string, ...>`), any string or symbol label is accepted, preserving the original behaviour.
+ */
+export type RouterLabel<Routes extends Record<keyof Routes, Dictionary>> = string extends keyof Routes ? string | symbol : (keyof Routes & string) | symbol;
+export interface RouterHandler<Context extends Omit<RestrictedCrawlingContext, 'enqueueLinks'> = CrawlingContext, Routes extends Record<keyof Routes, Dictionary> = Record<string, GetUserDataFromRequest<Context['request']>>> extends Router<Context, Routes> {
     (ctx: Context): Awaitable<void>;
 }
 export type GetUserDataFromRequest<T> = T extends Request<infer Y> ? Y : never;
-export type RouterRoutes<Context, UserData extends Dictionary> = {
-    [label in string | symbol]: (ctx: Omit<Context, 'request'> & {
-        request: Request<UserData>;
+export type RouterRoutes<Context, Routes extends Record<keyof Routes, Dictionary>> = {
+    [Label in keyof Routes]: (ctx: Omit<Context, 'request'> & {
+        request: Request<Routes[Label]>;
     }) => Awaitable<void>;
 };
 /**
@@ -75,9 +118,51 @@ export type RouterRoutes<Context, UserData extends Dictionary> = {
  *    ctx.log.info('...');
  * });
  * ```
+ *
+ * To get `request.userData` typed per label, declare a route map and pass it as the second
+ * type argument. The label passed to {@link Router.addHandler} then drives the type of
+ * `request.userData`, and unknown labels are rejected at compile time:
+ *
+ * ```ts
+ * import { createCheerioRouter, CheerioCrawlingContext } from 'crawlee';
+ *
+ * interface Routes {
+ *     PRODUCT: { sku: string; price: number };
+ *     CATEGORY: { categoryId: string };
+ * }
+ *
+ * const router = createCheerioRouter<CheerioCrawlingContext, Routes>();
+ *
+ * router.addHandler('PRODUCT', async ({ request }) => {
+ *     request.userData.sku;   // string
+ *     request.userData.price; // number
+ * });
+ *
+ * router.addHandler('TYPO', async () => {}); // compile error: not a known label
+ * ```
+ *
+ * Passing a [Standard Schema](https://standardschema.dev) per label instead of a plain type both infers the
+ * `request.userData` types *and* validates them at runtime — when the request is handled, and when it is
+ * added to the crawler (`crawler.addRequests`, `context.addRequests`, `enqueueLinks`). A failing request
+ * throws a {@link RequestValidationError}.
+ *
+ * ```ts
+ * import { z } from 'zod';
+ * import { createCheerioRouter } from 'crawlee';
+ *
+ * const router = createCheerioRouter({
+ *     PRODUCT: z.object({ sku: z.string(), price: z.number() }),
+ *     CATEGORY: z.object({ categoryId: z.string() }),
+ * });
+ *
+ * router.addHandler('PRODUCT', async ({ request }) => {
+ *     request.userData.price; // number, inferred from the schema and validated at runtime
+ * });
+ * ```
  */
-export declare class Router<Context extends Omit<RestrictedCrawlingContext, 'enqueueLinks'>> {
+export declare class Router<Context extends Omit<RestrictedCrawlingContext, 'enqueueLinks'>, Routes extends Record<keyof Routes, Dictionary> = Record<string, GetUserDataFromRequest<Context['request']>>> {
     private readonly routes;
+    private readonly schemas;
     private readonly middlewares;
     /**
      * use Router.create() instead!
@@ -85,17 +170,28 @@ export declare class Router<Context extends Omit<RestrictedCrawlingContext, 'enq
      */
     protected constructor();
     /**
-     * Registers new route handler for given label.
+     * Registers new route handler for given label. When the router declares a route map, the
+     * `label` is restricted to the declared labels and `request.userData` is typed accordingly.
+     */
+    addHandler<Label extends keyof Routes & string>(label: Label, handler: (ctx: RouterHandlerContext<Context, Routes[Label]>) => Awaitable<void>): void;
+    /**
+     * Registers new route handler for given label, explicitly typing `request.userData` via the
+     * `UserData` type argument. Useful when the router has no declared route map (the open default)
+     * and you want to type a single handler, or to register a handler under a `symbol` label.
      */
-    addHandler<UserData extends Dictionary = GetUserDataFromRequest<Context['request']>>(label: string | symbol, handler: (ctx: Omit<Context, 'request'> & {
-        request: LoadedRequest<Request<UserData>>;
-    }) => Awaitable<void>): void;
+    addHandler<UserData extends Dictionary = GetUserDataFromRequest<Context['request']>>(label: RouterLabel<Routes>, handler: (ctx: RouterHandlerContext<Context, UserData>) => Awaitable<void>): void;
     /**
-     * Registers default route handler.
+     * Registers default route handler. As a fallback it can receive any request (including labels not
+     * declared in the route map), so `request.userData` defaults to the context's `userData` type
+     * (loosely typed by default). Pass an explicit `UserData` type argument to narrow it.
      */
-    addDefaultHandler<UserData extends Dictionary = GetUserDataFromRequest<Context['request']>>(handler: (ctx: Omit<Context, 'request'> & {
-        request: LoadedRequest<Request<UserData>>;
-    }) => Awaitable<void>): void;
+    addDefaultHandler<UserData extends Dictionary = GetUserDataFromRequest<Context['request']>>(handler: (ctx: RouterHandlerContext<Context, UserData>) => Awaitable<void>): void;
+    /**
+     * Returns the {@link RouteSchemas|Standard Schema} registered for a label, if any. Used by the crawler
+     * to validate `request.userData` when requests are added.
+     * @internal
+     */
+    getSchema(label?: string | symbol): StandardSchemaV1 | undefined;
     /**
      * Registers a middleware that will be fired before the matching route handler.
      * Multiple middlewares can be registered, they will be fired in the same order.
@@ -105,6 +201,11 @@ export declare class Router<Context extends Omit<RestrictedCrawlingContext, 'enq
      * Returns route handler for given label. If no label is provided, the default request handler will be returned.
      */
     getHandler(label?: string | symbol): (ctx: Context) => Awaitable<void>;
+    /**
+     * Validates `request.userData` against the schema registered for its label (if any), replacing it with
+     * the parsed value. Throws a {@link RequestValidationError} when validation fails.
+     */
+    private validateRequest;
     /**
      * Throws when the label already exists in our registry.
      */
@@ -129,6 +230,7 @@ export declare class Router<Context extends Omit<RestrictedCrawlingContext, 'enq
      * await crawler.run();
      * ```
      */
-    static create<Context extends Omit<RestrictedCrawlingContext, 'enqueueLinks'> = CrawlingContext, UserData extends Dictionary = GetUserDataFromRequest<Context['request']>>(routes?: RouterRoutes<Context, UserData>): RouterHandler<Context>;
+    static create<Context extends Omit<RestrictedCrawlingContext, 'enqueueLinks'> = CrawlingContext, Routes extends Record<keyof Routes, Dictionary> = Record<string, GetUserDataFromRequest<Context['request']>>>(routes?: RouterRoutes<Context, Routes>): RouterHandler<Context, Routes>;
+    static create<Context extends Omit<RestrictedCrawlingContext, 'enqueueLinks'> = CrawlingContext, UserData extends Dictionary = GetUserDataFromRequest<Context['request']>>(routes?: RouterRoutes<Context, Record<string, UserData>>): RouterHandler<Context, Record<string, UserData>>;
+    static create<Context extends Omit<RestrictedCrawlingContext, 'enqueueLinks'> = CrawlingContext, const Schemas extends RouteSchemas = RouteSchemas>(schemas: Schemas): RouterHandler<Context, RoutesFromSchemas<Schemas>>;
 }
-//# sourceMappingURL=router.d.ts.map

package/router.js

@@ -1,5 +1,39 @@
-import { MissingRouteError } from './errors.js';
-const defaultRoute = Symbol('default-route');
+import { MissingRouteError, RequestValidationError } from './errors.js';
+/**
+ * The key of the default route — the fallback handler registered via {@link Router.addDefaultHandler}.
+ * Use it in a {@link RouteSchemas} map to register a schema that validates the `userData` of every request
+ * that falls through to the default handler (i.e. whose label has no route of its own).
+ */
+export const defaultRoute = Symbol('default-route');
+/** Whether a validation issue points at the top-level `label` key. */
+function isLabelIssue(issue) {
+    if (issue.path?.length !== 1) {
+        return false;
+    }
+    const [segment] = issue.path;
+    return (typeof segment === 'object' ? segment.key : segment) === 'label';
+}
+/**
+ * Validates `userData` against a {@link RouteSchemas|Standard Schema}, returning the parsed (and coerced)
+ * value. Throws a {@link RequestValidationError} when validation fails.
+ * @internal
+ */
+export async function validateUserData(label, schema, userData) {
+    const { label: _label, ...rest } = (userData ?? {});
+    // `label` is a Crawlee-managed key that lives inside `userData`, so validating it is opt-in: we validate
+    // without it first, letting schemas that don't describe it pass (including `.strict()` ones). A schema that
+    // *does* declare `label` reports an issue for the now-missing key — so we re-validate with it included,
+    // honouring the declaration. Unlike `userData.__crawlee`, `label` is enumerable, so schemas do see it.
+    let result = await schema['~standard'].validate(rest);
+    if (result.issues?.some(isLabelIssue)) {
+        result = await schema['~standard'].validate({ ...rest, label });
+    }
+    if (result.issues) {
+        throw new RequestValidationError(label, result.issues);
+    }
+    // Restore the label so it survives schemas that strip undeclared keys.
+    return { ...result.value, label };
+}
 /**
  * Simple router that works based on request labels. This instance can then serve as a `requestHandler` of your crawler.
  *
@@ -64,29 +98,90 @@ const defaultRoute = Symbol('default-route');
  *    ctx.log.info('...');
  * });
  * ```
+ *
+ * To get `request.userData` typed per label, declare a route map and pass it as the second
+ * type argument. The label passed to {@link Router.addHandler} then drives the type of
+ * `request.userData`, and unknown labels are rejected at compile time:
+ *
+ * ```ts
+ * import { createCheerioRouter, CheerioCrawlingContext } from 'crawlee';
+ *
+ * interface Routes {
+ *     PRODUCT: { sku: string; price: number };
+ *     CATEGORY: { categoryId: string };
+ * }
+ *
+ * const router = createCheerioRouter<CheerioCrawlingContext, Routes>();
+ *
+ * router.addHandler('PRODUCT', async ({ request }) => {
+ *     request.userData.sku;   // string
+ *     request.userData.price; // number
+ * });
+ *
+ * router.addHandler('TYPO', async () => {}); // compile error: not a known label
+ * ```
+ *
+ * Passing a [Standard Schema](https://standardschema.dev) per label instead of a plain type both infers the
+ * `request.userData` types *and* validates them at runtime — when the request is handled, and when it is
+ * added to the crawler (`crawler.addRequests`, `context.addRequests`, `enqueueLinks`). A failing request
+ * throws a {@link RequestValidationError}.
+ *
+ * ```ts
+ * import { z } from 'zod';
+ * import { createCheerioRouter } from 'crawlee';
+ *
+ * const router = createCheerioRouter({
+ *     PRODUCT: z.object({ sku: z.string(), price: z.number() }),
+ *     CATEGORY: z.object({ categoryId: z.string() }),
+ * });
+ *
+ * router.addHandler('PRODUCT', async ({ request }) => {
+ *     request.userData.price; // number, inferred from the schema and validated at runtime
+ * });
+ * ```
  */
 export class Router {
     routes = new Map();
+    schemas = new Map();
     middlewares = [];
     /**
      * use Router.create() instead!
      * @ignore
      */
     constructor() { }
-    /**
-     * Registers new route handler for given label.
-     */
     addHandler(label, handler) {
         this.validate(label);
         this.routes.set(label, handler);
     }
     /**
-     * Registers default route handler.
+     * Registers default route handler. As a fallback it can receive any request (including labels not
+     * declared in the route map), so `request.userData` defaults to the context's `userData` type
+     * (loosely typed by default). Pass an explicit `UserData` type argument to narrow it.
      */
     addDefaultHandler(handler) {
         this.validate(defaultRoute);
         this.routes.set(defaultRoute, handler);
     }
+    /**
+     * Returns the {@link RouteSchemas|Standard Schema} registered for a label, if any. Used by the crawler
+     * to validate `request.userData` when requests are added.
+     * @internal
+     */
+    getSchema(label) {
+        if (label != null) {
+            const schema = this.schemas.get(label);
+            if (schema) {
+                return schema;
+            }
+            // A label with its own route is fully specified; don't fall back to the default-route schema.
+            if (this.routes.has(label)) {
+                return undefined;
+            }
+        }
+        // Requests with no route of their own fall through to the default handler, so validate their
+        // `userData` against the default-route schema, if one was registered.
+        return this.schemas.get(defaultRoute);
+    }
     /**
      * Registers a middleware that will be fired before the matching route handler.
      * Multiple middlewares can be registered, they will be fired in the same order.
@@ -108,6 +203,17 @@ export class Router {
             ' You must set up a route for this label or a default route.' +
             ' Use `requestHandler`, `router.addHandler` or `router.addDefaultHandler`.');
     }
+    /**
+     * Validates `request.userData` against the schema registered for its label (if any), replacing it with
+     * the parsed value. Throws a {@link RequestValidationError} when validation fails.
+     */
+    async validateRequest(context) {
+        const label = context.request.label;
+        const schema = this.getSchema(label);
+        if (schema) {
+            context.request.userData = (await validateUserData(label, schema, context.request.userData));
+        }
+    }
     /**
      * Throws when the label already exists in our registry.
      */
@@ -119,39 +225,28 @@ export class Router {
             throw new Error(message);
         }
     }
-    /**
-     * Creates new router instance. This instance can then serve as a `requestHandler` of your crawler.
-     *
-     * ```ts
-     * import { Router, CheerioCrawler, CheerioCrawlingContext } from 'crawlee';
-     *
-     * const router = Router.create<CheerioCrawlingContext>();
-     * router.addHandler('label-a', async (ctx) => {
-     *    ctx.log.info('...');
-     * });
-     * router.addDefaultHandler(async (ctx) => {
-     *    ctx.log.info('...');
-     * });
-     *
-     * const crawler = new CheerioCrawler({
-     *     requestHandler: router,
-     * });
-     * await crawler.run();
-     * ```
-     */
-    static create(routes) {
+    static create(routesOrSchemas) {
         const router = new Router();
         const obj = Object.create(Function.prototype);
         obj.addHandler = router.addHandler.bind(router);
         obj.addDefaultHandler = router.addDefaultHandler.bind(router);
+        obj.getSchema = router.getSchema.bind(router);
         obj.getHandler = router.getHandler.bind(router);
         obj.use = router.use.bind(router);
-        for (const [label, handler] of Object.entries(routes ?? {})) {
-            router.addHandler(label, handler);
+        // `Reflect.ownKeys` (unlike `Object.entries`) also yields the `defaultRoute` symbol key.
+        for (const label of Reflect.ownKeys(routesOrSchemas ?? {})) {
+            const value = routesOrSchemas[label];
+            if (typeof value === 'function') {
+                router.addHandler(label, value);
+            }
+            else {
+                router.schemas.set(label, value);
+            }
         }
         const func = async function (context) {
             const { url, loadedUrl, label } = context.request;
             context.log.debug('Page opened.', { label, url: loadedUrl ?? url });
+            await router.validateRequest(context);
             for (const middleware of router.middlewares) {
                 await middleware(context);
             }
@@ -161,4 +256,3 @@ export class Router {
         return func;
     }
 }
-//# sourceMappingURL=router.js.map

package/serialization.d.ts

@@ -29,4 +29,3 @@ export declare function deserializeArray<T extends string | Buffer>(compressedDa
  * @internal
  */
 export declare function createDeserialize(compressedData: Buffer | Uint8Array): Readable;
-//# sourceMappingURL=serialization.d.ts.map

package/serialization.js

@@ -119,4 +119,3 @@ function pluckValue(streamArray) {
     streamArray.push = (obj) => realPush(obj?.value ?? null);
     return streamArray;
 }
-//# sourceMappingURL=serialization.js.map

package/service_locator.d.ts

@@ -154,4 +154,3 @@ export declare function bindMethodsToServiceLocator(serviceLocator: ServiceLocat
 };
 export declare const serviceLocator: ServiceLocatorInterface;
 export {};
-//# sourceMappingURL=service_locator.d.ts.map

package/service_locator.js

@@ -236,4 +236,3 @@ export const serviceLocator = new Proxy({}, {
         throw new TypeError(`Cannot set property '${String(prop)}' on serviceLocator directly. Use the setter methods (e.g. setConfiguration(), setStorageBackend()) instead.`);
     },
 });
-//# sourceMappingURL=service_locator.js.map

package/session_pool/consts.d.ts

@@ -1,4 +1,3 @@
 export declare const BLOCKED_STATUS_CODES: number[];
 export declare const PERSIST_STATE_KEY = "CRAWLEE_SESSION_POOL_STATE";
 export declare const MAX_POOL_SIZE = 1000;
-//# sourceMappingURL=consts.d.ts.map

package/session_pool/consts.js

@@ -1,4 +1,3 @@
 export const BLOCKED_STATUS_CODES = [401, 403, 429];
 export const PERSIST_STATE_KEY = 'CRAWLEE_SESSION_POOL_STATE';
 export const MAX_POOL_SIZE = 1000;
-//# sourceMappingURL=consts.js.map

package/session_pool/errors.d.ts

@@ -5,4 +5,3 @@ export declare class CookieParseError extends Error {
     readonly cookieHeaderString: unknown;
     constructor(cookieHeaderString: unknown);
 }
-//# sourceMappingURL=errors.d.ts.map

package/session_pool/errors.js

@@ -9,4 +9,3 @@ export class CookieParseError extends Error {
         Error.captureStackTrace(this, CookieParseError);
     }
 }
-//# sourceMappingURL=errors.js.map

package/session_pool/fingerprint.d.ts

@@ -7,4 +7,3 @@ import type { SessionFingerprint } from '@crawlee/types';
  * `fingerprint` in `sessionOptions`.
  */
 export declare function createDefaultSessionFingerprint(): SessionFingerprint;
-//# sourceMappingURL=fingerprint.d.ts.map

package/session_pool/fingerprint.js

@@ -28,4 +28,3 @@ const PROFILES_BY_PLATFORM = [
 export function createDefaultSessionFingerprint() {
     return { ...PROFILES_BY_PLATFORM[Math.floor(Math.random() * PROFILES_BY_PLATFORM.length)] };
 }
-//# sourceMappingURL=fingerprint.js.map

package/session_pool/index.d.ts

@@ -2,4 +2,3 @@ export * from './errors.js';
 export * from './session.js';
 export * from './session_pool.js';
 export * from './consts.js';
-//# sourceMappingURL=index.d.ts.map

package/session_pool/index.js

@@ -2,4 +2,3 @@ export * from './errors.js';
 export * from './session.js';
 export * from './session_pool.js';
 export * from './consts.js';
-//# sourceMappingURL=index.js.map

package/session_pool/session.d.ts

@@ -159,4 +159,3 @@ export declare class Session implements ISession {
      */
     protected _maybeSelfRetire(): void;
 }
-//# sourceMappingURL=session.d.ts.map

package/session_pool/session.js

@@ -216,4 +216,3 @@ export class Session {
         }
     }
 }
-//# sourceMappingURL=session.js.map

package/session_pool/session_pool.d.ts

@@ -248,4 +248,3 @@ export declare class SessionPool implements ISessionPool {
     protected _maybeLoadSessionPool(): Promise<void>;
 }
 export {};
-//# sourceMappingURL=session_pool.d.ts.map

package/session_pool/session_pool.js

@@ -384,4 +384,3 @@ export class SessionPool {
         this.log.debug(`${this.sessions.length} active sessions loaded from KeyValueStore`);
     }
 }
-//# sourceMappingURL=session_pool.js.map

package/storages/access_checking.d.ts

@@ -10,4 +10,3 @@ export declare const checkStorageAccess: () => void | undefined;
  * @param callback The code that should be invoked with the `checkFunction` setting
  */
 export declare const withCheckedStorageAccess: <T>(checkFunction: () => void, callback: () => Awaitable<T>) => Promise<T>;
-//# sourceMappingURL=access_checking.d.ts.map

package/storages/access_checking.js

@@ -15,4 +15,3 @@ export const checkStorageAccess = () => {
  * @param callback The code that should be invoked with the `checkFunction` setting
  */
 export const withCheckedStorageAccess = async (checkFunction, callback) => storage.run({ checkFunction }, callback);
-//# sourceMappingURL=access_checking.js.map

package/storages/dataset.d.ts

@@ -295,7 +295,7 @@ export declare class Dataset<Data extends Dictionary = Dictionary> {
      * If the dataset is empty, reduce will return undefined.
      *
      * @param iteratee
-     * @param memo Unset parameter, neccesary to be able to pass options
+     * @param memo Unset parameter, necessary to be able to pass options
      * @param [options] An object containing extra options for `reduce()`
      */
     reduce(iteratee: DatasetReducer<Data, Data>, memo: undefined, options: DatasetIteratorOptions): Promise<Data | undefined>;
@@ -478,4 +478,3 @@ export interface DatasetContent<Data> {
     /** Should the results be in descending order. */
     desc?: boolean;
 }
-//# sourceMappingURL=dataset.d.ts.map

package/storages/dataset.js

@@ -504,4 +504,3 @@ export class Dataset {
         return dataset.getData(options);
     }
 }
-//# sourceMappingURL=dataset.js.map

package/storages/index.d.ts

@@ -11,4 +11,3 @@ export * from './utils.js';
 export * from './access_checking.js';
 export * from './sitemap_request_loader.js';
 export * from './request_manager_tandem.js';
-//# sourceMappingURL=index.d.ts.map

package/storages/index.js

@@ -9,4 +9,3 @@ export * from './utils.js';
 export * from './access_checking.js';
 export * from './sitemap_request_loader.js';
 export * from './request_manager_tandem.js';
-//# sourceMappingURL=index.js.map

package/storages/key_value_store.d.ts

@@ -533,4 +533,3 @@ export interface KeyValueStoreIteratorOptions {
      */
     prefix?: string;
 }
-//# sourceMappingURL=key_value_store.d.ts.map