@salesforce/lds-runtime-aura 1.287.0-dev14 → 1.287.0-dev16

package/dist/ldsEngineCreator.js

@@ -16,6 +16,7 @@ import { HttpStatusCode, InMemoryStore as InMemoryStore$1, Environment, Luvio, I
 import ldsTrackedFieldsBehaviorGate from '@salesforce/gate/lds.useNewTrackedFieldBehavior';
 import usePredictiveLoading from '@salesforce/gate/lds.usePredictiveLoading';
 import useRelatedListsPredictions from '@salesforce/gate/lds.pdl.useRelatedListsPredictions';
+import applyPredictionRequestLimit from '@salesforce/gate/lds.pdl.applyRequestLimit';
 import { instrument, getRecordAvatarsAdapterFactory, getRecordAdapterFactory, coerceFieldIdArray, getRecordsAdapterFactory, getRecordActionsAdapterFactory, getObjectInfosAdapterFactory, coerceObjectIdArray, getObjectInfoAdapterFactory, coerceObjectId, getRelatedListsActionsAdapterFactory, getRelatedListInfoBatchAdapterFactory, getRelatedListRecordsBatchAdapterFactory, getRelatedListRecordsAdapterFactory, configuration, InMemoryRecordRepresentationQueryEvaluator, UiApiNamespace, RecordRepresentationRepresentationType, registerPrefetcher } from 'force/ldsAdaptersUiapi';
 import { withRegistration as withRegistration$1 } from 'force/luvioRegistry';
 import oneStoreEnabled from '@salesforce/gate/lds.oneStoreEnabled.ltng';
@@ -1359,9 +1360,10 @@ function logCRUDLightningInteraction(eventSource, attributes) {
 const instrumentation = new Instrumentation();
 
 class ApplicationPredictivePrefetcher {
-    constructor(context, repository, requestRunner) {
+    constructor(context, repository, requestRunner, options) {
         this.repository = repository;
         this.requestRunner = requestRunner;
+        this.options = options;
         this.isRecording = false;
         this.queuedPredictionRequests = [];
         this._context = context;
@@ -1380,6 +1382,7 @@ class ApplicationPredictivePrefetcher {
     }
     startRecording() {
         this.isRecording = true;
+        this.repository.markPageStart();
         this.repository.clearRequestBuffer();
     }
     saveRequest(request) {
@@ -1394,17 +1397,13 @@ class ApplicationPredictivePrefetcher {
         }, PDL_EXECUTE_ASYNC_OPTIONS);
     }
     async predict() {
-        const exactPageRequests = (await this.repository.getPageRequests(this.context)) || [];
-        const similarPageRequests = await this.getSimilarPageRequests();
         const alwaysRequests = this.page.getAlwaysRunRequests();
-        const predictedRequests = [
-            ...alwaysRequests,
-            ...this.requestRunner.reduceRequests([
-                ...exactPageRequests,
-                ...similarPageRequests,
-                ...this.page.getAlwaysRunRequests(),
-            ]),
-        ];
+        const similarPageRequests = await this.getSimilarPageRequests();
+        const exactPageRequests = (await this.repository.getPageRequests(this.context)) || [];
+        const reducedRequests = this.requestRunner
+            .reduceRequests([...exactPageRequests, ...similarPageRequests])
+            .map((entry) => entry.request);
+        const predictedRequests = [...alwaysRequests, ...reducedRequests];
         this.queuedPredictionRequests.push(...predictedRequests);
         return Promise.all(predictedRequests.map((request) => this.requestRunner.runRequest(request))).then();
     }
@@ -1424,19 +1423,76 @@ class ApplicationPredictivePrefetcher {
         if (this.page.similarContext !== undefined) {
             const similarPageRequests = this.repository.getPageRequests(this.page.similarContext);
             if (similarPageRequests !== undefined) {
-                resolvedSimilarPageRequests = similarPageRequests.map((request) => this.page.resolveSimilarRequest(request));
+                resolvedSimilarPageRequests = similarPageRequests.map((entry) => {
+                    return {
+                        ...entry,
+                        request: this.page.resolveSimilarRequest(entry.request),
+                    };
+                });
             }
         }
         return resolvedSimilarPageRequests;
     }
 }
 
+/**
+ * Runs a list of requests with a specified concurrency limit.
+ *
+ * @template Request - The type of the requests being processed.
+ * @param {RequestEntry<Request>[]} requests - An array of request entries to be processed in the array order.
+ * @param {RequestRunner<Request>} runner - The runner instance responsible for executing the requests.
+ * @param {number} concurrentRequestsLimit - The maximum number of concurrent requests allowed.
+ * @param {number} pageStartTime - The start time of the page load, used to calculate the time elapsed since the page starts loading.
+ * @returns {Promise<void>} A promise that resolves when all requests have been processed.
+ *
+ * This function manages a queue of pending requests and processes them with a concurrency limit.
+ * Requests are only processed if their `requestTime` is less than the time elapsed since `pageStartTime`.
+ */
+async function runRequestsWithLimit(requests, runner, concurrentRequestsLimit, pageStartTime) {
+    // queue for pending prediction requests
+    const requestQueue = [...requests];
+    // Function to process the next request in the queue
+    const processNextRequest = async (verifyPastTime = true) => {
+        const timeInWaterfall = Date.now() - pageStartTime;
+        while (requestQueue.length > 0 &&
+            verifyPastTime &&
+            requestQueue[0].requestMetadata.requestTime <= timeInWaterfall) {
+            requestQueue.shift();
+        }
+        if (requestQueue.length > 0) {
+            // (!) requestQueue will always have at least one element ensured by the above check.
+            const nextRequest = requestQueue.shift();
+            try {
+                // Run the request and wait for it to complete
+                await runner.runRequest(nextRequest.request);
+            }
+            finally {
+                await processNextRequest();
+            }
+        }
+    };
+    // Start processing requests up to concurrentRequestsLimit
+    const initialRequests = Math.min(concurrentRequestsLimit, requestQueue.length);
+    const promises = [];
+    for (let i = 0; i < initialRequests; i++) {
+        // Initial requests should always execute, without verifying if they are past due.
+        // Reasoning:
+        //   It may be that one of the alwaysRequest (with 0 as start time) that is reduced
+        //   with the regular requests to make these to have 0 as the initial time in the waterfall.
+        //   Because predictions are behind an await (see W-16139321), it could be that when this code is evaluated
+        //   is already past time for the request.
+        promises.push(processNextRequest(false));
+    }
+    // Wait for all initial requests to complete
+    await Promise.all(promises);
+}
+
 class LexPredictivePrefetcher extends ApplicationPredictivePrefetcher {
     constructor(context, repository, requestRunner, 
     // These strategies need to be in sync with the "predictiveDataLoadCapable" list
     // from scripts/lds-uiapi-plugin.js
-    requestStrategies) {
-        super(context, repository, requestRunner);
+    requestStrategies, options) {
+        super(context, repository, requestRunner, options);
         this.requestStrategies = requestStrategies;
         this.page = this.getPage();
     }
@@ -1446,6 +1502,35 @@ class LexPredictivePrefetcher extends ApplicationPredictivePrefetcher {
         }
         return new LexDefaultPage(this.context);
     }
+    async predict() {
+        const alwaysRequests = this.page.getAlwaysRunRequests();
+        // IMPORTANT: The `await` has no effect on this operation because `getSimilarPageRequests`
+        //            and `getExactPageRequest` are sync; however if removed, it will have a negative
+        //            effect when used with Aura Network: predictions will be boxcar'd, which likely will
+        //            result in a perf regression.
+        const similarPageRequests = await this.getSimilarPageRequests();
+        const exactPageRequests = (await this.repository.getPageRequests(this.context)) || [];
+        const alwaysRequestEntries = alwaysRequests.map((request) => {
+            return {
+                request,
+                requestMetadata: { requestTime: 0 }, // ensures always requests are executed, and executed first.
+            };
+        });
+        const reducedPredictions = this.requestRunner.reduceRequests([
+            ...exactPageRequests,
+            ...similarPageRequests,
+            ...alwaysRequestEntries,
+        ]); // In future - remove alwaysRequestEntries when on OneStore
+        // Always requests must go by themself - Some of them are essential to keep the page rendering at the beginning.
+        const predictedRequestsWithLimit = [...alwaysRequestEntries, ...reducedPredictions].sort((a, b) => a.requestMetadata.requestTime - b.requestMetadata.requestTime); // In future - choose sort algorithm via Gate?;
+        await runRequestsWithLimit(predictedRequestsWithLimit, this.requestRunner, this.options.inflightRequestLimit, 
+        // `this.repository.pageStartTime` would be the correct here, but because
+        // the await hack (see W-16139321), there's some delta by the time this executed,
+        // on the other hand, when W-16139321 is fixed,
+        // when doing predict+watch, it could be (set in watch) repository.startTime is not set yet,
+        // Date.now() is a better alternative, that is correct, and works on both cases.
+        Date.now());
+    }
 }
 
 // Copy-pasted from adapter-utils. This util should be extracted from generated code and imported in prefetch repository.
@@ -1542,10 +1627,14 @@ class PrefetchRepository {
     constructor(storage) {
         this.storage = storage;
         this.requestBuffer = new Map();
+        this.pageStartTime = Date.now();
     }
     clearRequestBuffer() {
         this.requestBuffer.clear();
     }
+    markPageStart() {
+        this.pageStartTime = Date.now();
+    }
     async flushRequestsToStorage() {
         const setPromises = [];
         for (const [id, batch] of this.requestBuffer) {
@@ -1577,7 +1666,7 @@ class PrefetchRepository {
         const batchForKey = this.requestBuffer.get(identifier) || [];
         batchForKey.push({
             request,
-            requestTime: Date.now(),
+            requestTime: Date.now() - this.pageStartTime,
         });
         this.requestBuffer.set(identifier, batchForKey);
     }
@@ -1590,7 +1679,7 @@ class PrefetchRepository {
         if (page === undefined) {
             return [];
         }
-        return page.requests.map((requestEntry) => requestEntry.request);
+        return page.requests;
     }
 }
 
@@ -1623,7 +1712,7 @@ class LuvioAdapterRequestStrategy extends RequestStrategy {
      * @returns
      */
     filterRequests(unfilteredRequests) {
-        return unfilteredRequests.filter((request) => request.adapterName === this.adapterName);
+        return unfilteredRequests.filter((entry) => entry.request.adapterName === this.adapterName);
     }
     /**
      * Reduce requests by combining those based on a strategies implementations
@@ -1641,9 +1730,15 @@ class LuvioAdapterRequestStrategy extends RequestStrategy {
                 const combinedRequest = { ...currentRequest };
                 for (let j = i + 1; j < n; j++) {
                     const hasNotBeenVisited = !visitedRequests.has(requests[j]);
-                    const canCombineConfigs = this.canCombine(combinedRequest.config, requests[j].config);
+                    const canCombineConfigs = this.canCombine(combinedRequest.request.config, requests[j].request.config);
                     if (hasNotBeenVisited && canCombineConfigs) {
-                        combinedRequest.config = this.combineRequests(combinedRequest.config, requests[j].config);
+                        combinedRequest.request.config = this.combineRequests(combinedRequest.request.config, requests[j].request.config);
+                        if (combinedRequest.requestMetadata.requestTime >
+                            requests[j].requestMetadata.requestTime) {
+                            // This logic is debateable - Currently this always assigns the lowest requestTime to a reduced request.
+                            combinedRequest.requestMetadata.requestTime =
+                                requests[j].requestMetadata.requestTime;
+                        }
                         visitedRequests.add(requests[j]);
                     }
                 }
@@ -1959,6 +2054,14 @@ class GetRecordActionsRequestStrategy extends LuvioAdapterRequestStrategy {
 }
 
 const GET_OBJECT_INFO_BATCH_ADAPTER_NAME = 'getObjectInfos';
+/**
+ * Returns true if A is a superset of B
+ * @param a
+ * @param b
+ */
+function isSuperSet(a, b) {
+    return b.every((oan) => a.has(oan));
+}
 class GetObjectInfosRequestStrategy extends LuvioAdapterRequestStrategy {
     constructor() {
         super(...arguments);
@@ -1978,6 +2081,43 @@ class GetObjectInfosRequestStrategy extends LuvioAdapterRequestStrategy {
             },
         };
     }
+    /**
+     * Reduces the given GetObjectInfosRequest requests by eliminating those for which config.objectApiNames
+     * is a subset of another GetObjectInfosRequest.
+     *
+     * @param unfilteredRequests - Array of unfiltered requests
+     * @returns RequestEntry<GetObjectInfosRequest>[] - Array of reduced requests
+     */
+    reduce(unfilteredRequests) {
+        // Filter and sort requests by the length of objectApiNames in ascending order.
+        // This ensures a superset of request (i) can only be found in a request (j) such that i < j.
+        const objectInfosRequests = this.filterRequests(unfilteredRequests).sort((a, b) => a.request.config.objectApiNames.length - b.request.config.objectApiNames.length);
+        // Convert request configurations to sets for easier comparison, avoiding a new set construction each iteration.
+        const requestConfigAsSet = objectInfosRequests.map((r) => new Set(r.request.config.objectApiNames));
+        const reducedRequests = [];
+        // Iterate over each request to determine if it is a subset of others
+        for (let i = 0, n = objectInfosRequests.length; i < n; i++) {
+            const current = objectInfosRequests[i];
+            const { request: { config: currentRequestConfig }, requestMetadata: currentRequestMetadata, } = current;
+            let isCurrentSubsetOfOthers = false;
+            // Check if the current request is a subset of any subsequent requests
+            for (let j = i + 1; j < n; j++) {
+                const possibleSuperset = objectInfosRequests[j];
+                if (isSuperSet(requestConfigAsSet[j], currentRequestConfig.objectApiNames)) {
+                    isCurrentSubsetOfOthers = true;
+                    if (currentRequestMetadata.requestTime <
+                        possibleSuperset.requestMetadata.requestTime) {
+                        possibleSuperset.requestMetadata.requestTime =
+                            currentRequestMetadata.requestTime;
+                    }
+                }
+            }
+            if (!isCurrentSubsetOfOthers) {
+                reducedRequests.push(current);
+            }
+        }
+        return reducedRequests;
+    }
 }
 
 class GetObjectInfoRequestStrategy extends LuvioAdapterRequestStrategy {
@@ -2028,13 +2168,13 @@ class GetObjectInfoRequestStrategy extends LuvioAdapterRequestStrategy {
      * @returns
      */
     reduce(unfilteredRequests) {
-        const objectApiNamesInBatchRequest = unfilteredRequests.filter((request) => request.adapterName === GET_OBJECT_INFO_BATCH_ADAPTER_NAME).reduce((acc, { config }) => {
-            config.objectApiNames.forEach((apiName) => acc.add(apiName));
+        const objectApiNamesInBatchRequest = unfilteredRequests.filter((entry) => entry.request.adapterName === GET_OBJECT_INFO_BATCH_ADAPTER_NAME).reduce((acc, { request }) => {
+            request.config.objectApiNames.forEach((apiName) => acc.add(apiName));
             return acc;
         }, new Set());
         const singleRequests = this.filterRequests(unfilteredRequests);
-        return singleRequests.filter((request) => {
-            return !objectApiNamesInBatchRequest.has(request.config.objectApiName);
+        return singleRequests.filter((singleEntry) => {
+            return !objectApiNamesInBatchRequest.has(singleEntry.request.config.objectApiName);
         });
     }
 }
@@ -2234,19 +2374,19 @@ class GetRelatedListRecordsRequestStrategy extends LuvioAdapterRequestStrategy {
      */
     reduce(unfilteredRequests) {
         // Batch requests by [parentRecordId]->[RelatedListIds]
-        const batchRequests = unfilteredRequests.filter((request) => request.adapterName === GET_RELATED_LIST_RECORDS_BATCH_ADAPTER_NAME).reduce((acc, request) => {
+        const batchRequests = unfilteredRequests.filter((entry) => entry.request.adapterName === GET_RELATED_LIST_RECORDS_BATCH_ADAPTER_NAME).reduce((acc, entry) => {
             // required properties, enforced by adapter typecheck
-            const { parentRecordId, relatedListParameters } = request.config;
+            const { parentRecordId, relatedListParameters } = entry.request.config;
             const existingRlSet = acc.get(parentRecordId) || new Set();
             // relatedListId enforced by adapter typecheck
             relatedListParameters.forEach((rlParam) => existingRlSet.add(rlParam.relatedListId));
             acc.set(parentRecordId, existingRlSet);
             return acc;
         }, new Map());
-        const singleRequests = unfilteredRequests.filter((request) => request.adapterName === this.adapterName);
-        return singleRequests.filter((request) => {
+        const singleRequests = unfilteredRequests.filter((entry) => entry.request.adapterName === this.adapterName);
+        return singleRequests.filter((entry) => {
             // required props enforced by adapter typecheck
-            const { parentRecordId, relatedListId } = request.config;
+            const { parentRecordId, relatedListId } = entry.request.config;
             const batchForParentRecordId = batchRequests.get(parentRecordId);
             return !(batchForParentRecordId && batchForParentRecordId.has(relatedListId));
         });
@@ -2326,7 +2466,7 @@ const DEFAULT_STORAGE_OPTIONS = {
     persistent: true,
     secure: true,
     maxSize: 7 * 1024 * 1024,
-    expiration: 12 * 60 * 60,
+    expiration: 5 * 24 * 60 * 60,
     clearOnInit: false,
     debugLogging: false,
     version: 3,
@@ -2531,10 +2671,22 @@ function setupQueryEvaluators(luvio, store) {
     luvio.registerTypeQueryEvaluator(UiApiNamespace, RecordRepresentationRepresentationType, recordRepresentationQueryEvaluator);
 }
 let __lexPrefetcher;
+const HARDCODED_REQUEST_LIMIT = 9;
+function getInflightRequestLimit() {
+    try {
+        return window['$A'].clientService.maxAllowedParallelXHRCounts() - 3;
+    }
+    catch (e) {
+        return HARDCODED_REQUEST_LIMIT;
+    }
+}
 function setupPredictivePrefetcher(luvio) {
     const storage = buildAuraPrefetchStorage();
     const repository = new PrefetchRepository(storage);
     const requestRunner = new LexRequestRunner(luvio);
+    const inflightRequestLimit = applyPredictionRequestLimit.isOpen({ fallback: false })
+        ? getInflightRequestLimit()
+        : 1000;
     const prefetcher = new LexPredictivePrefetcher({ context: 'unknown' }, repository, requestRunner, {
         getRecord: new GetRecordRequestStrategy(),
         getRecords: new GetRecordsRequestStrategy(),
@@ -2546,6 +2698,8 @@ function setupPredictivePrefetcher(luvio) {
         getRelatedListRecords: new GetRelatedListRecordsRequestStrategy(),
         getRelatedListRecordsBatch: new GetRelatedListRecordsBatchRequestStrategy(),
         getRelatedListInfoBatch: new GetRelatedListInfoBatchRequestStrategy(),
+    }, {
+        inflightRequestLimit,
     });
     registerPrefetcher(luvio, prefetcher);
     __lexPrefetcher = prefetcher;
@@ -2682,4 +2836,4 @@ function ldsEngineCreator() {
 }
 
 export { buildPredictorForContext, ldsEngineCreator as default, initializeLDS, initializeOneStore };
-// version: 1.287.0-dev14-85b5de0a8f
+// version: 1.287.0-dev16-db839640ab

package/dist/types/predictive-loading/common/index.d.ts

@@ -2,3 +2,9 @@ export declare const PDL_EXECUTE_ASYNC_OPTIONS: {
     LOG_ERROR_ONLY: boolean;
     ERROR_SCOPE: string;
 };
+export type RequestEntry<Request> = {
+    request: Request;
+    requestMetadata: {
+        requestTime: number;
+    };
+};

package/dist/types/predictive-loading/prefetcher/lex-predictive-prefetcher.d.ts

@@ -1,5 +1,6 @@
-import type { DefaultPageContext, PredictivePrefetchPage } from '../pages';
 import { ApplicationPredictivePrefetcher } from './predictive-prefetcher';
+import type { DefaultPageContext, PredictivePrefetchPage } from '../pages';
+import type { PrefetcherOptions } from './predictive-prefetcher';
 import type { GetRecordActionsRequestStrategy, GetRecordAvatarsRequestStrategy, GetRecordRequestStrategy, GetRecordsRequestStrategy, GetObjectInfoRequestStrategy, GetObjectInfosRequestStrategy, GetRelatedListsActionsRequestStrategy, GetRelatedListInfoBatchRequestStrategy, GetRelatedListRecordsRequestStrategy, GetRelatedListRecordsBatchRequestStrategy } from '../request-strategy';
 import type { RequestRunner } from '../request-runner';
 import type { PrefetchRepository } from '../repository/prefetch-repository';
@@ -19,6 +20,7 @@ export declare class LexPredictivePrefetcher extends ApplicationPredictivePrefet
         getRelatedListInfoBatch: GetRelatedListInfoBatchRequestStrategy;
         getRelatedListRecords: GetRelatedListRecordsRequestStrategy;
         getRelatedListRecordsBatch: GetRelatedListRecordsBatchRequestStrategy;
-    });
+    }, options: PrefetcherOptions);
     getPage(): PredictivePrefetchPage<LexRequest, LexContext>;
+    predict(): Promise<void>;
 }

package/dist/types/predictive-loading/prefetcher/predictive-prefetcher.d.ts

@@ -1,14 +1,19 @@
 import type { PrefetchRepository } from '../repository/prefetch-repository';
 import type { PredictivePrefetchPage } from '../pages';
 import type { RequestRunner } from '../request-runner';
+import type { RequestEntry } from '../common';
+export type PrefetcherOptions = {
+    inflightRequestLimit: number;
+};
 export declare abstract class ApplicationPredictivePrefetcher<Request, Context extends Record<string, any>> {
-    private repository;
-    private requestRunner;
+    protected repository: PrefetchRepository;
+    protected requestRunner: RequestRunner<Request>;
+    protected options: PrefetcherOptions;
     private _context;
     isRecording: boolean;
     page: PredictivePrefetchPage<Request, Context>;
     queuedPredictionRequests: Request[];
-    constructor(context: Context, repository: PrefetchRepository, requestRunner: RequestRunner<Request>);
+    constructor(context: Context, repository: PrefetchRepository, requestRunner: RequestRunner<Request>, options: PrefetcherOptions);
     abstract getPage(): PredictivePrefetchPage<Request, Context>;
     set context(value: Context);
     get context(): Context;
@@ -21,5 +26,5 @@ export declare abstract class ApplicationPredictivePrefetcher<Request, Context e
         similar: number;
     };
     hasPredictions(): boolean;
-    getSimilarPageRequests(): Request[];
+    getSimilarPageRequests(): RequestEntry<Request>[];
 }

package/dist/types/predictive-loading/prefetcher/utils.d.ts

@@ -0,0 +1,16 @@
+import type { RequestRunner } from '../request-runner';
+import type { RequestEntry } from '../common';
+/**
+ * Runs a list of requests with a specified concurrency limit.
+ *
+ * @template Request - The type of the requests being processed.
+ * @param {RequestEntry<Request>[]} requests - An array of request entries to be processed in the array order.
+ * @param {RequestRunner<Request>} runner - The runner instance responsible for executing the requests.
+ * @param {number} concurrentRequestsLimit - The maximum number of concurrent requests allowed.
+ * @param {number} pageStartTime - The start time of the page load, used to calculate the time elapsed since the page starts loading.
+ * @returns {Promise<void>} A promise that resolves when all requests have been processed.
+ *
+ * This function manages a queue of pending requests and processes them with a concurrency limit.
+ * Requests are only processed if their `requestTime` is less than the time elapsed since `pageStartTime`.
+ */
+export declare function runRequestsWithLimit<Request>(requests: RequestEntry<Request>[], runner: RequestRunner<Request>, concurrentRequestsLimit: number, pageStartTime: number): Promise<void>;

package/dist/types/predictive-loading/repository/prefetch-repository.d.ts

@@ -1,4 +1,5 @@
 import type { PrefetchStorage } from '../storage';
+import type { RequestEntry } from '../common';
 type Key = Record<string, any>;
 export type History = {
     version: '1.0';
@@ -8,21 +9,17 @@ export type PageEntry<Request> = {
     id: string;
     requests: RequestEntry<Request>[];
 };
-export type RequestEntry<Request> = {
-    request: Request;
-    requestMetadata: {
-        requestTime: number;
-    };
-};
 export declare class PrefetchRepository {
     private storage;
     private requestBuffer;
     constructor(storage: PrefetchStorage);
     clearRequestBuffer(): void;
+    pageStartTime: number;
+    markPageStart(): void;
     flushRequestsToStorage(): Promise<void>;
     getKeyId(key: Key): string;
     saveRequest<Request>(key: Key, request: Request): Promise<void>;
     getPage<Request>(key: Key): PageEntry<Request> | undefined;
-    getPageRequests<Request>(key: Key): Request[];
+    getPageRequests<Request>(key: Key): RequestEntry<Request>[];
 }
 export {};

package/dist/types/predictive-loading/request-runner/lex-request-runner.d.ts

@@ -1,10 +1,11 @@
 import type { Luvio } from '@luvio/engine';
 import type { LexRequest } from '../prefetcher';
 import type { RequestRunner } from './request-runner';
+import type { RequestEntry } from '../common';
 export declare class LexRequestRunner implements RequestRunner<LexRequest> {
     private luvio;
     private requestStrategies;
     constructor(luvio: Luvio);
-    reduceRequests(requests: LexRequest[]): LexRequest[];
+    reduceRequests(requests: RequestEntry<LexRequest>[]): RequestEntry<LexRequest>[];
     runRequest(request: LexRequest): Promise<void>;
 }

package/dist/types/predictive-loading/request-runner/request-runner.d.ts

@@ -1,4 +1,5 @@
+import type { RequestEntry } from '../common';
 export type RequestRunner<Request> = {
     runRequest(request: Request): Promise<void>;
-    reduceRequests(requests: Request[]): Request[];
+    reduceRequests(requests: RequestEntry<Request>[]): RequestEntry<Request>[];
 };

package/dist/types/predictive-loading/request-strategy/get-object-info-request-strategy.d.ts

@@ -1,6 +1,7 @@
 import type { GetObjectInfoConfig } from '@salesforce/lds-adapters-uiapi';
 import type { LuvioAdapterRequest } from './luvio-adapter-request';
 import { LuvioAdapterRequestStrategy } from './luvio-adapter-request-strategy';
+import type { RequestEntry } from '../common';
 export type GetObjectInfoRequest = {
     adapterName: 'getObjectInfo';
     config: GetObjectInfoConfig;
@@ -24,5 +25,5 @@ export declare class GetObjectInfoRequestStrategy extends LuvioAdapterRequestStr
      * @param unfilteredRequests all prediction requests
      * @returns
      */
-    reduce(unfilteredRequests: LuvioAdapterRequest<unknown>[]): GetObjectInfoRequest[];
+    reduce(unfilteredRequests: RequestEntry<LuvioAdapterRequest<unknown>>[]): RequestEntry<GetObjectInfoRequest>[];
 }

package/dist/types/predictive-loading/request-strategy/get-object-infos-request-strategy.d.ts

@@ -1,4 +1,6 @@
 import type { GetObjectInfosConfig } from '@salesforce/lds-adapters-uiapi';
+import type { RequestEntry } from '../common';
+import type { LuvioAdapterRequest } from './luvio-adapter-request';
 import { LuvioAdapterRequestStrategy } from './luvio-adapter-request-strategy';
 export type GetObjectInfosRequest = {
     adapterName: 'getObjectInfos';
@@ -10,4 +12,12 @@ export declare class GetObjectInfosRequestStrategy extends LuvioAdapterRequestSt
     adapterFactory: import("@luvio/engine").AdapterFactory<GetObjectInfosConfig, import("@salesforce/lds-adapters-uiapi").SimplifiedBatchRepresentation>;
     buildConcreteRequest(similarRequest: GetObjectInfosRequest): GetObjectInfosRequest;
     transformForSave(request: GetObjectInfosRequest): GetObjectInfosRequest;
+    /**
+     * Reduces the given GetObjectInfosRequest requests by eliminating those for which config.objectApiNames
+     * is a subset of another GetObjectInfosRequest.
+     *
+     * @param unfilteredRequests - Array of unfiltered requests
+     * @returns RequestEntry<GetObjectInfosRequest>[] - Array of reduced requests
+     */
+    reduce(unfilteredRequests: RequestEntry<LuvioAdapterRequest<unknown>>[]): RequestEntry<GetObjectInfosRequest>[];
 }

package/dist/types/predictive-loading/request-strategy/get-related-list-records-request-strategy.d.ts

@@ -1,6 +1,7 @@
 import type { GetRelatedListRecordsConfig } from '@salesforce/lds-adapters-uiapi';
 import type { LuvioAdapterRequest } from './luvio-adapter-request';
 import { LuvioAdapterRequestStrategy } from './luvio-adapter-request-strategy';
+import type { RequestEntry } from '../common';
 export type GetRelatedListRecordsRequest = {
     adapterName: 'getRelatedListRecords';
     config: GetRelatedListRecordsConfig;
@@ -25,7 +26,7 @@ export declare class GetRelatedListRecordsRequestStrategy extends LuvioAdapterRe
      * @param unfilteredRequests All of the request available for predictions.
      * @returns GetRelatedListRecordsRequest[] That should be a prediction.
      */
-    reduce(unfilteredRequests: LuvioAdapterRequest<unknown>[]): GetRelatedListRecordsRequest[];
+    reduce(unfilteredRequests: RequestEntry<LuvioAdapterRequest<unknown>>[]): RequestEntry<GetRelatedListRecordsRequest>[];
     buildSaveRequestData<C extends GetRelatedListRecordsContext>(similarContext: C, context: C, request: GetRelatedListRecordsRequest): {
         request: GetRelatedListRecordsRequest;
         context: C;

package/dist/types/predictive-loading/request-strategy/luvio-adapter-request-strategy.d.ts

@@ -1,6 +1,7 @@
 import type { AdapterFactory } from '@luvio/engine';
 import { RequestStrategy } from './request-strategy';
 import type { LuvioAdapterRequest } from './luvio-adapter-request';
+import type { RequestEntry } from '../common';
 export declare abstract class LuvioAdapterRequestStrategy<AdapterConfig, Request extends LuvioAdapterRequest<AdapterConfig>, Context> extends RequestStrategy<Request, Context> {
     /**
      * Name of the adapter used in this strategy.
@@ -26,14 +27,14 @@ export declare abstract class LuvioAdapterRequestStrategy<AdapterConfig, Request
      * @param unfilteredRequests array of requests to filter
      * @returns
      */
-    protected filterRequests(unfilteredRequests: LuvioAdapterRequest<unknown>[]): Request[];
+    protected filterRequests(unfilteredRequests: RequestEntry<LuvioAdapterRequest<unknown>>[]): RequestEntry<Request>[];
     /**
      * Reduce requests by combining those based on a strategies implementations
      * of canCombine and combineRequests.
      * @param unfilteredRequests array of requests to filter
      * @returns
      */
-    reduce(unfilteredRequests: LuvioAdapterRequest<unknown>[]): Request[];
+    reduce(unfilteredRequests: RequestEntry<LuvioAdapterRequest<unknown>>[]): RequestEntry<Request>[];
     /**
      * Check if two requests can be combined.
      *

package/dist/types/predictive-loading/request-strategy/request-strategy.d.ts

@@ -1,5 +1,6 @@
+import type { RequestEntry } from '../common';
 export declare abstract class RequestStrategy<Request, Context> {
     abstract buildConcreteRequest(similarRequest: Request, context: Context): Request;
     transformForSave(request: Request): Request;
-    reduce(requests: Request[]): Request[];
+    reduce(requests: RequestEntry<Request>[]): RequestEntry<Request>[];
 }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@salesforce/lds-runtime-aura",
-    "version": "1.287.0-dev14",
+    "version": "1.287.0-dev16",
     "license": "SEE LICENSE IN LICENSE.txt",
     "description": "LDS engine for Aura runtime",
     "main": "dist/ldsEngineCreator.js",
@@ -44,25 +44,25 @@
         "@luvio/service-subscription": "^1.0.0",
         "@luvio/service-type-registry": "^1.0.0",
         "@luvio/utils": "^3.6.0",
-        "@salesforce/lds-adapters-uiapi": "^1.287.0-dev14",
-        "@salesforce/lds-ads-bridge": "^1.287.0-dev14",
-        "@salesforce/lds-aura-storage": "^1.287.0-dev14",
-        "@salesforce/lds-bindings": "^1.287.0-dev14",
-        "@salesforce/lds-instrumentation": "^1.287.0-dev14",
-        "@salesforce/lds-network-aura": "^1.287.0-dev14",
-        "@salesforce/lds-network-fetch-with-jwt": "^1.287.0-dev14"
+        "@salesforce/lds-adapters-uiapi": "^1.287.0-dev16",
+        "@salesforce/lds-ads-bridge": "^1.287.0-dev16",
+        "@salesforce/lds-aura-storage": "^1.287.0-dev16",
+        "@salesforce/lds-bindings": "^1.287.0-dev16",
+        "@salesforce/lds-instrumentation": "^1.287.0-dev16",
+        "@salesforce/lds-network-aura": "^1.287.0-dev16",
+        "@salesforce/lds-network-fetch-with-jwt": "^1.287.0-dev16"
     },
     "dependencies": {
-        "@luvio/network-adapter-composable": "0.154.17-dev2",
-        "@salesforce/lds-adapters-uiapi-lex": "^1.287.0-dev14"
+        "@luvio/network-adapter-composable": "0.154.17-dev3",
+        "@salesforce/lds-adapters-uiapi-lex": "^1.287.0-dev16"
     },
     "luvioBundlesize": [
         {
             "path": "./dist/ldsEngineCreator.js",
             "maxSize": {
-                "none": "105 kB",
-                "min": "44 kB",
-                "compressed": "18.5 kB"
+                "none": "112 kB",
+                "min": "46 kB",
+                "compressed": "21 kB"
             }
         }
     ],