@crawlee/core 4.0.0-beta.8 → 4.0.0-beta.81

package/storages/request_list.js

@@ -1,9 +1,8 @@
 import { downloadListOfUrls } from '@crawlee/utils';
 import ow, { ArgumentError } from 'ow';
-import { Configuration } from '../configuration.js';
-import { log } from '../log.js';
 import { Request } from '../request.js';
 import { createDeserialize, serializeArray } from '../serialization.js';
+import { serviceLocator } from '../service_locator.js';
 import { KeyValueStore } from './key_value_store.js';
 import { purgeDefaultStorages } from './utils.js';
 /** @internal */
@@ -33,8 +32,8 @@ const CONTENT_TYPE_BINARY = 'application/octet-stream';
  * > In practical terms, such a combination can be useful when there is a large number of initial URLs,
  * > but more URLs would be added dynamically by the crawler.
  *
- * `RequestList` has an internal state where it stores information about which requests were already handled,
- * which are in progress and which were reclaimed. The state may be automatically persisted to the default
+ * `RequestList` has an internal state where it stores information about which requests were already handled
+ * and which are in progress. The state may be automatically persisted to the default
  * {@link KeyValueStore} by setting the `persistStateKey` option so that if the Node.js process is restarted,
  * the crawling can continue where it left off. The automated persisting is launched upon receiving the `persistState`
  * event that is periodically emitted by {@link EventManager}.
@@ -73,7 +72,7 @@ const CONTENT_TYPE_BINARY = 'application/octet-stream';
  * @category Sources
  */
 export class RequestList {
-    log = log.child({ prefix: 'RequestList' });
+    log = serviceLocator.getLogger().child({ prefix: 'RequestList' });
     /**
      * Array of all requests from all sources, in the order as they appeared in sources.
      * All requests in the array have distinct uniqueKey!
@@ -90,10 +89,11 @@ export class RequestList {
      */
     inProgress = new Set();
     /**
-     * Set of `uniqueKey`s of requests for which reclaimRequest() was called.
+     * `uniqueKey`s of requests that were in progress when the state was last persisted and thus need to be
+     * re-crawled after a restart. They are served before advancing through the rest of the sources.
      * @internal
      */
-    reclaimed = new Set();
+    requestsToRetry = [];
     /**
      * Starts as true because until we handle the first request, the list is effectively persisted by doing nothing.
      * @internal
@@ -114,14 +114,14 @@ export class RequestList {
     sources;
     sourcesFunction;
     proxyConfiguration;
-    events;
+    httpClient;
     /**
      * To create new instance of `RequestList` we need to use `RequestList.open()` factory method.
      * @param options All `RequestList` configuration options
      * @internal
      */
     constructor(options = {}) {
-        const { sources, sourcesFunction, persistStateKey, persistRequestsKey, state, proxyConfiguration, keepDuplicateUrls = false, config = Configuration.getGlobalConfig(), } = options;
+        const { sources, sourcesFunction, persistStateKey, persistRequestsKey, state, proxyConfiguration, keepDuplicateUrls = false, httpClient, } = options;
         if (!(sources || sourcesFunction)) {
             throw new ArgumentError('At least one of "sources" or "sourcesFunction" must be provided.', this.constructor);
         }
@@ -137,11 +137,12 @@ export class RequestList {
             }),
             keepDuplicateUrls: ow.optional.boolean,
             proxyConfiguration: ow.optional.object,
+            httpClient: ow.optional.object,
         }));
-        this.persistStateKey = persistStateKey ? `SDK_${persistStateKey}` : persistStateKey;
-        this.persistRequestsKey = persistRequestsKey ? `SDK_${persistRequestsKey}` : persistRequestsKey;
+        this.persistStateKey = persistStateKey ? `CRAWLEE_${persistStateKey}` : persistStateKey;
+        this.persistRequestsKey = persistRequestsKey ? `CRAWLEE_${persistRequestsKey}` : persistRequestsKey;
         this.initialState = state;
-        this.events = config.getEventManager();
+        this.httpClient = httpClient;
         // If this option is set then all requests will get a pre-generated unique ID and duplicate URLs will be kept in the list.
         this.keepDuplicateUrls = keepDuplicateUrls;
         // Will be empty after initialization to save memory.
