apify 4.0.0-beta.30 → 4.0.0-beta.32

package/dist/apify_request_queue_backend.d.ts

@@ -73,6 +73,6 @@ export declare abstract class ApifyRequestQueueBackend implements RequestQueueBa
  * @internal
  */
 export declare class AsyncLock {
-    private tail;
+    #private;
     runExclusive<T>(fn: () => Promise<T>): Promise<T>;
 }

package/dist/apify_request_queue_backend.js

@@ -104,11 +104,11 @@ export class ApifyRequestQueueBackend {
  * @internal
  */
 export class AsyncLock {
-    tail = Promise.resolve();
+    #tail = Promise.resolve();
     async runExclusive(fn) {
-        const run = this.tail.then(fn);
+        const run = this.#tail.then(fn);
         // Keep the chain alive even when the critical section throws.
-        this.tail = run.catch(() => { });
+        this.#tail = run.catch(() => { });
         return run;
     }
 }

package/dist/apify_request_queue_shared_backend.d.ts

@@ -13,20 +13,7 @@ import { ApifyRequestQueueBackend } from './apify_request_queue_backend.js';
  * @internal
  */
 export declare class ApifyRequestQueueSharedBackend extends ApifyRequestQueueBackend {
-    /** Ids of requests locked by this client and waiting to be handed out by `fetchNextRequest`. */
-    private readonly headIds;
-    /** Dedup records for requests known to exist on the platform, keyed by id. */
-    private readonly cachedRequestInfo;
-    /** Ids of requests currently being processed by this client. */
-    private readonly inProgressIds;
-    /** Whether the last head read reported any locked requests left in the queue (any client's). */
-    private queueHasLockedRequests?;
-    /** Set after a forefront insert — the next head read starts fresh so the insert is honored. */
-    private shouldCheckForefrontRequests;
-    /** Lock duration applied to fetched requests; raised via `setExpectedRequestProcessingTimeSecs`. */
-    private lockSecs;
-    /** Serializes head reads and reclaims — both reorder the shared head state. */
-    private readonly headLock;
+    #private;
     setExpectedRequestProcessingTimeSecs(secs: number): Promise<void>;
     addBatchOfRequests(requests: RequestSchema[], options?: RequestQueueOperationOptions): Promise<BatchAddRequestsResult>;
     getRequest(uniqueKey: string): Promise<UpdateRequestSchema | undefined>;

package/dist/apify_request_queue_shared_backend.js

@@ -21,23 +21,23 @@ const HEAD_LOCK_LIMIT = 25;
  */
 export class ApifyRequestQueueSharedBackend extends ApifyRequestQueueBackend {
     /** Ids of requests locked by this client and waiting to be handed out by `fetchNextRequest`. */
-    headIds = [];
+    #headIds = [];
     /** Dedup records for requests known to exist on the platform, keyed by id. */
-    cachedRequestInfo = new LruCache({ maxLength: MAX_CACHED_REQUESTS });
+    #cachedRequestInfo = new LruCache({ maxLength: MAX_CACHED_REQUESTS });
     /** Ids of requests currently being processed by this client. */
-    inProgressIds = new Set();
+    #inProgressIds = new Set();
     /** Whether the last head read reported any locked requests left in the queue (any client's). */
-    queueHasLockedRequests;
+    #queueHasLockedRequests;
     /** Set after a forefront insert — the next head read starts fresh so the insert is honored. */
-    shouldCheckForefrontRequests = false;
+    #shouldCheckForefrontRequests = false;
     /** Lock duration applied to fetched requests; raised via `setExpectedRequestProcessingTimeSecs`. */
-    lockSecs = DEFAULT_REQUEST_LOCK_SECS;
+    #lockSecs = DEFAULT_REQUEST_LOCK_SECS;
     /** Serializes head reads and reclaims — both reorder the shared head state. */
-    headLock = new AsyncLock();
+    #headLock = new AsyncLock();
     async setExpectedRequestProcessingTimeSecs(secs) {
         // Only ever raise the lock duration — several consumers may share this client, and a
         // short-lived one must not cut the reservation of a long-running one short.
-        this.lockSecs = Math.max(this.lockSecs, secs);
+        this.#lockSecs = Math.max(this.#lockSecs, secs);
     }
     async addBatchOfRequests(requests, options = {}) {
         const { forefront = false } = options;
@@ -48,7 +48,7 @@ export class ApifyRequestQueueSharedBackend extends ApifyRequestQueueBackend {
         const newRequests = [];
         for (const request of requests) {
             const id = this.requestIdFromUniqueKey(request.uniqueKey);
-            const cached = this.cachedRequestInfo.get(id);
+            const cached = this.#cachedRequestInfo.get(id);
             if (cached) {
                 alreadyPresent.push({
                     requestId: id,
@@ -70,7 +70,7 @@ export class ApifyRequestQueueSharedBackend extends ApifyRequestQueueBackend {
             // A forefront insert changes the head order — have the next head read re-fetch the
             // front of the queue instead of draining the local buffer first.
             if (forefront) {
-                this.shouldCheckForefrontRequests = true;
+                this.#shouldCheckForefrontRequests = true;
             }
         }
         result.processedRequests.push(...alreadyPresent);
@@ -83,9 +83,9 @@ export class ApifyRequestQueueSharedBackend extends ApifyRequestQueueBackend {
         return this.getRequestById(this.requestIdFromUniqueKey(uniqueKey));
     }
     async fetchNextRequest() {
-        const id = await this.headLock.runExclusive(async () => {
+        const id = await this.#headLock.runExclusive(async () => {
             await this.ensureHeadIsNonEmpty();
-            return this.headIds.shift();
+            return this.#headIds.shift();
         });
         if (!id)
             return undefined;
@@ -103,7 +103,7 @@ export class ApifyRequestQueueSharedBackend extends ApifyRequestQueueBackend {
             this.cacheRequestInfo(id, { wasAlreadyHandled: true });
             return undefined;
         }
-        this.inProgressIds.add(id);
+        this.#inProgressIds.add(id);
         return request;
     }
     async markRequestAsHandled(request) {
@@ -111,12 +111,12 @@ export class ApifyRequestQueueSharedBackend extends ApifyRequestQueueBackend {
         // Contract: marking a request that does not exist in the queue is a no-op — it must not be
         // added as a side effect (the platform update endpoint would upsert it).
         if (!(await this.isKnownOrExists(id))) {
-            this.inProgressIds.delete(id);
+            this.#inProgressIds.delete(id);
             return undefined;
         }
         const handledAt = request.handledAt ?? new Date().toISOString();
         const info = await this.updateRequestOnPlatform({ ...request, id, handledAt });
-        this.inProgressIds.delete(id);
+        this.#inProgressIds.delete(id);
         this.cacheRequestInfo(id, { wasAlreadyHandled: true });
         if (!info.wasAlreadyHandled) {
             this.estimatedHandledRequestCount += 1;
@@ -128,10 +128,10 @@ export class ApifyRequestQueueSharedBackend extends ApifyRequestQueueBackend {
         const id = this.requestIdFromUniqueKey(request.uniqueKey);
         // Same contract as `markRequestAsHandled` — never insert as a side effect.
         if (!(await this.isKnownOrExists(id))) {
-            this.inProgressIds.delete(id);
+            this.#inProgressIds.delete(id);
             return undefined;
         }
-        return this.headLock.runExclusive(async () => {
+        return this.#headLock.runExclusive(async () => {
             const info = await this.updateRequestOnPlatform({ ...request, id, handledAt: undefined }, forefront);
             // Release the server-side lock so the request becomes fetchable again immediately —
             // by any consumer — rather than only after the lock expires.
@@ -141,10 +141,10 @@ export class ApifyRequestQueueSharedBackend extends ApifyRequestQueueBackend {
             catch (err) {
                 log.debug(`Failed to delete the lock of a reclaimed request (id: ${id}): ${err.message}`);
             }
-            this.inProgressIds.delete(id);
+            this.#inProgressIds.delete(id);
             this.cacheRequestInfo(id, { wasAlreadyHandled: false });
             if (forefront) {
-                this.shouldCheckForefrontRequests = true;
+                this.#shouldCheckForefrontRequests = true;
             }
             if (info.wasAlreadyHandled) {
                 this.estimatedHandledRequestCount -= 1;
@@ -153,25 +153,25 @@ export class ApifyRequestQueueSharedBackend extends ApifyRequestQueueBackend {
         });
     }
     async isEmpty() {
-        return this.headLock.runExclusive(async () => {
-            if (this.headIds.length > 0)
+        return this.#headLock.runExclusive(async () => {
+            if (this.#headIds.length > 0)
                 return false;
             await this.listAndLockHead(1);
-            return this.headIds.length === 0;
+            return this.#headIds.length === 0;
         });
     }
     async isFinished() {
-        return this.headLock.runExclusive(async () => {
-            if (this.headIds.length > 0)
+        return this.#headLock.runExclusive(async () => {
+            if (this.#headIds.length > 0)
                 return false;
             // The head read also refreshes `queueHasLockedRequests`, so the order matters here.
             await this.listAndLockHead(1);
-            return this.headIds.length === 0 && !this.queueHasLockedRequests;
+            return this.#headIds.length === 0 && !this.#queueHasLockedRequests;
         });
     }
     /** Must be called with the head lock held. */
     async ensureHeadIsNonEmpty() {
-        if (this.headIds.length > 1 && !this.shouldCheckForefrontRequests) {
+        if (this.#headIds.length > 1 && !this.#shouldCheckForefrontRequests) {
             return;
         }
         await this.listAndLockHead(HEAD_LOCK_LIMIT);
@@ -181,31 +181,31 @@ export class ApifyRequestQueueSharedBackend extends ApifyRequestQueueBackend {
         // After a forefront insert the local buffer no longer starts at the true front of the
         // queue — re-fetch the front and keep the already-locked leftovers for afterwards.
         let leftoverIds = [];
-        if (this.shouldCheckForefrontRequests) {
-            leftoverIds = this.headIds.splice(0);
-            this.shouldCheckForefrontRequests = false;
+        if (this.#shouldCheckForefrontRequests) {
+            leftoverIds = this.#headIds.splice(0);
+            this.#shouldCheckForefrontRequests = false;
         }
-        const head = await this.client.listAndLockHead({ limit, lockSecs: this.lockSecs });
-        this.queueHasLockedRequests = head.queueHasLockedRequests;
+        const head = await this.client.listAndLockHead({ limit, lockSecs: this.#lockSecs });
+        this.#queueHasLockedRequests = head.queueHasLockedRequests;
         for (const item of head.items) {
-            if (this.inProgressIds.has(item.id))
+            if (this.#inProgressIds.has(item.id))
                 continue;
-            if (this.headIds.includes(item.id) || leftoverIds.includes(item.id))
+            if (this.#headIds.includes(item.id) || leftoverIds.includes(item.id))
                 continue;
             this.cacheRequestInfo(item.id, { wasAlreadyHandled: false });
-            this.headIds.push(item.id);
+            this.#headIds.push(item.id);
         }
-        this.headIds.push(...leftoverIds);
+        this.#headIds.push(...leftoverIds);
     }
     async isKnownOrExists(id) {
-        if (this.inProgressIds.has(id) || this.cachedRequestInfo.get(id)) {
+        if (this.#inProgressIds.has(id) || this.#cachedRequestInfo.get(id)) {
             return true;
         }
         return (await this.getRequestById(id)) !== undefined;
     }
     cacheRequestInfo(id, info) {
         // `LruCache.add` does not overwrite existing entries, so remove first.
-        this.cachedRequestInfo.remove(id);
-        this.cachedRequestInfo.add(id, info);
+        this.#cachedRequestInfo.remove(id);
+        this.#cachedRequestInfo.add(id, info);
     }
 }

package/dist/apify_request_queue_single_backend.d.ts

@@ -22,16 +22,7 @@ import { ApifyRequestQueueBackend } from './apify_request_queue_backend.js';
  * @internal
  */
 export declare class ApifyRequestQueueSingleBackend extends ApifyRequestQueueBackend {
-    /** Local estimate of the queue head — request ids in the order they should be fetched. */
-    private readonly headIds;
-    /** Unhandled full request objects added by (or fetched through) this client, keyed by id. */
-    private readonly cachedRequests;
-    /** Ids of requests known to be already handled — cheap dedup without caching full objects. */
-    private readonly handledIds;
-    /** Ids of requests currently being processed by this client. */
-    private readonly inProgressIds;
-    /** Memoized one-time prefetch of existing queue contents into the local caches. */
-    private initCachesPromise?;
+    #private;
     addBatchOfRequests(requests: RequestSchema[], options?: RequestQueueOperationOptions): Promise<BatchAddRequestsResult>;
     getRequest(uniqueKey: string): Promise<UpdateRequestSchema | undefined>;
     fetchNextRequest(): Promise<UpdateRequestSchema | undefined>;

package/dist/apify_request_queue_single_backend.js

@@ -32,25 +32,25 @@ const INIT_CACHES_REQUEST_LIMIT = 10_000;
  */
 export class ApifyRequestQueueSingleBackend extends ApifyRequestQueueBackend {
     /** Local estimate of the queue head — request ids in the order they should be fetched. */
-    headIds = [];
+    #headIds = [];
     /** Unhandled full request objects added by (or fetched through) this client, keyed by id. */
-    cachedRequests = new LruCache({ maxLength: MAX_CACHED_REQUESTS });
+    #cachedRequests = new LruCache({ maxLength: MAX_CACHED_REQUESTS });
     /** Ids of requests known to be already handled — cheap dedup without caching full objects. */
-    handledIds = new Set();
+    #handledIds = new Set();
     /** Ids of requests currently being processed by this client. */
-    inProgressIds = new Set();
+    #inProgressIds = new Set();
     /** Memoized one-time prefetch of existing queue contents into the local caches. */
-    initCachesPromise;
+    #initCachesPromise;
     async addBatchOfRequests(requests, options = {}) {
         const { forefront = false } = options;
-        await (this.initCachesPromise ??= this.initCaches());
+        await (this.#initCachesPromise ??= this.initCaches());
         // Split the batch into requests we already know about (dedup them locally — a platform
         // write costs an API call and a paid write operation) and genuinely new ones.
         const alreadyPresent = [];
         const newRequests = [];
         for (const request of requests) {
             const id = this.requestIdFromUniqueKey(request.uniqueKey);
-            if (this.handledIds.has(id)) {
+            if (this.#handledIds.has(id)) {
                 alreadyPresent.push({
                     requestId: id,
                     uniqueKey: request.uniqueKey,
@@ -58,7 +58,7 @@ export class ApifyRequestQueueSingleBackend extends ApifyRequestQueueBackend {
                     wasAlreadyHandled: true,
                 });
             }
-            else if (this.cachedRequests.get(id)) {
+            else if (this.#cachedRequests.get(id)) {
                 alreadyPresent.push({
                     requestId: id,
                     uniqueKey: request.uniqueKey,
@@ -83,15 +83,15 @@ export class ApifyRequestQueueSingleBackend extends ApifyRequestQueueBackend {
                 if (!processed)
                     continue; // rejected by the platform, reported in `unprocessedRequests`
                 if (processed.wasAlreadyHandled) {
-                    this.handledIds.add(processed.requestId);
+                    this.#handledIds.add(processed.requestId);
                     continue;
                 }
                 this.cacheRequest({ ...request, id: processed.requestId });
                 if (forefront) {
-                    this.headIds.unshift(processed.requestId);
+                    this.#headIds.unshift(processed.requestId);
                 }
                 else {
-                    this.headIds.push(processed.requestId);
+                    this.#headIds.push(processed.requestId);
                 }
             }
         }
@@ -101,16 +101,16 @@ export class ApifyRequestQueueSingleBackend extends ApifyRequestQueueBackend {
     }
     async getRequest(uniqueKey) {
         const id = this.requestIdFromUniqueKey(uniqueKey);
-        const cached = this.cachedRequests.get(id);
+        const cached = this.#cachedRequests.get(id);
         if (cached)
             return cached;
         const request = await this.getRequestById(id);
         if (!request)
             return undefined;
         // Requests already in progress are ones the client knows about — no caching needed.
-        if (!this.inProgressIds.has(id)) {
+        if (!this.#inProgressIds.has(id)) {
             if (request.handledAt) {
-                this.handledIds.add(id);
+                this.#handledIds.add(id);
             }
             else {
                 this.cacheRequest(request);
@@ -120,24 +120,24 @@ export class ApifyRequestQueueSingleBackend extends ApifyRequestQueueBackend {
     }
     async fetchNextRequest() {
         await this.ensureHeadIsNonEmpty();
-        while (this.headIds.length > 0) {
-            const id = this.headIds.shift();
-            if (this.inProgressIds.has(id) || this.handledIds.has(id)) {
+        while (this.#headIds.length > 0) {
+            const id = this.#headIds.shift();
+            if (this.#inProgressIds.has(id) || this.#handledIds.has(id)) {
                 continue;
             }
-            this.inProgressIds.add(id);
+            this.#inProgressIds.add(id);
             // Requests added by this client are served straight from the cache; only requests
             // discovered via `listHead` (added by another producer) need a round-trip.
-            const request = this.cachedRequests.get(id) ?? (await this.getRequestById(id));
+            const request = this.#cachedRequests.get(id) ?? (await this.getRequestById(id));
             if (!request) {
-                this.inProgressIds.delete(id);
+                this.#inProgressIds.delete(id);
                 continue;
             }
             if (request.handledAt) {
                 // Handled elsewhere in the meantime — skip it and remember the outcome.
-                this.inProgressIds.delete(id);
-                this.handledIds.add(id);
-                this.cachedRequests.remove(id);
+                this.#inProgressIds.delete(id);
+                this.#handledIds.add(id);
+                this.#cachedRequests.remove(id);
                 continue;
             }
             return request;
@@ -149,14 +149,14 @@ export class ApifyRequestQueueSingleBackend extends ApifyRequestQueueBackend {
         // Contract: marking a request that does not exist in the queue is a no-op — it must not be
         // added as a side effect (the platform update endpoint would upsert it).
         if (!(await this.isKnownOrExists(id))) {
-            this.inProgressIds.delete(id);
+            this.#inProgressIds.delete(id);
             return undefined;
         }
         const handledAt = request.handledAt ?? new Date().toISOString();
         const info = await this.updateRequestOnPlatform({ ...request, id, handledAt });
-        this.inProgressIds.delete(id);
-        this.handledIds.add(id);
-        this.cachedRequests.remove(id);
+        this.#inProgressIds.delete(id);
+        this.#handledIds.add(id);
+        this.#cachedRequests.remove(id);
         if (!info.wasAlreadyHandled) {
             this.estimatedHandledRequestCount += 1;
         }
@@ -167,24 +167,24 @@ export class ApifyRequestQueueSingleBackend extends ApifyRequestQueueBackend {
         const id = this.requestIdFromUniqueKey(request.uniqueKey);
         // Same contract as `markRequestAsHandled` — never insert as a side effect.
         if (!(await this.isKnownOrExists(id))) {
-            this.inProgressIds.delete(id);
+            this.#inProgressIds.delete(id);
             return undefined;
         }
         // Reclaiming returns the request to the queue for reprocessing.
         const reclaimed = { ...request, id, handledAt: undefined };
         const info = await this.updateRequestOnPlatform(reclaimed, forefront);
-        this.inProgressIds.delete(id);
-        this.handledIds.delete(id);
+        this.#inProgressIds.delete(id);
+        this.#handledIds.delete(id);
         this.cacheRequest(reclaimed);
         // Return the id to the local head estimate right away — the platform head read can lag a
         // few seconds behind the update, and `isFinished` must never report `true` while a
         // reclaimed request is still waiting to be reprocessed.
-        if (!this.headIds.includes(id)) {
+        if (!this.#headIds.includes(id)) {
             if (forefront) {
-                this.headIds.unshift(id);
+                this.#headIds.unshift(id);
             }
             else {
-                this.headIds.push(id);
+                this.#headIds.push(id);
             }
         }
         if (info.wasAlreadyHandled) {
@@ -194,28 +194,28 @@ export class ApifyRequestQueueSingleBackend extends ApifyRequestQueueBackend {
     }
     async isEmpty() {
         await this.ensureHeadIsNonEmpty();
-        return this.headIds.length === 0;
+        return this.#headIds.length === 0;
     }
     async isFinished() {
-        return (await this.isEmpty()) && this.inProgressIds.size === 0;
+        return (await this.isEmpty()) && this.#inProgressIds.size === 0;
     }
     async ensureHeadIsNonEmpty() {
-        if (this.headIds.length <= 1) {
+        if (this.#headIds.length <= 1) {
             await this.listHead();
         }
     }
     async listHead() {
         // The head read returns in-progress requests too, so fetch enough to find new ones.
-        const limit = Math.min(MAX_HEAD_ITEMS, DESIRED_NEW_HEAD_ITEMS + this.inProgressIds.size);
+        const limit = Math.min(MAX_HEAD_ITEMS, DESIRED_NEW_HEAD_ITEMS + this.#inProgressIds.size);
         const head = await this.client.listHead({ limit });
         for (const item of head.items) {
-            if (this.inProgressIds.has(item.id) || this.handledIds.has(item.id)) {
+            if (this.#inProgressIds.has(item.id) || this.#handledIds.has(item.id)) {
                 continue;
             }
             // `headIds` is nearly drained whenever this runs (see `ensureHeadIsNonEmpty`), so the
             // linear dedup scan stays cheap.
-            if (!this.headIds.includes(item.id)) {
-                this.headIds.push(item.id);
+            if (!this.#headIds.includes(item.id)) {
+                this.#headIds.push(item.id);
             }
         }
     }
@@ -229,7 +229,7 @@ export class ApifyRequestQueueSingleBackend extends ApifyRequestQueueBackend {
             const response = await this.client.listRequests({ limit: INIT_CACHES_REQUEST_LIMIT });
             for (const request of response.items) {
                 if (request.handledAt) {
-                    this.handledIds.add(request.id);
+                    this.#handledIds.add(request.id);
                 }
                 else {
                     this.cacheRequest(request);
@@ -243,14 +243,14 @@ export class ApifyRequestQueueSingleBackend extends ApifyRequestQueueBackend {
         }
     }
     async isKnownOrExists(id) {
-        if (this.inProgressIds.has(id) || this.handledIds.has(id) || this.cachedRequests.get(id)) {
+        if (this.#inProgressIds.has(id) || this.#handledIds.has(id) || this.#cachedRequests.get(id)) {
             return true;
         }
         return (await this.getRequestById(id)) !== undefined;
     }
     cacheRequest(request) {
         // `LruCache.add` does not overwrite existing entries, so remove first.
-        this.cachedRequests.remove(request.id);
-        this.cachedRequests.add(request.id, request);
+        this.#cachedRequests.remove(request.id);
+        this.#cachedRequests.add(request.id, request);
     }
 }

package/dist/apify_storage_backend.d.ts

@@ -1,7 +1,7 @@
 import { AsyncLocalStorage } from 'node:async_hooks';
 import type { DatasetBackend, KeyValueStoreBackend, RequestQueueBackend, StorageBackend, StorageIdentifier } from '@crawlee/types';
 import type { ApifyClient } from 'apify-client';
-import type { RequestQueueAccessMode } from './apify_request_queue_backend.js';
+import { type RequestQueueAccessMode } from './apify_request_queue_backend.js';
 import { type ChargeResult, type ChargingManager } from './charging.js';
 import type { Configuration } from './configuration.js';
 type StorageType = 'Dataset' | 'KeyValueStore' | 'RequestQueue';
@@ -62,14 +62,7 @@ export interface ApifyStorageBackendOptions {
  * ```
  */
 export declare class ApifyStorageBackend implements StorageBackend {
-    private readonly client;
-    private readonly config?;
-    private readonly requestQueueAccess;
-    private readonly getChargingManager?;
-    /** Unnamed storages created for aliases in this process, so an alias maps to one storage. */
-    private readonly aliasIdCache;
-    /** Fallback request queue client key when the run id is unavailable — one per backend. */
-    private fallbackClientKey?;
+    #private;
     constructor(client: ApifyClient, options?: ApifyStorageBackendOptions);
     /**
      * Partitions crawlee's storage-instance cache by API base URL and token, so the same storage
@@ -78,6 +71,8 @@ export declare class ApifyStorageBackend implements StorageBackend {
      * and `shared` mode at once is not supported, and whichever backend opens it first wins.
      */
     getStorageBackendCacheKey(): string;
+    /** Short digest of the API base URL and token — identifies the credentials a storage was opened with. */
+    private credentialsHash;
     storageExists(id: string, type: StorageType): Promise<boolean>;
     createDatasetBackend(options?: StorageIdentifier): Promise<DatasetBackend>;
     createKeyValueStoreBackend(options?: StorageIdentifier): Promise<KeyValueStoreBackend>;
@@ -97,11 +92,27 @@ export declare class ApifyStorageBackend implements StorageBackend {
      * Resolves a crawlee {@link StorageIdentifier} to a platform storage id.
      *
      * Aliases resolve to unnamed storages: the reserved `__default__` alias maps to the run's
-     * default storage, and other aliases to the storages declared in the Actor's schema (via the
-     * `ACTOR_STORAGES_JSON` environment variable, maintained by the platform). Outside the
-     * platform, an unnamed storage is created per alias instead (remembered for this process only).
+     * default storage, and an alias declared in the Actor's schema to the storage the platform
+     * created for it (via the `ACTOR_STORAGES_JSON` environment variable). Any other alias gets an
+     * unnamed storage of its own — crawlee mints aliases at runtime, one per extra crawler instance
+     * and one per throttled domain, so an undeclared alias is not an error.
      */
     private resolveId;
+    /**
+     * Returns the unnamed storage backing `alias`, creating it on first use.
+     *
+     * On the platform the mapping is persisted, so a migrated run reopens the same storages rather
+     * than empty ones — aliased request queues hold live requests. Serialized, so one alias means
+     * one storage and the mapping's read-modify-write cannot drop entries.
+     */
+    private resolveAliasId;
+    /**
+     * Re-reads the record first, so a second backend in this process does not drop its entries.
+     * Logged rather than thrown: a lost entry only costs a re-created storage after a migration.
+     */
+    private persistAliasId;
+    /** The run's default key-value store, where the mapping lives — `undefined` off the platform. */
+    private aliasMappingStore;
     /** Looks an alias up in the Actor's schema storages (the `ACTOR_STORAGES_JSON` env var). */
     private aliasFromActorStorages;
     private resourceClient;