@salesforce/lds-runtime-aura 1.246.0 → 1.248.0

package/dist/ldsEngineCreator.js

@@ -15,7 +15,8 @@
 import { HttpStatusCode, InMemoryStore, Environment, Luvio, InMemoryStoreQueryEvaluator } from 'force/luvioEngine';
 import ldsTrackedFieldsBehaviorGate from '@salesforce/gate/lds.useNewTrackedFieldBehavior';
 import usePredictiveLoading from '@salesforce/gate/lds.usePredictiveLoading';
-import { getRecordAdapterFactory, getRecordsAdapterFactory, instrument, configuration, InMemoryRecordRepresentationQueryEvaluator, UiApiNamespace, RecordRepresentationRepresentationType, registerPrefetcher } from 'force/ldsAdaptersUiapi';
+import { getRecordAvatarsAdapterFactory, getRecordAdapterFactory, getRecordsAdapterFactory, getRecordActionsAdapterFactory, instrument, configuration, InMemoryRecordRepresentationQueryEvaluator, UiApiNamespace, RecordRepresentationRepresentationType, registerPrefetcher } from 'force/ldsAdaptersUiapi';
+import { createStorage, clearStorages } from 'force/ldsStorage';
 import { withRegistration, register, setDefaultLuvio } from 'force/ldsEngine';
 import { REFRESH_ADAPTER_EVENT, ADAPTER_UNFULFILLED_ERROR, instrument as instrument$2 } from 'force/ldsBindings';
 import { counter, registerCacheStats, perfStart, perfEnd, registerPeriodicLogger, interaction, timer } from 'instrumentation/service';
