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

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

package/configuration.js

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

package/crawlers/context_pipeline.js

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

package/crawlers/crawler_commons.d.ts

@@ -1,13 +1,12 @@
 import type { Dictionary, HttpRequestOptions, ISession, ProxyInfo, SendRequestOptions } from '@crawlee/types';
-import type { ReadonlyDeep, SetRequired } from 'type-fest';
-import type { Configuration } from '../configuration.js';
-import type { EnqueueLinksOptions } from '../enqueue_links/enqueue_links.js';
+import type { ReadonlyDeep } from 'type-fest';
+import type { EnqueueUrlsOptions } from '../enqueue_links/enqueue_links.js';
 import type { CrawleeLogger } from '../log.js';
 import type { Request, RequestOptions, Source } from '../request.js';
 import type { StorageIdentifier } from '../storages/storage_instance_manager.js';
 import type { Dataset } from '../storages/dataset.js';
-import { KeyValueStore, type RecordOptions } from '../storages/key_value_store.js';
-import type { RequestQueueOperationOptions } from '../storages/request_queue.js';
+import type { KeyValueStore } from '../storages/key_value_store.js';
+import type { AddRequestsBatchedResult } from '../storages/request_queue.js';
 /** @internal */
 export type IsAny<T> = 0 extends 1 & T ? true : false;
 /**
@@ -38,7 +37,7 @@ export type TypedRequestsLike<Routes extends Record<keyof Routes, Dictionary>> =
  * The label-aware `addRequests` method signature exposed on a request handler's context when the crawler is
  * bound to a typed router. Mirrors {@link RestrictedCrawlingContext.addRequests} with typed sources.
  */
-export type TypedContextAddRequests<Routes extends Record<keyof Routes, Dictionary>> = (requestsLike: ReadonlyDeep<LabeledSource<Routes>[]>, options?: ReadonlyDeep<RequestQueueOperationOptions>) => Promise<void>;
+export type TypedContextAddRequests<Routes extends Record<keyof Routes, Dictionary>> = (requestsLike: ReadonlyDeep<LabeledSource<Routes>[]>, options?: ReadonlyDeep<EnqueueUrlsOptions>) => Promise<AddRequestsBatchedResult>;
 /**
  * An `enqueueLinks`-options object with its `label`/`userData` retyped according to a router's route map: a
  * declared `label` requires the matching `userData` shape (unknown labels are rejected), while unlabeled
@@ -88,37 +87,15 @@ export interface RestrictedCrawlingContext<UserData extends Dictionary = Diction
      */
     pushData(data: ReadonlyDeep<Parameters<Dataset['pushData']>[0]>, datasetIdentifier?: string | StorageIdentifier): Promise<void>;
     /**
-     * This function automatically finds and enqueues links from the current page, adding them to the {@link RequestQueue}
-     * currently used by the crawler.
+     * Add requests directly to the request queue currently used by the crawler.
      *
-     * Optionally, the function allows you to filter the target links' URLs using an array of globs or regular expressions
-     * and override settings of the enqueued {@link Request} objects.
-     *
-     * Check out the [Crawl a website with relative links](https://crawlee.dev/js/docs/examples/crawl-relative-links) example
-     * for more details regarding its usage.
-     *
-     * **Example usage**
-     *
-     * ```ts
-     * async requestHandler({ enqueueLinks }) {
-     *     await enqueueLinks({
-     *       globs: [
-     *           'https://www.example.com/handbags/*',
-     *       ],
-     *     });
-     * },
-     * ```
-     *
-     * @param [options] All `enqueueLinks()` parameters are passed via an options object.
-     */
-    enqueueLinks: (options: ReadonlyDeep<Omit<SetRequired<EnqueueLinksOptions, 'urls'>, 'requestManager' | 'robotsTxtFile'>>) => Promise<unknown>;
-    /**
-     * Add requests directly to the request queue.
+     * Optionally, the function allows you to filter the target URLs using an array of glob or regexp patterns,
+     * the same way {@link CrawlingContext.enqueueLinks|`enqueueLinks`} does for extracted links.
      *
      * @param requests The requests to add
      * @param options Options for the request queue
      */