@@ -149,6 +150,7 @@ export class RequestList {
         this.sourcesFunction = sourcesFunction;
         // The proxy configuration used for `requestsFromUrl` requests.
         this.proxyConfiguration = proxyConfiguration;
+        this.persistState = this.persistState.bind(this);
     }
     /**
      * Loads all remote sources of URLs and potentially starts periodic state persistence.
@@ -160,21 +162,21 @@ export class RequestList {
         }
         this.isLoading = true;
         await purgeDefaultStorages({ onlyPurgeOnce: true });
-        const [state, persistedRequests] = await this._loadStateAndPersistedRequests();
+        const [state, persistedRequests] = await this.loadStateAndPersistedRequests();
         // Add persisted requests / new sources in a memory efficient way because with very
         // large lists, we were running out of memory.
         if (persistedRequests) {
-            await this._addPersistedRequests(persistedRequests);
+            await this.addPersistedRequests(persistedRequests);
         }
         else {
-            await this._addRequestsFromSources();
+            await this.addRequestsFromSources();
         }
-        this._restoreState(state);
+        this.restoreState(state);
         this.isInitialized = true;
         if (this.persistRequestsKey && !this.areRequestsPersisted)
-            await this._persistRequests();
+            await this.persistRequests();
         if (this.persistStateKey) {
-            this.events.on("persistState" /* EventType.PERSIST_STATE */, this.persistState.bind(this));
+            serviceLocator.getEventManager().on("persistState" /* EventType.PERSIST_STATE */, this.persistState);
         }
         return this;
     }
