@crawlee/core 4.0.0-beta.105 → 4.0.0-beta.106

package/events/local_event_manager.js

@@ -2,10 +2,10 @@ import { betterClearInterval, betterSetInterval } from '@apify/utilities';
 import { serviceLocator } from '../service_locator.js';
 import { EventManager } from './event_manager.js';
 export class LocalEventManager extends EventManager {
-    systemInfoIntervalMillis;
+    #systemInfoIntervalMillis;
     constructor(options) {
         super(options);
-        this.systemInfoIntervalMillis = options.systemInfoIntervalMillis;
+        this.#systemInfoIntervalMillis = options.systemInfoIntervalMillis;
     }
     /**
      * Creates a new `LocalEventManager` based on the provided `Configuration`.
@@ -28,7 +28,7 @@ export class LocalEventManager extends EventManager {
         }
         await super.init();
         this.emitSystemInfoEvent = this.emitSystemInfoEvent.bind(this);
-        this.intervals.systemInfo = betterSetInterval(this.emitSystemInfoEvent.bind(this), this.systemInfoIntervalMillis);
+        this.intervals.systemInfo = betterSetInterval(this.emitSystemInfoEvent.bind(this), this.#systemInfoIntervalMillis);
     }
     /**
      * @inheritDoc

package/log.js

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

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

@@ -10,12 +10,8 @@ export interface MemoryStorageOptions {
     logger?: CrawleeLogger;
 }
 export declare class MemoryStorageBackend implements storage.StorageBackend {
+    #private;
     readonly logger?: CrawleeLogger;
-    /**
-     * Unique per-instance cache partition key. Mirrors the way `FileSystemStorageBackend` partitions its
-     * cache by storage directory: two distinct `MemoryStorageBackend` instances must not share cached backends.
-     */
-    private readonly instanceCacheKey;
     readonly keyValueStoreBackendCache: KeyValueStoreBackend[];
     readonly datasetBackendCache: DatasetBackend[];
     readonly requestQueueBackendCache: RequestQueueBackend[];

package/memory-storage/memory-storage.js

@@ -8,7 +8,7 @@ export class MemoryStorageBackend {
      * Unique per-instance cache partition key. Mirrors the way `FileSystemStorageBackend` partitions its
      * cache by storage directory: two distinct `MemoryStorageBackend` instances must not share cached backends.
      */
-    instanceCacheKey = `MemoryStorageBackend:${randomUUID()}`;
+    #instanceCacheKey = `MemoryStorageBackend:${randomUUID()}`;
     keyValueStoreBackendCache = [];
     datasetBackendCache = [];
     requestQueueBackendCache = [];
@@ -20,7 +20,7 @@ export class MemoryStorageBackend {
      * cache partitions in the storage backend cache.
      */
     getStorageBackendCacheKey() {
-        return this.instanceCacheKey;
+        return this.#instanceCacheKey;
     }
     static resolveStorageKey(options) {
         const isAlias = 'alias' in options && !!options.alias;

package/memory-storage/resource-clients/dataset.d.ts

@@ -14,6 +14,7 @@ export interface DatasetBackendOptions {
     storageBackend: MemoryStorageBackend;
 }
 export declare class DatasetBackend<Data extends Dictionary = Dictionary> extends BaseClient implements storage.DatasetBackend<Data> {
+    #private;
     name?: string;
     /**
      * The key used for cache lookup. For named storages, this equals the name. For alias (unnamed)
@@ -24,7 +25,6 @@ export declare class DatasetBackend<Data extends Dictionary = Dictionary> extend
     accessedAt: Date;
     modifiedAt: Date;
     itemCount: number;
-    private readonly datasetEntries;
     private readonly storageBackend;
     constructor(options: DatasetBackendOptions);
     getMetadata(): Promise<storage.DatasetInfo>;

package/memory-storage/resource-clients/dataset.js

@@ -22,7 +22,8 @@ export class DatasetBackend extends BaseClient {
     accessedAt = new Date();
     modifiedAt = new Date();
     itemCount = 0;
-    datasetEntries = new Map();
+    #datasetEntries = new Map();
+    // kept as TS-private: storage-backend tests read this field at runtime
     storageBackend;
     constructor(options) {
         super(options.id ?? randomUUID());
@@ -39,12 +40,12 @@ export class DatasetBackend extends BaseClient {
         if (storeIndex !== -1) {
             const [oldBackend] = this.storageBackend.datasetBackendCache.splice(storeIndex, 1);
             oldBackend.itemCount = 0;
-            oldBackend.datasetEntries.clear();
+            oldBackend.#datasetEntries.clear();
         }
     }
     async purge() {
         this.itemCount = 0;
-        this.datasetEntries.clear();
+        this.#datasetEntries.clear();
         this.updateTimestamps(true);
     }
     getData(options = {}) {
@@ -67,7 +68,7 @@ export class DatasetBackend extends BaseClient {
         const items = [];
         for (let idx = start; idx < end; idx++) {
             const entryNumber = this.generateLocalEntryName(idx);
-            items.push(this.datasetEntries.get(entryNumber));
+            items.push(this.#datasetEntries.get(entryNumber));
         }
         this.updateTimestamps(false);
         return {
@@ -82,7 +83,7 @@ export class DatasetBackend extends BaseClient {
     async pushData(items) {
         for (const entry of items) {
             const idx = this.generateLocalEntryName(++this.itemCount);
-            this.datasetEntries.set(idx, JSON.parse(JSON.stringify(entry)));
+            this.#datasetEntries.set(idx, JSON.parse(JSON.stringify(entry)));
         }
         this.updateTimestamps(true);
     }

package/memory-storage/resource-clients/key-value-store.d.ts

@@ -19,6 +19,7 @@ export interface InternalKeyRecord {
     extension: string;
 }
 export declare class KeyValueStoreBackend extends BaseClient implements storage.KeyValueStoreBackend {
+    #private;
     name?: string;
     /**
      * The key used for cache lookup. For named storages, this equals the name. For alias (unnamed)
@@ -28,7 +29,6 @@ export declare class KeyValueStoreBackend extends BaseClient implements storage.
     createdAt: Date;
     accessedAt: Date;
     modifiedAt: Date;
-    private readonly keyValueEntries;
     private readonly storageBackend;
     constructor(options: KeyValueStoreBackendOptions);
     getMetadata(): Promise<storage.KeyValueStoreInfo>;

package/memory-storage/resource-clients/key-value-store.js

@@ -19,7 +19,8 @@ export class KeyValueStoreBackend extends BaseClient {
     createdAt = new Date();
     accessedAt = new Date();
     modifiedAt = new Date();
-    keyValueEntries = new Map();
+    #keyValueEntries = new Map();
+    // kept as TS-private: storage-backend tests read this field at runtime
     storageBackend;
     constructor(options) {
         super(options.id ?? randomUUID());
@@ -35,11 +36,11 @@ export class KeyValueStoreBackend extends BaseClient {
         const storeIndex = this.storageBackend.keyValueStoreBackendCache.findIndex((store) => store.id === this.id);
         if (storeIndex !== -1) {
             const [oldBackend] = this.storageBackend.keyValueStoreBackendCache.splice(storeIndex, 1);
-            oldBackend.keyValueEntries.clear();
+            oldBackend.#keyValueEntries.clear();
         }
     }
     async purge() {
-        this.keyValueEntries.clear();
+        this.#keyValueEntries.clear();
         this.updateTimestamps(true);
     }
     /**
@@ -49,9 +50,9 @@ export class KeyValueStoreBackend extends BaseClient {
      * preserve the bare `INPUT` key only.
      */
     async purgeExceptInput() {
-        for (const key of this.keyValueEntries.keys()) {
+        for (const key of this.#keyValueEntries.keys()) {
             if (key !== KEY_VALUE_STORE_INPUT_KEY) {
-                this.keyValueEntries.delete(key);
+                this.#keyValueEntries.delete(key);
             }
         }
         this.updateTimestamps(true);
@@ -65,7 +66,7 @@ export class KeyValueStoreBackend extends BaseClient {
         })
             .parse(options);
         const items = [];
-        for (const record of this.keyValueEntries.values()) {
+        for (const record of this.#keyValueEntries.values()) {
             const size = Buffer.byteLength(record.value);
             items.push({
                 key: record.key,
@@ -114,11 +115,11 @@ export class KeyValueStoreBackend extends BaseClient {
      */
     async recordExists(key) {
         s.string().parse(key);
-        return this.keyValueEntries.has(key);
+        return this.#keyValueEntries.has(key);
     }
     async getValue(key) {
         s.string().parse(key);
-        const entry = this.keyValueEntries.get(key);
+        const entry = this.#keyValueEntries.get(key);
         if (!entry) {
             return undefined;
         }
@@ -169,19 +170,19 @@ export class KeyValueStoreBackend extends BaseClient {
         const normalizedValue = typeof value === 'string'
             ? Buffer.from(value, 'utf-8')
             : toBuffer(value);
-        const _record = {
+        const normalizedRecord = {
             extension,
             key,
             value: normalizedValue,
             contentType,
         };
-        this.keyValueEntries.set(key, _record);
+        this.#keyValueEntries.set(key, normalizedRecord);
         this.updateTimestamps(true);
     }
     async deleteValue(key) {
         s.string().parse(key);
-        if (this.keyValueEntries.has(key)) {
-            this.keyValueEntries.delete(key);
+        if (this.#keyValueEntries.has(key)) {
+            this.#keyValueEntries.delete(key);
             this.updateTimestamps(true);
         }
     }

package/memory-storage/resource-clients/request-queue.d.ts

@@ -22,6 +22,7 @@ export interface InternalRequest {
     json: string;
 }
 export declare class RequestQueueBackend extends BaseClient implements storage.RequestQueueBackend {
+    #private;
     name?: string;
     /**
      * The key used for cache lookup. For named storages, this equals the name. For alias (unnamed)
@@ -33,26 +34,6 @@ export declare class RequestQueueBackend extends BaseClient implements storage.R
     modifiedAt: Date;
     handledRequestCount: number;
     pendingRequestCount: number;
-    /**
-     * Serializes every operation that reads-then-writes this backend's shared queue state — the
-     * `requests` map, the `forefrontRequestIds` array, the `inProgressRequestIds` set and the request
-     * counts. Those mutations span `await` points, so without this mutex a concurrent operation could
-     * interleave and corrupt them (e.g. a head scan pruning `forefrontRequestIds` while
-     * `addBatchOfRequests` pushes to it). Held by every mutating method as well as by `isEmpty`/
-     * `isFinished`, whose head scan also prunes `forefrontRequestIds`.
-     */
-    private readonly queueStateMutex;
-    private forefrontRequestIds;
-    /**
-     * IDs of requests currently fetched but not yet handled or reclaimed. A request in this set is
-     * "in progress" and will not be handed out again by {@link fetchNextRequest}.
-     *
-     * Unlike the file-system / platform clients, the in-memory queue lives entirely within a single
-     * process and is never shared with another consumer, so there is no need for an expiring,
-     * cross-process-visible lock — tracking in-progress requests in this set is enough.
-     */
-    private readonly inProgressRequestIds;
-    private readonly requests;
     private readonly storageBackend;
     constructor(options: RequestQueueBackendOptions);
     getMetadata(): Promise<storage.RequestQueueInfo>;
@@ -90,7 +71,7 @@ export declare class RequestQueueBackend extends BaseClient implements storage.R
     listItems(): Promise<storage.UpdateRequestSchema[]>;
     toRequestQueueInfo(): storage.RequestQueueInfo;
     private updateTimestamps;
-    private _jsonToRequest;
-    private _createInternalRequest;
-    private _calculateOrderNo;
+    private jsonToRequest;
+    private createInternalRequest;
+    private calculateOrderNo;
 }

package/memory-storage/resource-clients/request-queue.js

@@ -38,8 +38,8 @@ export class RequestQueueBackend extends BaseClient {
      * `addBatchOfRequests` pushes to it). Held by every mutating method as well as by `isEmpty`/
      * `isFinished`, whose head scan also prunes `forefrontRequestIds`.
      */
-    queueStateMutex = new AsyncQueue();
-    forefrontRequestIds = [];
+    #queueStateMutex = new AsyncQueue();
+    #forefrontRequestIds = [];
     /**
      * IDs of requests currently fetched but not yet handled or reclaimed. A request in this set is
      * "in progress" and will not be handed out again by {@link fetchNextRequest}.
@@ -48,8 +48,9 @@ export class RequestQueueBackend extends BaseClient {
      * process and is never shared with another consumer, so there is no need for an expiring,
      * cross-process-visible lock — tracking in-progress requests in this set is enough.
      */
-    inProgressRequestIds = new Set();
-    requests = new Map();
+    #inProgressRequestIds = new Set();
+    #requests = new Map();
+    // kept as TS-private: storage-backend tests read this field at runtime
     storageBackend;
     constructor(options) {
         super(options.id ?? randomUUID());
@@ -65,7 +66,7 @@ export class RequestQueueBackend extends BaseClient {
         // Serialize against other mutators (and the head scans in `isEmpty`/`isFinished`) so a concurrent
         // operation cannot observe half-cleared state — e.g. a forefront id whose request has already been
         // removed, which `listPendingHead` would then dereference as `undefined`.
-        await this.queueStateMutex.wait();
+        await this.#queueStateMutex.wait();
         try {
             const storeIndex = this.storageBackend.requestQueueBackendCache.findIndex((queue) => queue.id === this.id);
             if (storeIndex !== -1) {
@@ -74,37 +75,37 @@ export class RequestQueueBackend extends BaseClient {
                 // Clear all in-memory state, consistent with `purge`. Clearing `requests` alone would
                 // leave dangling ids in `forefrontRequestIds`/`inProgressRequestIds`, which a later head
                 // scan would resolve to a missing request and dereference.
-                oldBackend.requests.clear();
-                oldBackend.forefrontRequestIds = [];
-                oldBackend.inProgressRequestIds.clear();
+                oldBackend.#requests.clear();
+                oldBackend.#forefrontRequestIds = [];
+                oldBackend.#inProgressRequestIds.clear();
             }
         }
         finally {
-            this.queueStateMutex.shift();
+            this.#queueStateMutex.shift();
         }
     }
     async purge() {
         // Serialize against other mutators (and the head scans in `isEmpty`/`isFinished`) so a concurrent
         // operation cannot observe or repopulate half-cleared state across the `await` below.
-        await this.queueStateMutex.wait();
+        await this.#queueStateMutex.wait();
         try {
             // Clear all in-memory state
-            this.requests.clear();
-            this.forefrontRequestIds = [];
-            this.inProgressRequestIds.clear();
+            this.#requests.clear();
+            this.#forefrontRequestIds = [];
+            this.#inProgressRequestIds.clear();
             this.handledRequestCount = 0;
             this.pendingRequestCount = 0;
             this.updateTimestamps(true);
         }
         finally {
-            this.queueStateMutex.shift();
+            this.#queueStateMutex.shift();
         }
     }
     *requestKeyIterator() {
-        for (let i = this.forefrontRequestIds.length - 1; i >= 0; i--) {
-            yield this.forefrontRequestIds[i];
+        for (let i = this.#forefrontRequestIds.length - 1; i >= 0; i--) {
+            yield this.#forefrontRequestIds[i];
         }
-        for (const key of this.requests.keys()) {
+        for (const key of this.#requests.keys()) {
             yield key;
         }
     }
@@ -140,17 +141,17 @@ export class RequestQueueBackend extends BaseClient {
                 continue;
             }
             seenRequestIds.add(requestId);
-            const request = this.requests.get(requestId);
+            const request = this.#requests.get(requestId);
             // Permanently-handled requests (`orderNo === null`) are in a terminal state and can be skipped.
             if (request.orderNo === null) {
-                if (this.forefrontRequestIds.includes(requestId)) {
+                if (this.#forefrontRequestIds.includes(requestId)) {
                     handledForefrontIds.add(requestId);
                 }
                 continue;
             }
             // In progress (fetched but not yet handled or reclaimed) — skip it, but remember that the
             // queue is not truly empty.
-            if (this.inProgressRequestIds.has(requestId)) {
+            if (this.#inProgressRequestIds.has(requestId)) {
                 hasInProgressRequests = true;
                 continue;
             }
@@ -158,7 +159,7 @@ export class RequestQueueBackend extends BaseClient {
                 items.push(request);
             }
         }
-        this.forefrontRequestIds = this.forefrontRequestIds.filter((id) => !handledForefrontIds.has(id));
+        this.#forefrontRequestIds = this.#forefrontRequestIds.filter((id) => !handledForefrontIds.has(id));
         return {
             items: items.sort((a, b) => a.orderNo - b.orderNo),
             hasInProgressRequests: detectInProgressRequests ? hasInProgressRequests : undefined,
@@ -166,7 +167,7 @@ export class RequestQueueBackend extends BaseClient {
     }
     async fetchNextRequest() {
         this.updateTimestamps(false);
-        await this.queueStateMutex.wait();
+        await this.#queueStateMutex.wait();
         try {
             const { items: [head], } = await this.listPendingHead(1);
             if (!head) {
@@ -174,11 +175,11 @@ export class RequestQueueBackend extends BaseClient {
             }
             // Mark the request as in progress so it is not handed out again until it is handled or
             // reclaimed. The request keeps its `orderNo` (and thus its forefront / normal ordering).
-            this.inProgressRequestIds.add(head.id);
-            return this._jsonToRequest(head.json) ?? undefined;
+            this.#inProgressRequestIds.add(head.id);
+            return this.jsonToRequest(head.json) ?? undefined;
         }
         finally {
-            this.queueStateMutex.shift();
+            this.#queueStateMutex.shift();
         }
     }
     async addBatchOfRequests(requests, options = {}) {
@@ -187,15 +188,15 @@ export class RequestQueueBackend extends BaseClient {
         // Serialize against other mutators (and the head scans in `isEmpty`/`isFinished`) so that the
         // shared `requests` map, `forefrontRequestIds` array and request counts are not corrupted by a
         // concurrent operation interleaving at one of the `await` points below.
-        await this.queueStateMutex.wait();
+        await this.#queueStateMutex.wait();
         try {
             const result = {
                 processedRequests: [],
                 unprocessedRequests: [],
             };
             for (const model of requests) {
-                const requestModel = this._createInternalRequest(model, options.forefront);
-                const existingRequestWithId = this.requests.get(requestModel.id);
+                const requestModel = this.createInternalRequest(model, options.forefront);
+                const existingRequestWithId = this.#requests.get(requestModel.id);
                 if (existingRequestWithId) {
                     result.processedRequests.push({
                         requestId: existingRequestWithId.id,
@@ -205,7 +206,7 @@ export class RequestQueueBackend extends BaseClient {
                     });
                     continue;
                 }
-                this.requests.set(requestModel.id, requestModel);
+                this.#requests.set(requestModel.id, requestModel);
                 if (requestModel.orderNo) {
                     this.pendingRequestCount += 1;
                 }
@@ -213,7 +214,7 @@ export class RequestQueueBackend extends BaseClient {
                     this.handledRequestCount += 1;
                 }
                 if (options.forefront) {
-                    this.forefrontRequestIds.push(requestModel.id);
+                    this.#forefrontRequestIds.push(requestModel.id);
                 }
                 result.processedRequests.push({
                     requestId: requestModel.id,
@@ -228,15 +229,15 @@ export class RequestQueueBackend extends BaseClient {
             return result;
         }
         finally {
-            this.queueStateMutex.shift();
+            this.#queueStateMutex.shift();
         }
     }
     async getRequest(uniqueKey) {
         s.string().parse(uniqueKey);
         this.updateTimestamps(false);
         const id = uniqueKeyToRequestId(uniqueKey);
-        const json = this.requests.get(id)?.json;
-        return this._jsonToRequest(json);
+        const json = this.#requests.get(id)?.json;
+        return this.jsonToRequest(json);
     }
     async markRequestAsHandled(request) {
         requestShape.parse(request);
@@ -244,10 +245,10 @@ export class RequestQueueBackend extends BaseClient {
         // Serialize against other mutators (and the head scans in `isEmpty`/`isFinished`) so the shared
         // `requests` map, `inProgressRequestIds` set and request counts stay consistent across the
         // `await` points below.
-        await this.queueStateMutex.wait();
+        await this.#queueStateMutex.wait();
         try {
             const id = uniqueKeyToRequestId(request.uniqueKey);
-            const existingRequest = this.requests.get(id);
+            const existingRequest = this.#requests.get(id);
             // The request must exist to be marked as handled. We intentionally do NOT require it to still
             // be in progress: marking an already-released request handled must still succeed, otherwise
             // the request could be handed out again and the queue would never finish.
@@ -257,10 +258,10 @@ export class RequestQueueBackend extends BaseClient {
             // A handled request has `orderNo === null`. Marking it again is an idempotent no-op.
             const wasAlreadyHandled = existingRequest.orderNo === null;
             const handledAt = request.handledAt ?? new Date().toISOString();
-            const requestModel = this._createInternalRequest({ ...request, handledAt }, false);
-            this.requests.set(id, requestModel);
+            const requestModel = this.createInternalRequest({ ...request, handledAt }, false);
+            this.#requests.set(id, requestModel);
             // The request is no longer in progress for this client.
-            this.inProgressRequestIds.delete(id);
+            this.#inProgressRequestIds.delete(id);
             if (!wasAlreadyHandled) {
                 this.pendingRequestCount -= 1;
                 this.handledRequestCount += 1;
@@ -273,7 +274,7 @@ export class RequestQueueBackend extends BaseClient {
             };
         }
         finally {
-            this.queueStateMutex.shift();
+            this.#queueStateMutex.shift();
         }
     }
     async reclaimRequest(request, options = {}) {
@@ -283,10 +284,10 @@ export class RequestQueueBackend extends BaseClient {
         // Serialize against other mutators (and the head scans in `isEmpty`/`isFinished`) so the shared
         // `requests` map, `forefrontRequestIds` array and `inProgressRequestIds` set stay consistent
         // across the `await` points below.
-        await this.queueStateMutex.wait();
+        await this.#queueStateMutex.wait();
         try {
             const id = uniqueKeyToRequestId(request.uniqueKey);
-            const existingRequest = this.requests.get(id);
+            const existingRequest = this.#requests.get(id);
             // The request must exist and not already be handled to be reclaimed. As with
             // `markRequestAsHandled`, we do NOT require it to still be in progress — returning an
             // already-released request to the queue (e.g. to honor a `forefront` reorder) must still
@@ -296,12 +297,12 @@ export class RequestQueueBackend extends BaseClient {
             }
             // Reclaiming resets the `orderNo` to a fresh timestamp, restoring the request to the queue
             // (at the front if `forefront`).
-            const requestModel = this._createInternalRequest(request, options.forefront);
-            this.requests.set(id, requestModel);
+            const requestModel = this.createInternalRequest(request, options.forefront);
+            this.#requests.set(id, requestModel);
             // The request is no longer in progress for this client.
-            this.inProgressRequestIds.delete(id);
+            this.#inProgressRequestIds.delete(id);
             if (options.forefront) {
-                this.forefrontRequestIds.push(id);
+                this.#forefrontRequestIds.push(id);
             }
             this.updateTimestamps(true);
             return {
@@ -311,7 +312,7 @@ export class RequestQueueBackend extends BaseClient {
             };
         }
         finally {
-            this.queueStateMutex.shift();
+            this.#queueStateMutex.shift();
         }
     }
     async isEmpty() {
@@ -324,13 +325,13 @@ export class RequestQueueBackend extends BaseClient {
         //
         // `listPendingHead` prunes `forefrontRequestIds` as it scans, so we must hold the queue-state mutex to avoid
         // racing a concurrent mutator (e.g. `addBatchOfRequests`) at its `await` points.
-        await this.queueStateMutex.wait();
+        await this.#queueStateMutex.wait();
         try {
             const { items } = await this.listPendingHead(1);
             return items.length === 0;
         }
         finally {
-            this.queueStateMutex.shift();
+            this.#queueStateMutex.shift();
         }
     }
     async isFinished() {
@@ -344,13 +345,13 @@ export class RequestQueueBackend extends BaseClient {
         //
         // `listPendingHead` prunes `forefrontRequestIds` as it scans, so we must hold the queue-state mutex to avoid
         // racing a concurrent mutator (e.g. `addBatchOfRequests`) at its `await` points.
-        await this.queueStateMutex.wait();
+        await this.#queueStateMutex.wait();
         try {
             const { items, hasInProgressRequests } = await this.listPendingHead(1, true);
             return items.length === 0 && !hasInProgressRequests;
         }
         finally {
-            this.queueStateMutex.shift();
+            this.#queueStateMutex.shift();
         }
     }
     /**
@@ -362,13 +363,13 @@ export class RequestQueueBackend extends BaseClient {
         this.updateTimestamps(false);
         // `listPendingHead` prunes `forefrontRequestIds` as it scans, so we must hold the queue-state
         // mutex to avoid racing a concurrent mutator at its `await` points.
-        await this.queueStateMutex.wait();
+        await this.#queueStateMutex.wait();
         try {
             const { items } = await this.listPendingHead(Number.POSITIVE_INFINITY);
-            return items.map((request) => this._jsonToRequest(request.json));
+            return items.map((request) => this.jsonToRequest(request.json));
         }
         finally {
-            this.queueStateMutex.shift();
+            this.#queueStateMutex.shift();
         }
     }
     toRequestQueueInfo() {
@@ -380,7 +381,7 @@ export class RequestQueueBackend extends BaseClient {
             modifiedAt: this.modifiedAt,
             name: this.name,
             pendingRequestCount: this.pendingRequestCount,
-            totalRequestCount: this.requests.size,
+            totalRequestCount: this.#requests.size,
         };
     }
     updateTimestamps(hasBeenModified) {
@@ -389,14 +390,14 @@ export class RequestQueueBackend extends BaseClient {
             this.modifiedAt = new Date();
         }
     }
-    _jsonToRequest(requestJson) {
+    jsonToRequest(requestJson) {
         if (!requestJson)
             return undefined;
         const request = JSON.parse(requestJson);
         return purgeNullsFromObject(request);
     }
-    _createInternalRequest(request, forefront) {
-        const orderNo = this._calculateOrderNo(request, forefront);
+    createInternalRequest(request, forefront) {
+        const orderNo = this.calculateOrderNo(request, forefront);
         const id = uniqueKeyToRequestId(request.uniqueKey);
         if (request.id && request.id !== id) {
             throw new Error('Request ID does not match its uniqueKey.');
@@ -412,7 +413,7 @@ export class RequestQueueBackend extends BaseClient {
             url: request.url,
         };
     }
-    _calculateOrderNo(request, forefront) {
+    calculateOrderNo(request, forefront) {
         if (request.handledAt)
             return null;
         const timestamp = Date.now();

package/owned_or_injected.d.ts

@@ -10,9 +10,7 @@
  * @internal
  */
 export declare class OwnedOrInjected<Injected, Owned extends Injected = Injected> {
-    private _value;
-    private readonly _owned;
-    private _present;
+    #private;
     private constructor();
     /**
      * Resolves a collaborator from an optionally-injected instance. `Injected` is the public/borrowed type exposed via