-    addRequests: (requestsLike: ReadonlyDeep<(string | Source)[]>, options?: ReadonlyDeep<RequestQueueOperationOptions>) => Promise<void>;
+    addRequests: (requestsLike: ReadonlyDeep<(string | Source)[]>, options?: ReadonlyDeep<EnqueueUrlsOptions>) => Promise<AddRequestsBatchedResult>;
     /**
      * Returns the state - a piece of mutable persistent data shared across all the request handler runs.
      */
@@ -133,32 +110,6 @@ export interface RestrictedCrawlingContext<UserData extends Dictionary = Diction
     log: CrawleeLogger;
 }
 export interface CrawlingContext<UserData extends Dictionary = Dictionary> extends RestrictedCrawlingContext<UserData> {
-    /**
-     * This function automatically finds and enqueues links from the current page, adding them to the {@link RequestQueue}
-     * currently used by the crawler.
-     *
-     * Optionally, the function allows you to filter the target links' URLs using an array of globs or regular expressions
-     * and override settings of the enqueued {@link Request} objects.
-     *
-     * Check out the [Crawl a website with relative links](https://crawlee.dev/js/docs/examples/crawl-relative-links) example
-     * for more details regarding its usage.
-     *
-     * **Example usage**
-     *
-     * ```ts
-     * async requestHandler({ enqueueLinks }) {
-     *     await enqueueLinks({
-     *       globs: [
-     *           'https://www.example.com/handbags/*',
-     *       ],
-     *     });
-     * },
-     * ```
-     *
-     * @param [options] All `enqueueLinks()` parameters are passed via an options object.
-     * @returns Promise that resolves to {@link BatchAddRequestsResult} object.
-     */
-    enqueueLinks(options: ReadonlyDeep<Omit<SetRequired<EnqueueLinksOptions, 'urls'>, 'requestManager' | 'robotsTxtFile'>> & Pick<EnqueueLinksOptions, 'requestManager' | 'robotsTxtFile'>): Promise<unknown>;
     /**
      * Fires HTTP request via the internal HTTP client, allowing to override the request options on the fly.
      *
@@ -178,6 +129,11 @@ export interface CrawlingContext<UserData extends Dictionary = Dictionary> exten
     sendRequest: (requestOverrides?: Partial<HttpRequestOptions>, optionsOverrides?: SendRequestOptions) => Promise<Response>;
     /**
      * Register a function to be called at the very end of the request handling process. This is useful for resources that should be accessible to error handlers, for instance.
+     *
+     * The callback runs *outside* the request's storage transaction, so storage writes made here are
+     * applied immediately and are **not** rolled back when the request fails. In
+     * {@link AdaptivePlaywrightCrawler} it also runs once per request handler attempt, so a write
+     * here can land more than once for a single request. Push results from the request handler itself.
      */
     registerDeferredCleanup(cleanup: () => Promise<unknown>): void;
     /**
@@ -200,58 +156,4 @@ export interface CrawlingContext<UserData extends Dictionary = Dictionary> exten
      */
     extendTimeout(secs: number): void;
 }