@@ -183,17 +185,18 @@ export class RequestList {
      * This needs to be done in a memory efficient way. We should update the input
      * to a Stream once apify-client supports streams.
      */
-    async _addPersistedRequests(persistedRequests) {
+    async addPersistedRequests(persistedRequests) {
         // We don't need the sources so we purge them to
         // prevent them from hanging in memory.
         for (let i = 0; i < this.sources.length; i++) {
+            // oxlint-disable-next-line typescript/no-array-delete -- intentional, drop the slot so V8 can collect the object
             delete this.sources[i];
         }
         this.sources = [];
         this.areRequestsPersisted = true;
         const requestStream = createDeserialize(persistedRequests);
         for await (const request of requestStream) {
-            this._addRequest(request);
+            this.addRequest(request);
         }
     }
     /**
@@ -202,20 +205,21 @@ export class RequestList {
      * We need to avoid keeping both sources and requests in memory
      * to reduce memory footprint with very large sources.
      */
-    async _addRequestsFromSources() {
+    async addRequestsFromSources() {
         // We'll load all sources in sequence to ensure that they get loaded in the right order.
         const sourcesCount = this.sources.length;
         for (let i = 0; i < sourcesCount; i++) {
             const source = this.sources[i];
             // Using delete here to drop the original object ASAP to free memory
             // .pop would reverse the array and .shift is SLOW.
+            // oxlint-disable-next-line typescript/no-array-delete
             delete this.sources[i];
             if (typeof source === 'object' && source.requestsFromUrl) {
-                const fetchedRequests = await this._fetchRequestsFromUrl(source);
-                await this._addFetchedRequests(source, fetchedRequests);
+                const fetchedRequests = await this.fetchRequestsFromUrl(source);
+                await this.addFetchedRequests(source, fetchedRequests);
             }
             else {
-                this._addRequest(source);
+                this.addRequest(source);
             }
         }
         // Drop the original array full of empty indexes.
@@ -225,9 +229,12 @@ export class RequestList {
                 const sourcesFromFunction = await this.sourcesFunction();
                 const sourcesFromFunctionCount = sourcesFromFunction.length;
                 for (let i = 0; i < sourcesFromFunctionCount; i++) {
-                    const source = sourcesFromFunction.shift();
-                    this._addRequest(source);
+                    const source = sourcesFromFunction[i];
+                    // oxlint-disable-next-line typescript/no-array-delete -- intentional, drop the slot so V8 can collect the object
+                    delete sourcesFromFunction[i];
+                    this.addRequest(source);
                 }
+                sourcesFromFunction.length = 0;
             }
             catch (e) {
                 const err = e;
@@ -254,12 +261,23 @@ export class RequestList {
             this.log.exception(err, 'Attempted to persist state, but failed.');
         }
     }
+    /**
+     * Removes the `PERSIST_STATE` event listener registered during initialization and persists
+     * the current state one last time. Call this when you are done with the `RequestList` to avoid
+     * leaking the listener (and the requests it retains) on the shared event manager.
+     */
+    async teardown() {
+        serviceLocator.getEventManager().off("persistState" /* EventType.PERSIST_STATE */, this.persistState);
+        if (this.persistStateKey) {
+            await this.persistState();
+        }
+    }
     /**
      * Unlike persistState(), this is used only internally, since the sources
      * are automatically persisted at RequestList initialization (if the persistRequestsKey is set),
      * but there's no reason to persist it again afterwards, because RequestList is immutable.
      */
-    async _persistRequests() {
+    async persistRequests() {
         const serializedRequests = await serializeArray(this.requests);
         this.store ??= await KeyValueStore.open();
         await this.store.setValue(this.persistRequestsKey, serializedRequests, { contentType: CONTENT_TYPE_BINARY });
@@ -268,7 +286,7 @@ export class RequestList {
     /**
      * Restores RequestList state from a state object.
      */
-    _restoreState(state) {
+    restoreState(state) {
         // If there's no state it means we've not persisted any (yet).
         if (!state)
             return;
@@ -316,14 +334,14 @@ export class RequestList {
                 this.inProgress.delete(uniqueKey);
             }
         }
-        // All in-progress requests need to be re-crawled
-        this.reclaimed = new Set(this.inProgress);
+        // All in-progress requests were interrupted and need to be re-crawled.
+        this.requestsToRetry = [...this.inProgress];
     }
     /**
      * Attempts to load state and requests using the `RequestList` configuration
      * and returns a tuple of [state, requests] where each may be null if not loaded.
      */
-    async _loadStateAndPersistedRequests() {
+    async loadStateAndPersistedRequests() {
         let state;
         let persistedRequests;
         if (this.initialState) {
@@ -331,12 +349,12 @@ export class RequestList {
             this.log.debug('Loaded state from options.state argument.');
         }
         else if (this.persistStateKey) {
-            state = await this._getPersistedState(this.persistStateKey);
+            state = await this.getPersistedState(this.persistStateKey);
             if (state)
                 this.log.debug('Loaded state from key value store using the persistStateKey.');
         }
         if (this.persistRequestsKey) {
-            persistedRequests = await this._getPersistedState(this.persistRequestsKey);
+            persistedRequests = await this.getPersistedState(this.persistRequestsKey);
             if (persistedRequests)
                 this.log.debug('Loaded requests from key value store using the persistRequestsKey.');
         }
@@ -347,7 +365,7 @@ export class RequestList {
      * Note that the object's fields can change in future releases.
      */
     getState() {
-        this._ensureIsInitialized();
+        this.ensureIsInitialized();
         return {
             nextIndex: this.nextIndex,
             nextUniqueKey: this.nextIndex < this.requests.length ? this.requests[this.nextIndex].uniqueKey : null,
@@ -358,25 +376,24 @@ export class RequestList {
      * @inheritDoc
      */
     async isEmpty() {
-        this._ensureIsInitialized();
-        return this.reclaimed.size === 0 && this.nextIndex >= this.requests.length;
+        this.ensureIsInitialized();
+        return this.requestsToRetry.length === 0 && this.nextIndex >= this.requests.length;
     }
     /**
      * @inheritDoc
      */
     async isFinished() {
-        this._ensureIsInitialized();
+        this.ensureIsInitialized();
         return this.inProgress.size === 0 && this.nextIndex >= this.requests.length;
     }
     /**
      * @inheritDoc
      */
     async fetchNextRequest() {
-        this._ensureIsInitialized();
-        // First return reclaimed requests if any.
-        const uniqueKey = this.reclaimed.values().next().value;
+        this.ensureIsInitialized();
+        // First re-serve any requests that were interrupted before the last state persist.
+        const uniqueKey = this.requestsToRetry.shift();
         if (uniqueKey) {
-            this.reclaimed.delete(uniqueKey);
             const index = this.uniqueKeyToIndex[uniqueKey];
             return this.ensureRequest(this.requests[index], index);
         }
@@ -412,31 +429,21 @@ export class RequestList {
     /**
      * @inheritDoc
      */
-    async markRequestHandled(request) {
+    async markRequestAsHandled(request) {
         const { uniqueKey } = request;
-        this._ensureUniqueKeyValid(uniqueKey);
-        this._ensureInProgressAndNotReclaimed(uniqueKey);
-        this._ensureIsInitialized();
+        this.ensureUniqueKeyValid(uniqueKey);
+        this.ensureInProgress(uniqueKey);
+        this.ensureIsInitialized();
         this.inProgress.delete(uniqueKey);
         this.isStatePersisted = false;
     }
-    /**
-     * @inheritDoc
-     */
-    async reclaimRequest(request) {
-        const { uniqueKey } = request;
-        this._ensureUniqueKeyValid(uniqueKey);
-        this._ensureInProgressAndNotReclaimed(uniqueKey);
-        this._ensureIsInitialized();
-        this.reclaimed.add(uniqueKey);
-    }
     /**
      * Adds all fetched requests from a URL from a remote resource.
      */
-    async _addFetchedRequests(source, fetchedRequests) {
+    async addFetchedRequests(source, fetchedRequests) {
         const { requestsFromUrl, regex } = source;
         const originalLength = this.requests.length;
-        fetchedRequests.forEach((request) => this._addRequest(request));
+        fetchedRequests.forEach((request) => this.addRequest(request));
         const fetchedCount = fetchedRequests.length;
         const importedCount = this.requests.length - originalLength;
         this.log.info('Fetched and loaded Requests from a remote resource.', {
@@ -448,7 +455,7 @@ export class RequestList {
             sample: JSON.stringify(fetchedRequests.slice(0, 5)),
         });
     }
-    async _getPersistedState(key) {
+    async getPersistedState(key) {
         this.store ??= await KeyValueStore.open();
         const state = await this.store.getValue(key);
         return state;
@@ -456,7 +463,7 @@ export class RequestList {
     /**
      * Fetches URLs from requestsFromUrl and returns them in format of list of requests
      */
-    async _fetchRequestsFromUrl(source) {
+    async fetchRequestsFromUrl(source) {
         const { requestsFromUrl, regex, ...sharedOpts } = source;
         // Download remote resource and parse URLs.
         let urlsArr;
@@ -464,7 +471,7 @@ export class RequestList {
             urlsArr = await this._downloadListOfUrls({
                 url: requestsFromUrl,
                 urlRegExp: regex,
-                proxyUrl: await this.proxyConfiguration?.newUrl(),
+                proxyUrl: (await this.proxyConfiguration?.newProxyInfo())?.url,
             });
         }
         catch (err) {
@@ -482,7 +489,7 @@ export class RequestList {
      * If the `source` parameter is a string or plain object and not an instance
      * of a `Request`, then the function creates a `Request` instance.
      */
-    _addRequest(source) {
+    addRequest(source) {
         let request;
         const type = typeof source;
         if (type === 'string') {
@@ -504,7 +511,7 @@ export class RequestList {
             request.uniqueKey += `-${this.requests.length}`;
         }
         const { uniqueKey } = request;
-        this._ensureUniqueKeyValid(uniqueKey);
+        this.ensureUniqueKeyValid(uniqueKey);
         // Skip requests with duplicate uniqueKey
         if (!Object.hasOwn(this.uniqueKeyToIndex, uniqueKey)) {
             this.uniqueKeyToIndex[uniqueKey] = this.requests.length;
@@ -518,26 +525,23 @@ export class RequestList {
      * Helper function that validates unique key.
      * Throws an error if uniqueKey is not a non-empty string.
      */
-    _ensureUniqueKeyValid(uniqueKey) {
+    ensureUniqueKeyValid(uniqueKey) {
         if (typeof uniqueKey !== 'string' || !uniqueKey) {
             throw new Error("Request object's uniqueKey must be a non-empty string");
         }
     }
     /**
-     * Checks that request is not reclaimed and throws an error if so.
+     * Checks that a request is currently being processed and throws an error if not.
      */
-    _ensureInProgressAndNotReclaimed(uniqueKey) {
+    ensureInProgress(uniqueKey) {
         if (!this.inProgress.has(uniqueKey)) {
             throw new Error(`The request is not being processed (uniqueKey: ${uniqueKey})`);
         }
-        if (this.reclaimed.has(uniqueKey)) {
-            throw new Error(`The request was already reclaimed (uniqueKey: ${uniqueKey})`);
-        }
     }
     /**
      * Throws an error if request list wasn't initialized.
      */
-    _ensureIsInitialized() {
+    ensureIsInitialized() {
         if (!this.isInitialized) {
             throw new Error('RequestList is not initialized; you must call "await requestList.initialize()" before using it!');
         }
@@ -545,15 +549,33 @@ export class RequestList {
     /**
      * Returns the total number of unique requests present in the `RequestList`.
      */
-    length() {
-        this._ensureIsInitialized();
+    async getTotalCount() {
+        this.ensureIsInitialized();
         return this.requests.length;
     }
+    /**
+     * Returns the number of pending requests in the `RequestList`.
+     */
+    async getPendingCount() {
+        this.ensureIsInitialized();
+        return this.requests.length - (this.nextIndex - this.inProgress.size);
+    }
+    /**
+     * Combines this list with a request manager (a {@link RequestQueue} by default) into a
+     * {@link RequestManagerTandem}, allowing requests to be added and reclaimed while still
+     * being read from this list first.
+     */
+    async toTandem(requestManager) {
+        // Import here to avoid circular imports.
+        const { RequestManagerTandem } = await import('./request_manager_tandem.js');
+        const { RequestQueue } = await import('./request_queue.js');
+        return new RequestManagerTandem(this, requestManager ?? (await RequestQueue.open()));
+    }
     /**
      * @inheritDoc
      */
-    handledCount() {
-        this._ensureIsInitialized();
+    async getHandledCount() {
+        this.ensureIsInitialized();
         return this.nextIndex - this.inProgress.size;
     }
     /**
@@ -633,7 +655,9 @@ export class RequestList {
      * @internal wraps public utility for mocking purposes
      */
     async _downloadListOfUrls(options) {
-        return downloadListOfUrls(options);
+        return downloadListOfUrls({
+            ...options,
+            httpClient: this.httpClient,
+        });
     }
 }
-//# sourceMappingURL=request_list.js.map

package/storages/request_loader.d.ts

@@ -0,0 +1,96 @@
+import type { Dictionary } from '@crawlee/types';
+import type { Request } from '../request.js';
+import type { IRequestManager } from './request_manager.js';
+import type { RequestQueueOperationInfo } from './request_queue.js';
+/**
+ * An abstract interface defining a read-only stream of requests to crawl.
+ *
+ * Request loaders are used to manage and provide access to a storage of crawling requests.
+ *
+ * Key responsibilities:
+ * - Fetching the next request to be processed.
+ * - Marking requests as handled once they are no longer in progress.
+ * - Managing state information such as the total and handled request counts.
+ *
+ * ## Request lifecycle contract
+ *
+ * Every request returned by {@link IRequestLoader.fetchNextRequest} is considered **in progress**
+ * until it is passed to {@link IRequestLoader.markRequestAsHandled}. Once you fetch a request, you are
+ * obligated to eventually mark it as handled — there is no way to hand a request back to a loader
+ * (only an {@link IRequestManager} can reclaim requests for a retry). "Handled" therefore means
+ * "finished with this request", whether processing succeeded or was abandoned after exhausting retries.
+ *
+ * Honoring this contract matters for three reasons:
+ * - **Restarts and migrations:** loaders that persist their state (see {@link IRequestLoader.persistState})
+ *   treat in-progress requests as interrupted and re-serve them after a restart. A request that is fetched
+ *   but never marked handled will be crawled again.
+ * - **Termination detection:** {@link IRequestLoader.isFinished} only resolves to `true` once nothing is
+ *   in progress. Leaving a request unmarked keeps the crawler running indefinitely.
+ * - **Bookkeeping:** the handled and pending counts are derived from the set of in-progress requests, so
+ *   skipping {@link IRequestLoader.markRequestAsHandled} corrupts {@link IRequestLoader.getHandledCount}
+ *   and {@link IRequestLoader.getPendingCount}.
+ *
+ * Concrete implementations such as {@link RequestList} or {@link SitemapRequestLoader} build on this interface.
+ * The {@link IRequestManager} interface extends it with the capability to enqueue and reclaim requests.
+ */
+export interface IRequestLoader {
+    /**
+     * Returns an approximation of the total number of requests in the loader (i.e. pending + handled).
+     */
+    getTotalCount(): Promise<number>;
+    /**
+     * Returns an approximation of the number of pending requests in the loader.
+     */
+    getPendingCount(): Promise<number>;
+    /**
+     * Returns the number of requests in the loader that have been handled.
+     */
+    getHandledCount(): Promise<number>;
+    /**
+     * Returns `true` if all requests were already handled and there are no more left.
+     */
+    isFinished(): Promise<boolean>;
+    /**
+     * Resolves to `true` if the next call to {@link IRequestLoader.fetchNextRequest} function
+     * would return `null`, otherwise it resolves to `false`.
+     * Note that even if the loader is empty, there might be some pending requests currently being processed.
+     */
+    isEmpty(): Promise<boolean>;
+    /**
+     * Gets the next {@link Request} to process, or `null` if there are no more pending requests.
+     *
+     * The returned request is marked as **in progress** and remains so until it is passed to
+     * {@link IRequestLoader.markRequestAsHandled}. The caller is responsible for eventually marking
+     * every fetched request as handled; otherwise the loader never considers itself finished and the
+     * request may be re-served after a restart. See the request lifecycle contract on {@link IRequestLoader}.
+     */
+    fetchNextRequest<T extends Dictionary = Dictionary>(): Promise<Request<T> | null>;
+    /**
+     * Can be used to iterate over the loader instance in a `for await .. of` loop.
+     * Provides an alternative for the repeated use of `fetchNextRequest`.
+     */
+    [Symbol.asyncIterator](): AsyncGenerator<Request>;
+    /**
+     * Marks a request previously returned by {@link IRequestLoader.fetchNextRequest} as handled,
+     * removing it from the set of in-progress requests.
+     *
+     * Call this once you are done with the request — whether processing succeeded or was abandoned after
+     * exhausting retries. Because a loader cannot take a request back, marking it handled is the only way to
+     * signal completion; failing to do so prevents {@link IRequestLoader.isFinished} from ever resolving to
+     * `true` and skews the handled and pending counts. See the request lifecycle contract on {@link IRequestLoader}.
+     */
+    markRequestAsHandled(request: Request): Promise<RequestQueueOperationInfo | void | null>;
+    /**
+     * Persists the current state of the loader into the default {@link KeyValueStore}.
+     *
+     * Not all loaders support persistence; implementations that do not should leave this `undefined`.
+     */
+    persistState?(): Promise<void>;
+    /**
+     * Combines the loader with a request manager to support adding and reclaiming requests.
+     *
+     * @param requestManager Request manager to combine the loader with. If not provided, the default
+     *  {@link RequestQueue} is used.
+     */
+    toTandem?(requestManager?: IRequestManager): Promise<IRequestManager>;
+}

package/storages/request_loader.js

@@ -0,0 +1 @@
+export {};

package/storages/request_manager.d.ts

@@ -0,0 +1,33 @@
+import type { Request, Source } from '../request.js';
+import type { IRequestLoader } from './request_loader.js';
+import type { AddRequestsBatchedOptions, AddRequestsBatchedResult, RequestQueueOperationInfo, RequestQueueOperationOptions } from './request_queue.js';
+export type RequestsLike = AsyncIterable<Source | string> | Iterable<Source | string> | (Source | string)[];
+/**
+ * Extends the read-only {@link IRequestLoader} interface with the capability to enqueue new requests
+ * and reclaim failed ones.
+ */
+export interface IRequestManager extends IRequestLoader {
+    /**
+     * Reclaims request to the provider if its processing failed.
+     * The request will be returned by some subsequent `fetchNextRequest()` call.
+     */
+    reclaimRequest(request: Request, options?: RequestQueueOperationOptions): Promise<RequestQueueOperationInfo | null>;
+    addRequest(requestLike: Source, options?: RequestQueueOperationOptions): Promise<RequestQueueOperationInfo>;
+    addRequestsBatched(requests: RequestsLike, options?: AddRequestsBatchedOptions): Promise<AddRequestsBatchedResult>;
+    /**
+     * Remove all requests from the queue but keep the queue itself, resetting it
+     * so it can be reused (e.g. across multiple `crawler.run()` calls).
+     *
+     * Implementations that do not support purging may leave this `undefined`.
+     */
+    purge?(): Promise<void>;
+    /**
+     * Tells the manager how long a consumer expects to hold a request fetched via `fetchNextRequest()`
+     * before marking it handled or reclaiming it (typically the request-handler timeout plus padding).
+     *
+     * Managers backed by a storage backend that reserves requests via locking use this to avoid handing
+     * the same request out again while it is still being processed. Implementations that do not need
+     * this hint may leave it `undefined`.
+     */
+    setExpectedRequestProcessingTimeSecs?(secs: number): Promise<void>;
+}

package/storages/request_manager.js

@@ -0,0 +1 @@
+export {};