@@ -23,7 +24,6 @@ import { LRUCache, instrumentAdapter, instrumentLuvio, setupInstrumentation as s
 import auraNetworkAdapter, { instrument as instrument$1, forceRecordTransactionsDisabled, ldsNetworkAdapterInstrument, dispatchAuraAction, defaultActionConfig } from 'force/ldsNetwork';
 import { instrument as instrument$3 } from 'force/adsBridge';
 import { buildJwtNetworkAdapter } from 'force/ldsNetworkFetchWithJwt';
-import { clearStorages } from 'force/ldsStorage';
 
 class PredictivePrefetchPage {
     constructor(context) {
@@ -42,6 +42,9 @@ class LexDefaultPage extends PredictivePrefetchPage {
     resolveSimilarRequest(similarRequest) {
         return similarRequest;
     }
+    getAlwaysRunRequests() {
+        return [];
+    }
 }
 
 class RecordHomePage extends PredictivePrefetchPage {
@@ -55,14 +58,18 @@ class RecordHomePage extends PredictivePrefetchPage {
         };
     }
     buildSaveRequestData(request) {
-        if (request.adapterName === 'getRecord') {
-            return this.buildGetRecordSaveRequestData(request);
-        }
-        else if (request.adapterName === 'getRecords') {
-            return this.buildGetRecordsSaveRequestData(request);
-        }
-        else {
-            return { request, context: this.context };
+        const { adapterName } = request;
+        switch (adapterName) {
+            case 'getRecord':
+                return this.buildGetRecordSaveRequestData(request);
+            case 'getRecords':
+                return this.buildGetRecordsSaveRequestData(request);
+            case 'getRecordActions':
+                return this.requestStrategies.getRecordActions.buildGetRecordActionsSaveRequestData(this.similarContext, this.context, request);
+            case 'getRecordAvatars':
+                return this.requestStrategies.getRecordAvatars.buildGetRecordAvatarsSaveRequestData(this.similarContext, this.context, request);
+            default:
+                return { request, context: this.context };
         }
     }
     buildGetRecordSaveRequestData(request) {
@@ -121,8 +128,27 @@ class RecordHomePage extends PredictivePrefetchPage {
         if (similarRequest.adapterName === 'getRecords') {
             return this.requestStrategies.getRecords.buildConcreteRequest(similarRequest, this.context);
         }
+        if (similarRequest.adapterName === 'getRecordActions') {
+            return this.requestStrategies.getRecordActions.buildConcreteRequest(similarRequest, this.context);
+        }
+        if (similarRequest.adapterName === 'getRecordAvatars') {
+            return this.requestStrategies.getRecordAvatars.buildConcreteRequest(similarRequest, this.context);
+        }
         return similarRequest;
     }
+    // Record Home performs best when we always do a minimal getRecord alongside the other requests.
+    getAlwaysRunRequests() {
+        const { recordId, objectApiName } = this.context;
+        return [
+            {
+                adapterName: 'getRecord',
+                config: {
+                    recordId,
+                    optionalFields: [`${objectApiName}.Id`, `${objectApiName}.RecordTypeId`],
+                },
+            },
+        ];
+    }
     static handlesContext(context) {
         const maybeRecordHomePageContext = context;
         return (maybeRecordHomePageContext !== undefined &&
@@ -149,11 +175,13 @@ class ApplicationPredictivePrefetcher {
     get context() {
         return this._context;
     }
-    stopRecording() {
+    async stopRecording() {
         this.isRecording = false;
+        await this.repository.flushRequestsToStorage();
     }
     startRecording() {
         this.isRecording = true;
+        this.repository.clearRequestBuffer();
     }
     saveRequest(request) {
         if (!this.isRecording) {
@@ -167,10 +195,10 @@ class ApplicationPredictivePrefetcher {
     async predict() {
         const exactPageRequests = (await this.repository.getPageRequests(this.context)) || [];
         const similarPageRequests = await this.getSimilarPageRequests();
-        const predictedRequests = this.requestRunner.reduceRequests([
-            ...exactPageRequests,
-            ...similarPageRequests,
-        ]);
+        const predictedRequests = [
+            ...this.requestRunner.reduceRequests([...exactPageRequests, ...similarPageRequests]),
+            ...this.page.getAlwaysRunRequests(),
+        ];
         this.queuedPredictionRequests.push(...predictedRequests);
         return Promise.all(predictedRequests.map((request) => this.requestRunner.runRequest(request))).then();
     }
@@ -262,31 +290,74 @@ function stableJSONStringify$1(node) {
     }
     return '{' + out + '}';
 }
+function isObject(obj) {
+    return obj !== null && typeof obj === 'object';
+}
+function deepEquals(objA, objB) {
+    if (objA === objB)
+        return true;
+    if (objA instanceof Date && objB instanceof Date)
+        return objA.getTime() === objB.getTime();
+    // If one of them is not an object, they are not deeply equal
+    if (!isObject(objA) || !isObject(objB))
+        return false;
+    // Filter out keys set as undefined, we can compare undefined as equals.
+    const keysA = ObjectKeys(objA).filter((key) => objA[key] !== undefined);
+    const keysB = ObjectKeys(objB).filter((key) => objB[key] !== undefined);
+    // If the objects do not have the same set of keys, they are not deeply equal
+    if (keysA.length !== keysB.length)
+        return false;
+    for (const key of keysA) {
+        const valA = objA[key];
+        const valB = objB[key];
+        const areObjects = isObject(valA) && isObject(valB);
+        // If both values are objects, recursively compare them
+        if (areObjects && !deepEquals(valA, valB))
+            return false;
+        // If only one value is an object or if the values are not strictly equal, they are not deeply equal
+        if (!areObjects && valA !== valB)
+            return false;
+    }
+    return true;
+}
 
 class PrefetchRepository {
     constructor(storage) {
         this.storage = storage;
+        this.requestBuffer = new Map();
+    }
+    clearRequestBuffer() {
+        this.requestBuffer.clear();
+    }
+    async flushRequestsToStorage() {
+        for (const [id, batch] of this.requestBuffer) {
+            const rawPage = await this.storage.get(id);
+            const page = rawPage === undefined ? { id, requests: [] } : rawPage;
+            batch.forEach(({ request, requestTime }) => {
+                let existingRequestEntry = page.requests.find(({ request: storedRequest }) => deepEquals(storedRequest, request));
+                if (existingRequestEntry === undefined) {
+                    existingRequestEntry = { request, requestMetadata: { requestTimes: [] } };
+                    page.requests.push(existingRequestEntry);
+                }
+                existingRequestEntry.requestMetadata.requestTimes.push(requestTime);
+            });
+            await this.storage.set(id, page);
+        }
+        this.clearRequestBuffer();
     }
     async saveRequest(key, request) {
         const identifier = stableJSONStringify$1(key);
-        const rawPage = await this.storage.get(identifier);
-        const page = rawPage === undefined ? { identifier, requests: [] } : JSON.parse(rawPage);
-        const stringifiedRequest = stableJSONStringify$1(request);
-        let existingRequestEntry = page.requests.find((requestEntry) => stableJSONStringify$1(requestEntry.request) === stringifiedRequest);
-        if (existingRequestEntry === undefined) {
-            existingRequestEntry = { request, requestMetadata: { requestTimes: [] } };
-            page.requests.push(existingRequestEntry);
-        }
-        existingRequestEntry.requestMetadata.requestTimes.push(Date.now());
-        return this.storage.set(identifier, stableJSONStringify$1(page));
+        const batchForKey = this.requestBuffer.get(identifier) || [];
+        batchForKey.push({
+            request,
+            requestTime: Date.now(),
+        });
+        this.requestBuffer.set(identifier, batchForKey);
     }
     async getPage(key) {
         const identifier = stableJSONStringify$1(key);
         const rawPage = await this.storage.get(identifier);
-        if (rawPage === undefined) {
-            return;
-        }
-        return JSON.parse(rawPage);
+        return rawPage;
     }
     async getPageRequests(key) {
         const page = await this.getPage(key);
@@ -310,14 +381,95 @@ class LuvioAdapterRequestStrategy extends RequestStrategy {
     transformForSave(request) {
         return request;
     }
-    reduce(requests) {
-        return requests;
+    filterRequests(unfilteredRequests) {
+        return unfilteredRequests.filter((request) => request.adapterName === this.adapterName);
+    }
+    reduce(unfilteredRequests) {
+        return this.filterRequests(unfilteredRequests);
+    }
+}
+
+function normalizeRecordIds$1(recordIds) {
+    if (!Array.isArray(recordIds)) {
+        return [recordIds];
+    }
+    return recordIds;
+}
+function canCombine$1(reqA, reqB) {
+    return reqA.formFactor === reqB.formFactor;
+}
+function combineRequests$1(reqA, reqB) {
+    const combined = { ...reqA };
+    combined.recordIds = Array.from(new Set([...normalizeRecordIds$1(reqA.recordIds), ...normalizeRecordIds$1(reqB.recordIds)]));
+    return combined;
+}
+class GetRecordAvatarsRequestStrategy extends LuvioAdapterRequestStrategy {
+    constructor() {
+        super(...arguments);
+        this.adapterName = 'getRecordAvatars';
+        this.adapterFactory = getRecordAvatarsAdapterFactory;
+    }
+    buildConcreteRequest(similarRequest, context) {
+        return {
+            ...similarRequest,
+            config: {
+                ...similarRequest.config,
+                recordIds: [context.recordId],
+            },
+        };
+    }
+    buildGetRecordAvatarsSaveRequestData(similarContext, context, request) {
+        if (this.isGetRecordAvatarsRequestContextDependent(context, request)) {
+            return {
+                request: this.transformForSave({
+                    ...request,
+                    config: {
+                        ...request.config,
+                        recordIds: ['*'],
+                    },
+                }),
+                context: similarContext,
+            };
+        }
+        return {
+            request: this.transformForSave(request),
+            context,
+        };
+    }
+    isGetRecordAvatarsRequestContextDependent(context, request) {
+        return (request.config.recordIds &&
+            (context.recordId === request.config.recordIds || // some may set this as string instead of array
+                (request.config.recordIds.length === 1 &&
+                    request.config.recordIds[0] === context.recordId)));
+    }
+    reduce(unfilteredRequests) {
+        const requests = this.filterRequests(unfilteredRequests);
+        const visitedRequests = new Set();
+        const reducedRequests = [];
+        for (let i = 0, n = requests.length; i < n; i++) {
+            const currentRequest = requests[i];
+            if (!visitedRequests.has(currentRequest)) {
+                const combinedRequest = { ...currentRequest };
+                for (let j = i + 1; j < n; j++) {
+                    const hasNotBeenVisited = !visitedRequests.has(requests[j]);
+                    const canCombineConfigs = canCombine$1(combinedRequest.config, requests[j].config);
+                    if (hasNotBeenVisited && canCombineConfigs) {
+                        combinedRequest.config = combineRequests$1(combinedRequest.config, requests[j].config);
+                        visitedRequests.add(requests[j]);
+                    }
+                }
+                reducedRequests.push(combinedRequest);
+                visitedRequests.add(currentRequest);
+            }
+        }
+        return reducedRequests;
     }
 }
 
 class GetRecordRequestStrategy extends LuvioAdapterRequestStrategy {
     constructor() {
         super(...arguments);
+        this.adapterName = 'getRecord';
         this.adapterFactory = getRecordAdapterFactory;
     }
     buildConcreteRequest(similarRequest, context) {
@@ -333,19 +485,21 @@ class GetRecordRequestStrategy extends LuvioAdapterRequestStrategy {
         if (request.config.fields === undefined && request.config.optionalFields === undefined) {
             return request;
         }
+        let optionalFields = request.config.optionalFields || [];
+        if (!ArrayIsArray(optionalFields)) {
+            optionalFields = [optionalFields];
+        }
         return {
             ...request,
             config: {
                 ...request.config,
                 fields: undefined,
-                optionalFields: [
-                    ...(request.config.fields || []),
-                    ...(request.config.optionalFields || []),
-                ],
+                optionalFields: [...(request.config.fields || []), ...optionalFields],
             },
         };
     }
-    reduce(requests) {
+    reduce(unfilteredRequests) {
+        const requests = this.filterRequests(unfilteredRequests);
         const recordIdToRequestMap = {};
         const resultRequests = [];
         requests.forEach((request) => {
@@ -390,6 +544,7 @@ class GetRecordRequestStrategy extends LuvioAdapterRequestStrategy {
 class GetRecordsRequestStrategy extends LuvioAdapterRequestStrategy {
     constructor() {
         super(...arguments);
+        this.adapterName = 'getRecords';
         this.adapterFactory = getRecordsAdapterFactory;
     }
     buildConcreteRequest(similarRequest, context) {
@@ -403,18 +558,104 @@ class GetRecordsRequestStrategy extends LuvioAdapterRequestStrategy {
     }
 }
 
+function normalizeRecordIds(recordIds) {
+    if (!Array.isArray(recordIds)) {
+        return [recordIds];
+    }
+    return recordIds;
+}
+function canCombine(reqA, reqB) {
+    return (reqA.retrievalMode === reqB.retrievalMode &&
+        reqA.formFactor === reqB.formFactor &&
+        (reqA.actionTypes || []).toString() === (reqB.actionTypes || []).toString() &&
+        (reqA.sections || []).toString() === (reqB.sections || []).toString());
+}
+function combineRequests(reqA, reqB) {
+    const combined = { ...reqA };
+    // let's merge the recordIds
+    combined.recordIds = Array.from(new Set([...normalizeRecordIds(reqA.recordIds), ...normalizeRecordIds(reqB.recordIds)]));
+    if (combined.retrievalMode === 'ALL') {
+        const combinedSet = new Set([...(combined.apiNames || []), ...(reqB.apiNames || [])]);
+        combined.apiNames = Array.from(combinedSet);
+    }
+    return combined;
+}
+class GetRecordActionsRequestStrategy extends LuvioAdapterRequestStrategy {
+    constructor() {
+        super(...arguments);
+        this.adapterName = 'getRecordActions';
+        this.adapterFactory = getRecordActionsAdapterFactory;
+    }
+    buildConcreteRequest(similarRequest, context) {
+        return {
+            ...similarRequest,
+            config: {
+                ...similarRequest.config,
+                recordIds: [context.recordId],
+            },
+        };
+    }
+    buildGetRecordActionsSaveRequestData(similarContext, context, request) {
+        if (this.isGetRecordActionsRequestContextDependent(context, request)) {
+            return {
+                request: this.transformForSave({
+                    ...request,
+                    config: {
+                        ...request.config,
+                        recordIds: ['*'],
+                    },
+                }),
+                context: similarContext,
+            };
+        }
+        return {
+            request: this.transformForSave(request),
+            context,
+        };
+    }
+    isGetRecordActionsRequestContextDependent(context, request) {
+        return (request.config.recordIds &&
+            (context.recordId === request.config.recordIds || // some may set this as string instead of array
+                (request.config.recordIds.length === 1 &&
+                    request.config.recordIds[0] === context.recordId)));
+    }
+    reduce(unfilteredRequests) {
+        const requests = this.filterRequests(unfilteredRequests);
+        const visitedRequests = new Set();
+        const reducedRequests = [];
+        for (let i = 0, n = requests.length; i < n; i++) {
+            const currentRequest = requests[i];
+            if (!visitedRequests.has(currentRequest)) {
+                const combinedRequest = { ...currentRequest };
+                for (let j = i + 1; j < n; j++) {
+                    if (!visitedRequests.has(requests[j]) &&
+                        canCombine(combinedRequest.config, requests[j].config)) {
+                        combinedRequest.config = combineRequests(combinedRequest.config, requests[j].config);
+                        visitedRequests.add(requests[j]);
+                    }
+                }
+                reducedRequests.push(combinedRequest);
+                visitedRequests.add(currentRequest);
+            }
+        }
+        return reducedRequests;
+    }
+}
+
 class LexRequestRunner {
     constructor(luvio) {
         this.luvio = luvio;
         this.requestStrategies = {
             getRecord: new GetRecordRequestStrategy(),
             getRecords: new GetRecordsRequestStrategy(),
+            getRecordActions: new GetRecordActionsRequestStrategy(),
+            getRecordAvatars: new GetRecordAvatarsRequestStrategy(),
         };
     }
     reduceRequests(requests) {
-        const getRecordRequests = requests.filter((request) => request.adapterName === 'getRecord');
-        const otherRequests = requests.filter((request) => request.adapterName !== 'getRecord');
-        return [...this.requestStrategies.getRecord.reduce(getRecordRequests), ...otherRequests];
+        return Object.values(this.requestStrategies)
+            .map((strategy) => strategy.reduce(requests))
+            .flat();
     }
     runRequest(request) {
         if (request.adapterName in this.requestStrategies) {
@@ -425,16 +666,49 @@ class LexRequestRunner {
     }
 }
 
-class LocalPrefetchStorage {
-    constructor(localStorage) {
-        this.localStorage = localStorage;
+class InMemoryPrefetchStorage {
+    constructor() {
+        this.data = {};
     }
     set(key, value) {
-        this.localStorage.setItem(key, value);
+        this.data[key] = value;
         return Promise.resolve();
     }
     get(key) {
-        return Promise.resolve(this.localStorage.getItem(key) || undefined);
+        return Promise.resolve(this.data[key]);
+    }
+}
+
+const DEFAULT_STORAGE_OPTIONS = {
+    name: 'ldsPredictiveLoading',
+    persistent: true,
+    secure: true,
+    maxSize: 20 * 1024 * 1024,
+    // @todo: there's no way of setting a "no expire" value. We should determine the best ttl for this cache.
+    expiration: 24 * 60 * 60,
+    clearOnInit: false,
+    debugLogging: false,
+};
+function buildAuraPrefetchStorage(options = {}) {
+    const auraStorage = createStorage({
+        ...DEFAULT_STORAGE_OPTIONS,
+        ...options,
+    });
+    if (auraStorage === null) {
+        return new InMemoryPrefetchStorage();
+    }
+    return new AuraPrefetchStorage(auraStorage);
+}
+class AuraPrefetchStorage {
+    constructor(auraStorage) {
+        this.auraStorage = auraStorage;
+    }
+    set(key, value) {
+        return this.auraStorage.set(key, value);
+    }
+    async get(key) {
+        const result = await this.auraStorage.get(key);
+        return result ? result : undefined;
     }
 }
 
@@ -446,8 +720,8 @@ class LocalPrefetchStorage {
  *
  * Below are the R.E.A.D.S. metrics for the Lightning Data Service, defined here[2].
  *
- * [1] https://salesforce.quip.com/NfW9AsbGEaTY
- * [2] https://salesforce.quip.com/1dFvAba1b0eq
+ * [1] Search "[M1] Lightning Data Service Design Spike" in Quip
+ * [2] Search "Lightning Data Service R.E.A.D.S. Metrics" in Quip
  */
 const OBSERVABILITY_NAMESPACE = 'LIGHTNING.lds.service';
 const ADAPTER_INVOCATION_COUNT_METRIC_NAME = 'request';
@@ -1138,7 +1412,6 @@ function setupMetadataWatcher(luvio) {
     });
 }
 
-// import { createStorage } from '@salesforce/lds-aura-storage';
 // This code *should* be in lds-network-adapter, but when combined with the Aura
 // component test workaround in lds-default-luvio it creates a circular dependecy
 // between lds-default-luvio and lds-network-adapter. We do the register on behalf
@@ -1167,12 +1440,14 @@ function setupQueryEvaluators(luvio, store) {
 }
 let __lexPrefetcher;
 function setupPredictivePrefetcher(luvio) {
-    const storage = new LocalPrefetchStorage(window.localStorage);
+    const storage = buildAuraPrefetchStorage();
     const repository = new PrefetchRepository(storage);
     const requestRunner = new LexRequestRunner(luvio);
     const prefetcher = new LexPredictivePrefetcher({ context: 'unknown' }, repository, requestRunner, {
         getRecord: new GetRecordRequestStrategy(),
         getRecords: new GetRecordsRequestStrategy(),
+        getRecordActions: new GetRecordActionsRequestStrategy(),
+        getRecordAvatars: new GetRecordAvatarsRequestStrategy(),
     });
     registerPrefetcher(luvio, prefetcher);
     __lexPrefetcher = prefetcher;
@@ -1225,4 +1500,4 @@ function ldsEngineCreator() {
 }
 
 export { ldsEngineCreator as default, initializeLDS, predictiveLoadPage };
-// version: 1.246.0-8357100fc
+// version: 1.248.0-1f7f01112

package/dist/types/aura-instrumentation/utils/observability.d.ts

@@ -6,8 +6,8 @@
  *
  * Below are the R.E.A.D.S. metrics for the Lightning Data Service, defined here[2].
  *
- * [1] https://salesforce.quip.com/NfW9AsbGEaTY
- * [2] https://salesforce.quip.com/1dFvAba1b0eq
+ * [1] Search "[M1] Lightning Data Service Design Spike" in Quip
+ * [2] Search "Lightning Data Service R.E.A.D.S. Metrics" in Quip
  */
 import type { MetricsKey } from 'instrumentation/service';
 export declare const OBSERVABILITY_NAMESPACE = "LIGHTNING.lds.service";

package/dist/types/predictive-loading/pages/lex-default-page.d.ts

@@ -8,4 +8,5 @@ export declare class LexDefaultPage extends PredictivePrefetchPage<LexRequest, D
         request: import("./record-home-page").RecordHomePageRequest;
     };
     resolveSimilarRequest(similarRequest: LexRequest): LexRequest;
+    getAlwaysRunRequests(): LexRequest[];
 }

package/dist/types/predictive-loading/pages/predictive-prefetch-page.d.ts

@@ -7,4 +7,5 @@ export declare abstract class PredictivePrefetchPage<Request, Context> {
         request: Request;
     };
     abstract resolveSimilarRequest(similarRequest: Request): Request;
+    abstract getAlwaysRunRequests(): Request[];
 }

package/dist/types/predictive-loading/pages/record-home-page.d.ts

@@ -1,5 +1,5 @@
 import type { LexContext } from '../prefetcher';
-import type { GetRecordRequest, GetRecordsRequest, GetRecordRequestStrategy, GetRecordsRequestStrategy } from '../request-strategy';
+import type { GetRecordRequest, GetRecordsRequest, GetRecordRequestStrategy, GetRecordsRequestStrategy, GetRecordActionsRequestStrategy, GetRecordActionsRequest, GetRecordAvatarsRequest, GetRecordAvatarsRequestStrategy } from '../request-strategy';
 import { PredictivePrefetchPage } from './predictive-prefetch-page';
 export type RecordHomePageContext = {
     objectApiName: string;
@@ -7,13 +7,15 @@ export type RecordHomePageContext = {
     actionName: string;
     type: 'recordPage';
 };
-export type RecordHomePageRequest = GetRecordRequest | GetRecordsRequest;
+export type RecordHomePageRequest = GetRecordRequest | GetRecordsRequest | GetRecordActionsRequest | GetRecordAvatarsRequest;
 export declare class RecordHomePage extends PredictivePrefetchPage<RecordHomePageRequest, RecordHomePageContext> {
     private requestStrategies;
     similarContext: RecordHomePageContext;
     constructor(context: RecordHomePageContext, requestStrategies: {
         getRecord: GetRecordRequestStrategy;
         getRecords: GetRecordsRequestStrategy;
+        getRecordActions: GetRecordActionsRequestStrategy;
+        getRecordAvatars: GetRecordAvatarsRequestStrategy;
     });
     buildSaveRequestData(request: RecordHomePageRequest): {
         request: GetRecordRequest;
@@ -21,6 +23,12 @@ export declare class RecordHomePage extends PredictivePrefetchPage<RecordHomePag
     } | {
         request: GetRecordsRequest;
         context: RecordHomePageContext;
+    } | {
+        request: GetRecordActionsRequest;
+        context: RecordHomePageContext;
+    } | {
+        request: GetRecordAvatarsRequest;
+        context: RecordHomePageContext;
     };
     buildGetRecordSaveRequestData(request: GetRecordRequest): {
         request: GetRecordRequest;
@@ -33,5 +41,6 @@ export declare class RecordHomePage extends PredictivePrefetchPage<RecordHomePag
     isGetRecordRequestContextDependent(request: GetRecordRequest): boolean;
     isGetRecordsRequestContextDependent(request: GetRecordsRequest): boolean;
     resolveSimilarRequest(similarRequest: RecordHomePageRequest): RecordHomePageRequest;
+    getAlwaysRunRequests(): RecordHomePageRequest[];
     static handlesContext(context: LexContext): context is RecordHomePageContext;
 }

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

@@ -1,6 +1,6 @@
 import type { DefaultPageContext, PredictivePrefetchPage } from '../pages';
 import { ApplicationPredictivePrefetcher } from './predictive-prefetcher';
-import type { GetRecordRequestStrategy, GetRecordsRequestStrategy } from '../request-strategy';
+import type { GetRecordActionsRequestStrategy, GetRecordAvatarsRequestStrategy, GetRecordRequestStrategy, GetRecordsRequestStrategy } from '../request-strategy';
 import type { RequestRunner } from '../request-runner';
 import type { PrefetchRepository } from '../repository/prefetch-repository';
 import type { RecordHomePageContext, RecordHomePageRequest } from '../pages/record-home-page';
@@ -11,6 +11,8 @@ export declare class LexPredictivePrefetcher extends ApplicationPredictivePrefet
     constructor(context: LexContext, repository: PrefetchRepository, requestRunner: RequestRunner<LexRequest>, requestStrategies: {
         getRecord: GetRecordRequestStrategy;
         getRecords: GetRecordsRequestStrategy;
+        getRecordActions: GetRecordActionsRequestStrategy;
+        getRecordAvatars: GetRecordAvatarsRequestStrategy;
     });
     getPage(): PredictivePrefetchPage<LexRequest, LexContext>;
 }

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

@@ -12,7 +12,7 @@ export declare abstract class ApplicationPredictivePrefetcher<Request, Context e
     abstract getPage(): PredictivePrefetchPage<Request, Context>;
     set context(value: Context);
     get context(): Context;
-    stopRecording(): void;
+    stopRecording(): Promise<void>;
     startRecording(): void;
     saveRequest(request: Request): Promise<void>;
     predict(): Promise<void>;

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

@@ -16,7 +16,10 @@ export type RequestEntry<Request> = {
 };
 export declare class PrefetchRepository {
     private storage;
+    private requestBuffer;
     constructor(storage: PrefetchStorage);
+    clearRequestBuffer(): void;
+    flushRequestsToStorage(): Promise<void>;
     saveRequest<Request>(key: Key, request: Request): Promise<void>;
     getPage<Request>(key: Key): Promise<PageEntry<Request> | undefined>;
     getPageRequests<Request>(key: Key): Promise<Request[]>;

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

@@ -11,3 +11,5 @@ export declare const ArrayIsArray: (arg: any) => arg is any[];
  * @returns JSON.stringified value with consistent ordering of keys.
  */
 export declare function stableJSONStringify(node: any): string | undefined;
+export declare function isObject(obj: any): obj is Record<string, unknown>;
+export declare function deepEquals(objA: any, objB: any): boolean;

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

@@ -0,0 +1,22 @@
+import type { GetRecordActionsConfig } from '@salesforce/lds-adapters-uiapi';
+import { LuvioAdapterRequestStrategy } from './luvio-adapter-request-strategy';
+import type { LuvioAdapterRequest } from './luvio-adapter-request';
+export type GetRecordActionsRequest = {
+    adapterName: 'getRecordActions';
+    config: GetRecordActionsConfig;
+};
+type GetRecordActionsContext = {
+    recordId: string;
+};
+export declare class GetRecordActionsRequestStrategy extends LuvioAdapterRequestStrategy<GetRecordActionsConfig, GetRecordActionsRequest, GetRecordActionsContext> {
+    adapterName: string;
+    adapterFactory: import("@luvio/engine").AdapterFactory<GetRecordActionsConfig, import("packages/lds-adapters-uiapi/dist/es/es2018/types/src/generated/types/ActionRepresentation").ActionRepresentation>;
+    buildConcreteRequest(similarRequest: GetRecordActionsRequest, context: GetRecordActionsContext): GetRecordActionsRequest;
+    buildGetRecordActionsSaveRequestData<C extends GetRecordActionsContext>(similarContext: C, context: C, request: GetRecordActionsRequest): {
+        request: GetRecordActionsRequest;
+        context: C;
+    };
+    private isGetRecordActionsRequestContextDependent;
+    reduce(unfilteredRequests: LuvioAdapterRequest<unknown>[]): GetRecordActionsRequest[];
+}
+export {};

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

@@ -0,0 +1,22 @@
+import type { GetRecordAvatarsConfig } from '@salesforce/lds-adapters-uiapi';
+import { LuvioAdapterRequestStrategy } from './luvio-adapter-request-strategy';
+import type { LuvioAdapterRequest } from './luvio-adapter-request';
+export type GetRecordAvatarsRequest = {
+    adapterName: 'getRecordAvatars';
+    config: GetRecordAvatarsConfig;
+};
+type GetRecordAvatarsContext = {
+    recordId: string;
+};
+export declare class GetRecordAvatarsRequestStrategy extends LuvioAdapterRequestStrategy<GetRecordAvatarsConfig, GetRecordAvatarsRequest, GetRecordAvatarsContext> {
+    adapterName: string;
+    adapterFactory: import("@luvio/engine").AdapterFactory<GetRecordAvatarsConfig, import("packages/lds-adapters-uiapi/dist/es/es2018/types/src/generated/types/RecordAvatarBulkMapRepresentation").RecordAvatarBulkMapRepresentation>;
+    buildConcreteRequest(similarRequest: GetRecordAvatarsRequest, context: GetRecordAvatarsContext): GetRecordAvatarsRequest;
+    buildGetRecordAvatarsSaveRequestData<C extends GetRecordAvatarsContext>(similarContext: C, context: C, request: GetRecordAvatarsRequest): {
+        request: GetRecordAvatarsRequest;
+        context: C;
+    };
+    private isGetRecordAvatarsRequestContextDependent;
+    reduce(unfilteredRequests: LuvioAdapterRequest<unknown>[]): GetRecordAvatarsRequest[];
+}
+export {};

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

@@ -4,13 +4,15 @@ export type GetRecordRequest = {
     adapterName: 'getRecord';
     config: GetRecordConfig;
 };
+import type { LuvioAdapterRequest } from './luvio-adapter-request';
 type GetRecordContext = {
     recordId: string;
 };
 export declare class GetRecordRequestStrategy extends LuvioAdapterRequestStrategy<GetRecordConfig, GetRecordRequest, GetRecordContext> {
+    adapterName: string;
     adapterFactory: import("@luvio/engine").AdapterFactory<GetRecordConfig, import("@salesforce/lds-adapters-uiapi").RecordRepresentation>;
     buildConcreteRequest(similarRequest: GetRecordRequest, context: GetRecordContext): GetRecordRequest;
     transformForSave(request: GetRecordRequest): GetRecordRequest;
-    reduce(requests: GetRecordRequest[]): GetRecordRequest[];
+    reduce(unfilteredRequests: LuvioAdapterRequest<unknown>[]): GetRecordRequest[];
 }
 export {};

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

@@ -8,6 +8,7 @@ type GetRecordsContext = {
     recordId: string;
 };
 export declare class GetRecordsRequestStrategy extends LuvioAdapterRequestStrategy<GetRecordsConfig, GetRecordsRequest, GetRecordsContext> {
+    adapterName: string;
     adapterFactory: import("@luvio/engine").AdapterFactory<GetRecordsConfig, import("@salesforce/lds-adapters-uiapi").BatchRepresentation>;
     buildConcreteRequest(similarRequest: GetRecordsRequest, context: GetRecordsContext): GetRecordsRequest;
 }

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

@@ -1,5 +1,7 @@
+export * from './get-record-avatars-request-strategy';
 export * from './get-record-request-strategy';
 export * from './get-records-request-strategy';
+export * from './get-record-actions-request-strategy';
 export * from './luvio-adapter-request-strategy';
 export * from './luvio-adapter-request';
 export * from './request-strategy';

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

@@ -2,7 +2,9 @@ import type { AdapterFactory } from '@luvio/engine';
 import { RequestStrategy } from './request-strategy';
 import type { LuvioAdapterRequest } from './luvio-adapter-request';
 export declare abstract class LuvioAdapterRequestStrategy<AdapterConfig, Request extends LuvioAdapterRequest<AdapterConfig>, Context> extends RequestStrategy<Request, Context> {
+    abstract adapterName: string;
     abstract adapterFactory: AdapterFactory<AdapterConfig, any>;
     transformForSave(request: Request): Request;
-    reduce(requests: Request[]): Request[];
+    protected filterRequests(unfilteredRequests: LuvioAdapterRequest<unknown>[]): Request[];
+    reduce(unfilteredRequests: LuvioAdapterRequest<unknown>[]): Request[];
 }

package/dist/types/predictive-loading/storage/aura-prefetch-storage.d.ts

@@ -0,0 +1,18 @@
+import { type PrefetchStorage } from '.';
+import { type AuraStorage, type AuraStorageConfig } from '@salesforce/lds-aura-storage';
+export declare const DEFAULT_STORAGE_OPTIONS: {
+    name: string;
+    persistent: boolean;
+    secure: boolean;
+    maxSize: number;
+    expiration: number;
+    clearOnInit: boolean;
+    debugLogging: boolean;
+};
+export declare function buildAuraPrefetchStorage(options?: Partial<AuraStorageConfig>): PrefetchStorage;
+export declare class AuraPrefetchStorage implements PrefetchStorage {
+    private auraStorage;
+    constructor(auraStorage: AuraStorage);
+    set<T>(key: string, value: T): Promise<void>;
+    get<T>(key: string): Promise<T | undefined>;
+}

package/dist/types/predictive-loading/storage/in-memory-prefetch-storage.d.ts

@@ -1,6 +1,6 @@
 import type { PrefetchStorage } from '.';
 export declare class InMemoryPrefetchStorage implements PrefetchStorage {
-    data: Record<string, string>;
-    set(key: string, value: string): Promise<void>;
-    get(key: string): Promise<string | undefined>;
+    data: Record<string, any>;
+    set<T>(key: string, value: T): Promise<void>;
+    get<T>(key: string): Promise<T | undefined>;
 }

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

@@ -1,6 +1,7 @@
 export type PrefetchStorage = {
-    get(key: string): Promise<string | undefined>;
-    set(key: string, value: string): Promise<void>;
+    get<T>(key: string): Promise<T | undefined>;
+    set<T>(key: string, value: T): Promise<void>;
 };
 export * from './in-memory-prefetch-storage';
 export * from './local-prefetch-storage';
+export { buildAuraPrefetchStorage } from './aura-prefetch-storage';

package/dist/types/predictive-loading/storage/local-prefetch-storage.d.ts

@@ -2,6 +2,6 @@ import type { PrefetchStorage } from '.';
 export declare class LocalPrefetchStorage implements PrefetchStorage {
     private localStorage;
     constructor(localStorage: typeof window.localStorage);
-    set(key: string, value: string): Promise<void>;
-    get(key: string): Promise<string | undefined>;
+    set<T>(key: string, value: T): Promise<void>;
+    get<T>(key: string): Promise<T | undefined>;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@salesforce/lds-runtime-aura",
-    "version": "1.246.0",
+    "version": "1.248.0",
     "license": "SEE LICENSE IN LICENSE.txt",
     "description": "LDS engine for Aura runtime",
     "main": "dist/ldsEngineCreator.js",
@@ -43,15 +43,15 @@
         "@salesforce/lds-network-fetch-with-jwt": "*"
     },
     "dependencies": {
-        "@luvio/network-adapter-composable": "0.150.6"
+        "@luvio/network-adapter-composable": "0.151.1"
     },
     "luvioBundlesize": [
         {
             "path": "./dist/ldsEngineCreator.js",
             "maxSize": {
-                "none": "50 kB",
-                "min": "22 kB",
-                "compressed": "10 kB"
+                "none": "60 kB",
+                "min": "28 kB",
+                "compressed": "12 kB"
             }
         }
     ],