-/**
- * A partial implementation of {@link RestrictedCrawlingContext} that stores parameters of calls to context methods for later inspection.
- *
- * @experimental
- */
-export declare class RequestHandlerResult {
-    private configuration;
-    private crawleeStateKey;
-    private _keyValueStoreChanges;
-    private pushDataCalls;
-    private addRequestsCalls;
-    constructor(configuration: Configuration, crawleeStateKey: string);
-    /**
-     * A record of calls to {@link RestrictedCrawlingContext.pushData}, {@link RestrictedCrawlingContext.addRequests}, {@link RestrictedCrawlingContext.enqueueLinks} made by a request handler.
-     */
-    get calls(): ReadonlyDeep<{
-        pushData: Parameters<RestrictedCrawlingContext['pushData']>[];
-        addRequests: Parameters<RestrictedCrawlingContext['addRequests']>[];
-    }>;
-    /**
-     * A record of changes made to key-value stores by a request handler.
-     */
-    get keyValueStoreChanges(): ReadonlyDeep<Record<string, Record<string, {
-        changedValue: unknown;
-        options?: RecordOptions;
-    }>>>;
-    /**
-     * Items added to datasets by a request handler.
-     */
-    get datasetItems(): ReadonlyDeep<{
-        item: Dictionary;
-        datasetIdentifier?: string | StorageIdentifier;
-    }[]>;
-    /**
-     * URLs enqueued to the request queue by a request handler, either via {@link RestrictedCrawlingContext.addRequests} or {@link RestrictedCrawlingContext.enqueueLinks}
-     */
-    get enqueuedUrls(): ReadonlyDeep<{
-        url: string;
-        label?: string;
-    }[]>;
-    /**
-     * URL lists enqueued to the request queue by a request handler via {@link RestrictedCrawlingContext.addRequests} using the `requestsFromUrl` option.
-     */
-    get enqueuedUrlLists(): ReadonlyDeep<{
-        listUrl: string;
-        label?: string;
-    }[]>;
-    pushData: RestrictedCrawlingContext['pushData'];
-    addRequests: RestrictedCrawlingContext['addRequests'];
-    useState: RestrictedCrawlingContext['useState'];
-    getKeyValueStore: RestrictedCrawlingContext['getKeyValueStore'];
-    private getKeyValueStoreChangedValue;
-    private setKeyValueStoreChangedValue;
-}
 export {};

package/crawlers/crawler_commons.js

@@ -1,107 +1 @@
-import { KeyValueStore } from '../storages/key_value_store.js';
-/**
- * A partial implementation of {@link RestrictedCrawlingContext} that stores parameters of calls to context methods for later inspection.
- *
- * @experimental
- */
-export class RequestHandlerResult {
-    configuration;
-    crawleeStateKey;
-    _keyValueStoreChanges = {};
-    pushDataCalls = [];
-    addRequestsCalls = [];
-    constructor(configuration, crawleeStateKey) {
-        this.configuration = configuration;
-        this.crawleeStateKey = crawleeStateKey;
-    }
-    /**
-     * A record of calls to {@link RestrictedCrawlingContext.pushData}, {@link RestrictedCrawlingContext.addRequests}, {@link RestrictedCrawlingContext.enqueueLinks} made by a request handler.
-     */
-    get calls() {
-        return {
-            pushData: this.pushDataCalls,
-            addRequests: this.addRequestsCalls,
-        };
-    }
-    /**
-     * A record of changes made to key-value stores by a request handler.
-     */
-    get keyValueStoreChanges() {
-        return this._keyValueStoreChanges;
-    }
-    /**
-     * Items added to datasets by a request handler.
-     */
-    get datasetItems() {
-        return this.pushDataCalls.flatMap(([data, datasetIdentifier]) => (Array.isArray(data) ? data : [data]).map((item) => ({ item, datasetIdentifier })));
-    }
-    /**
-     * URLs enqueued to the request queue by a request handler, either via {@link RestrictedCrawlingContext.addRequests} or {@link RestrictedCrawlingContext.enqueueLinks}
-     */
-    get enqueuedUrls() {
-        const result = [];
-        for (const [requests] of this.addRequestsCalls) {
-            for (const request of requests) {
-                if (typeof request === 'object' &&
-                    (!('requestsFromUrl' in request) || request.requestsFromUrl !== undefined) &&
-                    request.url !== undefined) {
-                    result.push({ url: request.url, label: request.label });
-                }
-                else if (typeof request === 'string') {
-                    result.push({ url: request });
-                }
-            }
-        }
-        return result;
-    }
-    /**
-     * URL lists enqueued to the request queue by a request handler via {@link RestrictedCrawlingContext.addRequests} using the `requestsFromUrl` option.
-     */
-    get enqueuedUrlLists() {
-        const result = [];
-        for (const [requests] of this.addRequestsCalls) {
-            for (const request of requests) {
-                if (typeof request === 'object' &&
-                    'requestsFromUrl' in request &&
-                    request.requestsFromUrl !== undefined) {
-                    result.push({ listUrl: request.requestsFromUrl, label: request.label });
-                }
-            }
-        }
-        return result;
-    }
-    pushData = async (data, datasetIdOrName) => {
-        this.pushDataCalls.push([data, datasetIdOrName]);
-    };
-    addRequests = async (requests, options = {}) => {
-        this.addRequestsCalls.push([requests, options]);
-    };
-    useState = async (defaultValue) => {
-        const store = await this.getKeyValueStore(undefined);
-        return await store.getAutoSavedValue(this.crawleeStateKey, defaultValue);
-    };
-    getKeyValueStore = async (identifier) => {
-        const store = await KeyValueStore.open(identifier, { configuration: this.configuration });
-        const storeId = store.id;
-        return {
-            id: storeId ?? this.configuration.defaultKeyValueStoreId,
-            name: store.name,
-            getValue: async (key) => this.getKeyValueStoreChangedValue(storeId, key) ?? (await store.getValue(key)),
-            setValue: async (key, value, options) => {
-                this.setKeyValueStoreChangedValue(storeId, key, value, options);
-            },
-            getAutoSavedValue: store.getAutoSavedValue.bind(store),
-            getPublicUrl: store.getPublicUrl.bind(store),
-        };
-    };
-    getKeyValueStoreChangedValue = (storeKey, key) => {
-        const id = storeKey ?? this.configuration.defaultKeyValueStoreId;
-        this._keyValueStoreChanges[id] ??= {};
-        return this.keyValueStoreChanges[id][key]?.changedValue ?? null;
-    };
-    setKeyValueStoreChangedValue = (storeKey, key, changedValue, options) => {
-        const id = storeKey ?? this.configuration.defaultKeyValueStoreId;
-        this._keyValueStoreChanges[id] ??= {};
-        this._keyValueStoreChanges[id][key] = { changedValue, options };
-    };
-}
+export {};

package/crawlers/error_snapshotter.d.ts

@@ -25,9 +25,7 @@ interface ErrorSnapshot {
  * ```ts
  * const crawler = new BasicCrawler({
  *   // ...
- *   statisticsOptions: {
- *     saveErrorSnapshots: true,
- *   },
+ *   statistics: new Statistics({ saveErrorSnapshots: true }),
  * });
  * ```
  */
@@ -48,7 +46,7 @@ export declare class ErrorSnapshotter {
      */
     contextCaptureSnapshot(context: BrowserCrawlingContext, fileName: string): Promise<SnapshotResult | undefined>;
     /**
-     * Save the HTML snapshot of the page, and return the fileName with the extension.
+     * Save the HTML snapshot of the page, and return the key it was stored under.
      */
     saveHTMLSnapshot(html: string, keyValueStore: Pick<KeyValueStore, 'setValue'>, fileName: string): Promise<string | undefined>;
     /**

package/crawlers/error_snapshotter.js

@@ -7,9 +7,7 @@ import crypto from 'node:crypto';
  * ```ts
  * const crawler = new BasicCrawler({
  *   // ...
- *   statisticsOptions: {
- *     saveErrorSnapshots: true,
- *   },
+ *   statistics: new Statistics({ saveErrorSnapshots: true }),
  * });
  * ```
  */
@@ -79,12 +77,14 @@ export class ErrorSnapshotter {
         }
     }
     /**
-     * Save the HTML snapshot of the page, and return the fileName with the extension.
+     * Save the HTML snapshot of the page, and return the key it was stored under.
      */
     async saveHTMLSnapshot(html, keyValueStore, fileName) {
         try {
             await keyValueStore.setValue(fileName, html, { contentType: 'text/html' });
-            return `${fileName}.html`;
+            // The record key is `fileName` - returning it with an `.html` suffix (as v3 did,
+            // where local storage put the extension in the key) would break `getPublicUrl`.
+            return fileName;
         }
         catch {
             return undefined;

package/crawlers/index.d.ts

@@ -1,5 +1,5 @@
 export * from './context_pipeline.js';
-export * from './crawler_commons.js';
+export type * from './crawler_commons.js';
 export * from './statistics.js';
 export * from './error_tracker.js';
 export * from './error_snapshotter.js';

package/crawlers/index.js

@@ -1,5 +1,4 @@
 export * from './context_pipeline.js';
-export * from './crawler_commons.js';
 export * from './statistics.js';
 export * from './error_tracker.js';
 export * from './error_snapshotter.js';